5 (+/%#)\ 1 2 3 4 5 5 4 3 2 1 NB. not a solution for this task
3 3.8 4.2 4.2 3.8 3

In the context of the task, we need to produce a stateful function to consume streams. Since J does not have native lexical closure, we need to [http://www.jsoftware.com/jwiki/Guides/Lexical%20Closure implement it]. Thus the [[Talk:Averages/Simple_moving_average#J_Implementation|streaming solution]] is more complex:

   lex =:  1 :'(a[n__a=.m#_.[a=.18!:3$~0)&(4 :''(+/%#)(#~1-128!:5)n__x=.1|.!.y n__x'')'

'''Example:'''

   sma =: 5 lex
   sma&> 1 2 3 4 5 5 4 3 2 1
1 1.5 2 2.5 3 3.8 4.2 4.2 3.8 3

Here, the &> is analogous to the "for each" of other languages.

Or, a more traditional approach could be used:

avg=: +/ % #
SEQ=:''
moveAvg=:4 :0"0
   SEQ=:SEQ,y
   avg ({.~ x -@<. #) SEQ
)

   5 moveAvg 1 2 3 4 5 5 4 3 2 1
1 1.5 2 2.5 3 3.8 4.2 4.2 3.8 3

Java

{{works with|Java|1.5+}}

import java.util.LinkedList;
import java.util.Queue;

public class MovingAverage {
    private final Queue<Double> window = new LinkedList<Double>();
    private final int period;
    private double sum;

    public MovingAverage(int period) {
        assert period > 0 : "Period must be a positive integer";
        this.period = period;
    }

    public void newNum(double num) {
        sum += num;
        window.add(num);
        if (window.size() > period) {
            sum -= window.remove();
        }
    }

    public double getAvg() {
        if (window.isEmpty()) return 0.0; // technically the average is undefined
        return sum / window.size();
    }

    public static void main(String[] args) {
        double[] testData = {1, 2, 3, 4, 5, 5, 4, 3, 2, 1};
        int[] windowSizes = {3, 5};
        for (int windSize : windowSizes) {
            MovingAverage ma = new MovingAverage(windSize);
            for (double x : testData) {
                ma.newNum(x);
                System.out.println("Next number = " + x + ", SMA = " + ma.getAvg());
            }
            System.out.println();
        }
    }
}

{{out}}

Next number = 1.0, SMA = 1.0
Next number = 2.0, SMA = 1.5
Next number = 3.0, SMA = 2.0
Next number = 4.0, SMA = 3.0
Next number = 5.0, SMA = 4.0
Next number = 5.0, SMA = 4.666666666666667
Next number = 4.0, SMA = 4.666666666666667
Next number = 3.0, SMA = 4.0
Next number = 2.0, SMA = 3.0
Next number = 1.0, SMA = 2.0

Next number = 1.0, SMA = 1.0
Next number = 2.0, SMA = 1.5
Next number = 3.0, SMA = 2.0
Next number = 4.0, SMA = 2.5
Next number = 5.0, SMA = 3.0
Next number = 5.0, SMA = 3.8
Next number = 4.0, SMA = 4.2
Next number = 3.0, SMA = 4.2
Next number = 2.0, SMA = 3.8
Next number = 1.0, SMA = 3.0

JavaScript

Using for loop

function simple_moving_averager(period) {
    var nums = [];
    return function(num) {
        nums.push(num);
        if (nums.length > period)
            nums.splice(0,1);  // remove the first element of the array
        var sum = 0;
        for (var i in nums)
            sum += nums[i];
        var n = period;
        if (nums.length < period)
            n = nums.length;
        return(sum/n);
    }
}

var sma3 = simple_moving_averager(3);
var sma5 = simple_moving_averager(5);
var data = [1,2,3,4,5,5,4,3,2,1];
for (var i in data) {
    var n = data[i];
    // using WSH
    WScript.Echo("Next number = " + n + ", SMA_3 = " + sma3(n) + ", SMA_5 = " + sma5(n));
}

{{out}}

Next number = 1, SMA_3 = 1, SMA_5 = 1
Next number = 2, SMA_3 = 1.5, SMA_5 = 1.5
Next number = 3, SMA_3 = 2, SMA_5 = 2
Next number = 4, SMA_3 = 3, SMA_5 = 2.5
Next number = 5, SMA_3 = 4, SMA_5 = 3
Next number = 5, SMA_3 = 4.666666666666667, SMA_5 = 3.8
Next number = 4, SMA_3 = 4.666666666666667, SMA_5 = 4.2
Next number = 3, SMA_3 = 4, SMA_5 = 4.2
Next number = 2, SMA_3 = 3, SMA_5 = 3.8
Next number = 1, SMA_3 = 2, SMA_5 = 3

Using reduce/filter

[http://jsfiddle.net/79xe381e/ JS Fiddle]

// single-sided
Array.prototype.simpleSMA=function(N) {
return this.map(
  function(el,index, _arr) {
      return _arr.filter(
      function(x2,i2) {
        return i2 <= index && i2 > index - N;
        })
      .reduce(
      function(current, last, index, arr){
        return (current + last);
        })/index || 1;
      });
};

g=[0,1,2,3,4,5,6,7,8,9,10];
console.log(g.simpleSMA(3));
console.log(g.simpleSMA(5));
console.log(g.simpleSMA(g.length));

{{out}}

[1, 1, 1.5, 2, 2.25, 2.4, 2.5, 2.5714285714285716, 2.625, 2.6666666666666665, 2.7]
[1, 1, 1.5, 2, 2.5, 3, 3.3333333333333335, 3.5714285714285716, 3.75, 3.888888888888889, 4]
[1, 1, 1.5, 2, 2.5, 3, 3.5, 4, 4.5, 5, 5.5]

Julia

The function wants specified the type of the data in the buffer and, if you want, the limit of the buffer.

```julia
function movingaverage(::Type{T} = Float64; lim::Integer = -1) where T<:Real
	buffer = Vector{T}(0)
	if lim == -1
		# unlimited buffer
		return (y::T) -> begin
			push!(buffer, y)
			return mean(buffer)
		end
	else
		# limited size buffer
		return (y) -> begin
			push!(buffer, y)
			if length(buffer) > lim shift!(buffer) end
			return mean(buffer)
		end
	end
end

test = movingaverage()
@show test(1.0) # mean([1])
@show test(2.0) # mean([1, 2])
@show test(3.0) # mean([1, 2, 3])

{{out}}

test(1.0) = 1.0
test(2.0) = 1.5
test(3.0) = 2.0

K

Non-stateful:

  v:v,|v:1+!5
  v
1 2 3 4 5 5 4 3 2 1

  avg:{(+/x)%#x}
  sma:{avg'x@(,\!y),(1+!y)+\:!y}

  sma[v;5]
1 1.5 2 2.5 3 3.8 4.2 4.2 3.8 3

Stateful:

  sma:{n::x#_n; {n::1_ n,x; {avg x@&~_n~'x} n}}

  sma[5]' v
1 1.5 2 2.5 3 3.8 4.2 4.2 3.8 3

Kotlin

// version 1.0.6

fun initMovingAverage(p: Int): (Double) -> Double {
    if (p < 1) throw IllegalArgumentException("Period must be a positive integer")
    val list = mutableListOf<Double>()
    return {
        list.add(it)
        if (list.size > p) list.removeAt(0)
        list.average()
    }
}

fun main(args: Array<String>) {
    val sma4 = initMovingAverage(4)
    val sma5 = initMovingAverage(5)
    val numbers = listOf(1.0, 2.0, 3.0, 4.0, 5.0, 5.0, 4.0, 3.0, 2.0, 1.0)
    println("num\tsma4\tsma5\n")
    for (number in numbers) println("${number}\t${sma4(number)}\t${sma5(number)}")
}

{{out}}

num     sma4    sma5

1.0     1.0     1.0
2.0     1.5     1.5
3.0     2.0     2.0
4.0     2.5     2.5
5.0     3.5     3.0
5.0     4.25    3.8
4.0     4.5     4.2
3.0     4.25    4.2
2.0     3.5     3.8
1.0     2.5     3.0

Lasso

{{incorrect|Lasso|routine is called with a list of multiple numbers rather than being called with individual numbers in succession.}}

define simple_moving_average(a::array,s::integer)::decimal => {
	#a->size == 0 ? return 0.00
	#s == 0 ? return 0.00
	#a->size == 1 ? return decimal(#a->first)
	#s == 1 ? return decimal(#a->last)
	local(na = array)
	if(#a->size <= #s) => {
		#na = #a
	else
		local(ar = #a->ascopy)
		#ar->reverse
		loop(#s) => { #na->insert(#ar->get(loop_count)) }
	}
	#s > #na->size ? #s = #na->size
	return (with e in #na sum #e) / decimal(#s)
}
// tests:
'SMA 3 on array(1,2,3,4,5,5,4,3,2,1): '
simple_moving_average(array(1,2,3,4,5,5,4,3,2,1),3)

'\rSMA 5 on array(1,2,3,4,5,5,4,3,2,1): '
simple_moving_average(array(1,2,3,4,5,5,4,3,2,1),5)

'\r\rFurther example: \r'
local(mynumbers = array, sma_num = 5)
loop(10) => {^
	#mynumbers->insert(integer_random(1,100))
	#mynumbers->size + ' numbers: ' + #mynumbers
	 ' SMA3 is: ' + simple_moving_average(#mynumbers,3)
	 ', SMA5 is: ' + simple_moving_average(#mynumbers,5)
	'\r'
^}

{{out}}

SMA 3 on array(1,2,3,4,5,5,4,3,2,1): 2.000000
SMA 5 on array(1,2,3,4,5,5,4,3,2,1): 3.000000

Further example:
1 numbers: array(91) SMA3 is: 91.000000, SMA5 is: 91.000000
2 numbers: array(91, 30) SMA3 is: 60.500000, SMA5 is: 60.500000
3 numbers: array(91, 30, 99) SMA3 is: 73.333333, SMA5 is: 73.333333
4 numbers: array(91, 30, 99, 73) SMA3 is: 67.333333, SMA5 is: 73.250000
5 numbers: array(91, 30, 99, 73, 22) SMA3 is: 64.666667, SMA5 is: 63.000000
6 numbers: array(91, 30, 99, 73, 22, 35) SMA3 is: 43.333333, SMA5 is: 51.800000
7 numbers: array(91, 30, 99, 73, 22, 35, 93) SMA3 is: 50.000000, SMA5 is: 64.400000
8 numbers: array(91, 30, 99, 73, 22, 35, 93, 24) SMA3 is: 50.666667, SMA5 is: 49.400000
9 numbers: array(91, 30, 99, 73, 22, 35, 93, 24, 8) SMA3 is: 41.666667, SMA5 is: 36.400000
10 numbers: array(91, 30, 99, 73, 22, 35, 93, 24, 8, 80) SMA3 is: 37.333333, SMA5 is: 48.000000

Liberty BASIC

The interesting thing here is how to implement an equivalent of a stateful function. For sample output see http://libertybasic.conforums.com/index.cgi?board=open&action=display&num=1322956720

    dim v$( 100)                                                            '   Each array term stores a particular SMA of period p in p*10 bytes

    nomainwin

    WindowWidth  =1080
    WindowHeight = 780

    graphicbox #w.gb1,   20,   20, 1000,  700

    open "Running averages to smooth data" for window as #w

    #w "trapclose quit"

    #w.gb1 "down"

    old.x         =  0
    old.y.orig    =500  '   black
    old.y.3.SMA   =350  '     red
    old.y.20.SMA  =300  '   green

    for i =0 to 999 step 1
        scan
        v       =1.1 +sin( i /1000 *2 *3.14159265) + 0.2 *rnd( 1)               '   sin wave with added random noise
        x       =i /6.28318 *1000
        y.orig  =500 -v /2.5 *500

        #w.gb1 "color black ; down ; line "; i-1; " "; old.y.orig;  " "; i; " "; y.orig;         " ; up"

        y.3.SMA =500 -SMA( 1, v,  3) /2.5 *500                                  '   SMA given ID of 1 is to do 3-term  running average
        #w.gb1 "color red   ; down ; line "; i-1; " "; old.y.3.SMA +50;  " "; i; " "; y.3.SMA  +50;  " ; up"

        y.20.SMA =500 -SMA( 2, v, 20) /2.5 *500                                 '   SMA given ID of 2 is to do 20-term running average
        #w.gb1 "color green ; down ; line "; i-1; " "; old.y.20.SMA +100; " "; i; " "; y.20.SMA +100; " ; up"

        'print "Supplied with "; v; ", so SMAs are now "; using( "###.###", SMA( 1, v, 3)); " over 3 terms or "; using( "###.###", SMA( 2, v, 5)) ; " over 5 terms."  '   ID, latest data, period

        old.y.orig    =y.orig
        old.y.3.SMA   =y.3.SMA
        old.y.20.SMA  =y.20.SMA
    next i

    wait

sub quit j$
    close #w
    end
end sub



function SMA( ID, Number, Period)
    v$( ID) =right$( "          " +str$( Number), 10) +v$( ID)              '   add new number at left, lose last number on right
    v$( ID) =left$( v$( ID), Period *10)
    'print "{"; v$( ID); "}",

    k      =0   '   number of terms read
    total  =0   '   sum of terms read

    do
        p$     =mid$( v$( ID), 1 +k *10, 10)
        if p$ ="" then exit do
        vv     =val( p$)
        total  =total +vv
        k      =k +1
    loop until p$ =""

    if k <Period then SMA =total / k else  SMA =total /Period
end function

Logo

Although Logo does not support closures, some varieties of Logo support enough metaprogramming to accomplish this task.

{{works with|UCB Logo}}

UCB Logo has a DEFINE primitive to construct functions from structured instruction lists. In addition, UCB Logo supports a compact template syntax for quoting lists (backquote "`") and replacing components of quoted lists (comma ","). These facilities can be used together in order to create templated function-defining-functions.

to average :l
  output quotient apply "sum :l count :l
end

to make.sma :name :period
  localmake "qn word :name ".queue
  make :qn []
  define :name `[ [n]              ; parameter list
    [if equal? count :,:qn ,:period [ignore dequeue ",:qn]]
    [queue ",:qn :n]
    [output average :,:qn]
  ]
end

make.sma "avg3 3

show map "avg3 [1 2 3 4 5]     ; [1 1.5 2 3 4]

show text "avg3     ; examine what substitutions took place
[[n] [if equal? count :avg3.queue 3 [ignore dequeue "avg3.queue]] [queue "avg3.queue :n] [output average :avg3.queue]]

; the internal queue is in the global namespace, easy to inspect
show :avg3.queue    ; [3 4 5]

If namespace pollution is a concern, UCB Logo supplies a GENSYM command to obtain unique names in order to avoid collisions.

  ...
  localmake "qn word :name gensym
  ...

; list user-defined functions and variables
show procedures     ; [average avg3 make.sma]
show names          ; [[[] [avg3.g1]]

Lua

function sma(period)
	local t = {}
	function sum(a, ...)
		if a then return a+sum(...) else return 0 end
	end
	function average(n)
		if #t == period then table.remove(t, 1) end
		t[#t + 1] = n
		return sum(unpack(t)) / #t
	end
	return average
end

sma5 = sma(5)
sma10 = sma(10)
print("SMA 5")
for v=1,15 do print(sma5(v)) end
print("\nSMA 10")
for v=1,15 do print(sma10(v)) end

=={{header|Mathematica}} / {{header|Wolfram Language}}== This version uses a list entry so it can use the built-in function.

MA[x_List, r_] := Join[Table[Mean[x[[1;;y]]],{y,r-1}], MovingAverage[x,r]]

This version is stateful instead.

MAData = {{}, 0};
MAS[x_, t_: Null] :=
 With[{r = If[t === Null, MAData[[2]], t]},
  Mean[MAData[[1]] =
    If[Length[#] > (MAData[[2]] = r), #[[-r ;; -1]], #] &@
     Append[MAData[[1]], x]]]

Tests:

MA[{1, 2, 3, 4, 5, 5, 4, 3, 2, 1}, 5]
=> {1, 3/2, 2, 5/2, 3, 19/5, 21/5, 21/5, 19/5, 3}

MAS[1, 5]  => 1
MAS[2]     => 3/2
MAS[3]     => 2
MAS[4]     => 5/2
MAS[5]     => 3
MAS[5]     => 19/5
MAS[4]     => 21/5
MAS[3]     => 21/5
MAS[2]     => 19/5
MAS[1]     => 3

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

Matlab and Octave provide very efficient and fast functions, that can be applied to vectors (i.e. series of data samples)

 [m,z] = filter(ones(1,P),P,x);

m is the moving average, z returns the state at the end of the data series, which can be used to continue the moving average.

 [m,z] = filter(ones(1,P),P,x,z);

Mercury

In Mercury, an idiomatic "moving averages" function would be 'stateless' - or rather, it would have ''explicit state'' that its callers would have to thread through uses of it:

    % state(period, list of floats from [newest, ..., oldest])
:- type state ---> state(int, list(float)).

:- func init(int) = state.
init(Period) = state(Period, []).

:- pred sma(float::in, float::out, state::in, state::out) is det.
sma(N, Average, state(P, L0), state(P, L)) :-
        take_upto(P, [N|L0], L),
        Average = foldl((+), L, 0.0) / float(length(L)).

Some notes about this solution: unless P = 0, length(L) can never be 0, as L always incorporates at least N (a step that is accomplished in the arguments to list.take_upto/3). If the implementation of the 'state' type is hidden, and if init/1 checks for P = 0, users of this code can never cause a division-by-zero error in sma/4. Although this solution doesn't try to be as stateful as the task description would like, explicit state is by far simpler and more natural and more straightforward than the alternative in Mercury. Finally, [http://www.mercury.csse.unimelb.edu.au/information/doc-release/mercury_ref/State-variables.html#State-variables state variables] (and higher-order functions that anticipate threaded state) remove much of the potential ugliness or error in threading the same state through many users.

MiniScript

We define an SMA class, which can be configured with the desired window size (P).

SMA = {}
SMA.P = 5  // (a default; may be overridden)
SMA.buffer = null
SMA.next = function(n)
    if self.buffer == null then self.buffer = []
    self.buffer.push n
    if self.buffer.len > self.P then self.buffer.pull
    return self.buffer.sum / self.buffer.len
end function

sma3 = new SMA
sma3.P = 3
sma5 = new SMA

for i in range(10)
    num = round(rnd*100)
    print "num: " + num + "  sma3: " + sma3.next(num) + "  sma5: " + sma5.next(num)
end for

{{out}}

num: 81 sma3: 81 sma5: 81
num: 82 sma3: 81.5 sma5: 81.5
num: 78 sma3: 80.333333 sma5: 80.333333
num: 54 sma3: 71.333333 sma5: 73.75
num: 94 sma3: 75.333333 sma5: 77.8
num: 8 sma3: 52 sma5: 63.2
num: 40 sma3: 47.333333 sma5: 54.8
num: 98 sma3: 48.666667 sma5: 58.8
num: 48 sma3: 62 sma5: 57.6
num: 41 sma3: 62.333333 sma5: 47
num: 94 sma3: 61 sma5: 64.2

NetRexx

{{trans|Java}}

/* NetRexx */
options replace format comments java crossref symbols nobinary

numeric digits 20

class RAvgSimpleMoving public

  properties private
    window = java.util.Queue
    period
    sum

  properties constant
    exMsg = 'Period must be a positive integer'

  -- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  method RAvgSimpleMoving(period_) public
    if \period_.datatype('w') then signal RuntimeException(exMsg)
    if period_ <= 0           then signal RuntimeException(exMsg)
    window = LinkedList()
    period = period_
    sum    = 0
    return

  -- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  method newNum(num) public
    sum = sum + num
    window.add(num)
    if window.size() > period then do
      rmv = (Rexx window.remove())
      sum = sum - rmv
      end
    return

  -- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  method getAvg() public returns Rexx
    if window.isEmpty() then do
      avg = 0
      end
    else do
      avg = sum / window.size()
      end
    return avg

  -- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  method run_samples(args = String[]) public static
    testData = [Rexx 1, 2, 3, 4, 5, 5, 4, 3, 2, 1]
    windowSizes = [Rexx 3, 5]
    loop windSize over windowSizes
      ma = RAvgSimpleMoving(windSize)
      loop xVal over testData
        ma.newNum(xVal)
        say 'Next number =' xVal.right(5)', SMA =' ma.getAvg().format(10, 9)
        end xVal
      say
      end windSize

    return

  -- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  method main(args = String[]) public static
    run_samples(args)
    return

{{out}}

Next number =   1.0, SMA =          1.000000000
Next number =   2.0, SMA =          1.500000000
Next number =   3.0, SMA =          2.000000000
Next number =   4.0, SMA =          3.000000000
Next number =   5.0, SMA =          4.000000000
Next number =   5.0, SMA =          4.666666667
Next number =   4.0, SMA =          4.666666667
Next number =   3.0, SMA =          4.000000000
Next number =   2.0, SMA =          3.000000000
Next number =   1.0, SMA =          2.000000000

Next number =   1.0, SMA =          1.000000000
Next number =   2.0, SMA =          1.500000000
Next number =   3.0, SMA =          2.000000000
Next number =   4.0, SMA =          2.500000000
Next number =   5.0, SMA =          3.000000000
Next number =   5.0, SMA =          3.800000000
Next number =   4.0, SMA =          4.200000000
Next number =   3.0, SMA =          4.200000000
Next number =   2.0, SMA =          3.800000000
Next number =   1.0, SMA =          3.000000000


```



## Nim


```nim
import queues

proc simplemovingaverage(period: int): auto =
  assert period > 0

  var
    summ, n = 0.0
    values = initQueue[float]()
  for i in 1..period:
    values.add(0)

  proc sma(x: float): float =
    values.add(x)
    summ += x - values.dequeue()
    n = min(n+1, float(period))
    result = summ / n

  return sma

var sma = simplemovingaverage(3)
for i in 1..5: echo sma(float(i))
for i in countdown(5,1): echo sma(float(i))

echo ""

var sma2 = simplemovingaverage(5)
for i in 1..5: echo sma2(float(i))
for i in countdown(5,1): echo sma2(float(i))
```

{{out}}

```txt
1.0000000000000000e+00
1.5000000000000000e+00
2.0000000000000000e+00
3.0000000000000000e+00
4.0000000000000000e+00
4.6666666666666670e+00
4.6666666666666670e+00
4.0000000000000000e+00
3.0000000000000000e+00
2.0000000000000000e+00

1.0000000000000000e+00
1.5000000000000000e+00
2.0000000000000000e+00
2.5000000000000000e+00
3.0000000000000000e+00
3.7999999999999998e+00
4.2000000000000002e+00
4.2000000000000002e+00
3.7999999999999998e+00
3.0000000000000000e+00
```



## Objeck

{{trans|Java}}

```objeck

use Collection;

class MovingAverage {
  @window : FloatQueue;
  @period : Int;
  @sum : Float;

  New(period : Int) {
    @window := FloatQueue->New();
    @period := period;
  }

  method : NewNum(num : Float) ~ Nil {
    @sum += num;
    @window->Add(num);
    if(@window->Size() > @period) {
      @sum -= @window->Remove();
    };
  }

  method : GetAvg() ~ Float {
    if(@window->IsEmpty()) {
      return 0; # technically the average is undefined
    };

    return @sum / @window->Size();
  }

  function : Main(args : String[]) ~ Nil {
    testData := [1.0, 2.0, 3.0, 4.0, 5.0, 5.0, 4.0, 3.0, 2.0, 1.0];
    windowSizes := [3.0, 5.0];

    each(i : windowSizes) {
      windSize := windowSizes[i];
      ma := MovingAverage->New(windSize);
      each(j : testData) {
        x := testData[j];
        ma->NewNum(x);
        avg := ma->GetAvg();
        "Next number = {$x}, SMA = {$avg}"->PrintLine();
      };
      IO.Console->PrintLine();
    };
  }
}

```


{{out}}

```txt

Next number = 1.0, SMA = 1.0
Next number = 2.0, SMA = 1.500
Next number = 3.0, SMA = 2.0
Next number = 4.0, SMA = 3.0
Next number = 5.0, SMA = 4.0
Next number = 5.0, SMA = 4.667
Next number = 4.0, SMA = 4.667
Next number = 3.0, SMA = 4.0
Next number = 2.0, SMA = 3.0
Next number = 1.0, SMA = 2.0

Next number = 1.0, SMA = 1.0
Next number = 2.0, SMA = 1.500
Next number = 3.0, SMA = 2.0
Next number = 4.0, SMA = 2.500
Next number = 5.0, SMA = 3.0
Next number = 5.0, SMA = 3.800
Next number = 4.0, SMA = 4.200
Next number = 3.0, SMA = 4.200
Next number = 2.0, SMA = 3.800
Next number = 1.0, SMA = 3.0

```


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


```objc>#import  period) {
		NSNumber *n = window[0];
		sum -= [n doubleValue];
		[window removeObjectAtIndex:0];
	}
}

// get the average value
- (double)avg {
	if([window count] == 0) {
		return 0; // technically the average is undefined
	}
	return sum / [window count];
}

// set the period, resizes current window
- (void)setPeriod:(unsigned int)thePeriod {
	// make smaller?
	if(thePeriod < [window count]) {
		for(int i = 0; i < thePeriod; ++i) {
			NSNumber *n = window[0];
			sum -= [n doubleValue];
			[window removeObjectAtIndex:0];
		}
	}
	period = thePeriod;
}

// get the period (window size)
- (unsigned int)period {
	return period;
}

// clear the window and current sum
- (void)clear {
	[window removeAllObjects];
	sum = 0;
}

@end

int main (int argc, const char * argv[]) {
	@autoreleasepool {
		double testData[10] = {1,2,3,4,5,5,4,3,2,1};
		int periods[2] = {3,5};
		for(int i = 0; i < 2; ++i) {
			MovingAverage *ma = [[MovingAverage alloc] initWithPeriod:periods[i]];
			for(int j = 0; j < 10; ++j) {
				[ma add:testData[j]];
				NSLog(@"Next number = %f, SMA = %f", testData[j], [ma avg]);
			}
			NSLog(@"\n");
		}
	}
	return 0;
}
```


{{out}}

```txt

Next number = 1.000000, SMA = 1.000000
Next number = 2.000000, SMA = 1.500000
Next number = 3.000000, SMA = 2.000000
Next number = 4.000000, SMA = 3.000000
Next number = 5.000000, SMA = 4.000000
Next number = 5.000000, SMA = 4.666667
Next number = 4.000000, SMA = 4.666667
Next number = 3.000000, SMA = 4.000000
Next number = 2.000000, SMA = 3.000000
Next number = 1.000000, SMA = 2.000000

Next number = 1.000000, SMA = 1.000000
Next number = 2.000000, SMA = 1.500000
Next number = 3.000000, SMA = 2.000000
Next number = 4.000000, SMA = 2.500000
Next number = 5.000000, SMA = 3.000000
Next number = 5.000000, SMA = 3.800000
Next number = 4.000000, SMA = 4.200000
Next number = 3.000000, SMA = 4.200000
Next number = 2.000000, SMA = 3.800000
Next number = 1.000000, SMA = 3.000000

```



## OCaml


```ocaml
let sma (n, s, q) x =
  let l = Queue.length q and s = s +. x in
  Queue.push x q;
  if l < n then
    (n, s, q), s /. float (l + 1)
  else (
    let s = s -. Queue.pop q in
    (n, s, q), s /. float l
  )

let _ =
  let periodLst = [ 3; 5 ] in
  let series = [ 1.; 2.; 3.; 4.; 5.; 5.; 4.; 3.; 2.; 1. ] in

  List.iter (fun d ->
    Printf.printf "SIMPLE MOVING AVERAGE: PERIOD = %d\n" d;
    ignore (
      List.fold_left (fun o x ->
	let o, m = sma o x in
	Printf.printf "Next number = %-2g, SMA = %g\n" x m;
	o
      ) (d, 0., Queue.create ()) series;
    );
    print_newline ();
  ) periodLst
```


{{out}}

```txt

SIMPLE MOVING AVERAGE: PERIOD = 3
Next number = 1 , SMA = 1
Next number = 2 , SMA = 1.5
Next number = 3 , SMA = 2
Next number = 4 , SMA = 3
Next number = 5 , SMA = 4
Next number = 5 , SMA = 4.66667
Next number = 4 , SMA = 4.66667
Next number = 3 , SMA = 4
Next number = 2 , SMA = 3
Next number = 1 , SMA = 2

SIMPLE MOVING AVERAGE: PERIOD = 5
Next number = 1 , SMA = 1
Next number = 2 , SMA = 1.5
Next number = 3 , SMA = 2
Next number = 4 , SMA = 2.5
Next number = 5 , SMA = 3
Next number = 5 , SMA = 3.8
Next number = 4 , SMA = 4.2
Next number = 3 , SMA = 4.2
Next number = 2 , SMA = 3.8
Next number = 1 , SMA = 3

```


More imperatively:

```ocaml
let sma_create period =
  let q = Queue.create ()
  and sum = ref 0.0 in
  fun x ->
    sum := !sum +. x;
    Queue.push x q;
    if Queue.length q > period then
      sum := !sum -. Queue.pop q;
    !sum /. float (Queue.length q)

let () =
  let periodLst = [ 3; 5 ] in
  let series = [ 1.; 2.; 3.; 4.; 5.; 5.; 4.; 3.; 2.; 1. ] in

  List.iter (fun d ->
    Printf.printf "SIMPLE MOVING AVERAGE: PERIOD = %d\n" d;
    let sma = sma_create d in
    List.iter (fun x ->
      Printf.printf "Next number = %-2g, SMA = %g\n" x (sma x);
    ) series;
    print_newline ();
  ) periodLst
```



## Oforth


createSMA returns a closure.
The list of values is included into a channel so this code is thread-safe : multiple tasks running in parallel can call the closure returned.


```oforth
import: parallel

: createSMA(period)
| ch |
   Channel new [ ] over send drop ->ch
   #[ ch receive + left(period) dup avg swap ch send drop ] ;
```


Usage:


```oforth
: test
| sma3 sma5 l |
   3 createSMA -> sma3
   5 createSMA -> sma5
   [ 1, 2, 3, 4, 5, 5, 4, 3, 2, 1 ] ->l
   "SMA3" .cr l apply( #[ sma3 perform . ] ) printcr
   "SMA5" .cr l apply( #[ sma5 perform . ] ) ;
```


{{out}}

```txt

>test
SMA3
1 1.5 2 3 4 4.66666666666667 4.66666666666667 4 3 2
SMA5
1 1.5 2 2.5 3 3.8 4.2 4.2 3.8 3 ok

```



## ooRexx

ooRexx does not have stateful functions, but the same effect can be achieved by using object instances.

```ooRexx

testdata = .array~of(1, 2, 3, 4, 5, 5, 4, 3, 2, 1)

-- run with different period sizes
loop period over .array~of(3, 5)
    say "Period size =" period
    say
    movingaverage = .movingaverage~new(period)
    loop number over testdata
        average = movingaverage~addnumber(number)
        say "   Next number =" number", moving average =" average
    end
    say
end

::class movingaverage
::method init
  expose period queue sum
  use strict arg period
  sum = 0
  -- the circular queue makes this easy
  queue = .circularqueue~new(period)

-- add a number to the average set
::method addNumber
  expose queue sum
  use strict arg number
  sum += number
  -- add this to the queue
  old = queue~queue(number)
  -- if we pushed an element off the end of the queue,
  -- subtract this from our sum
  if old \= .nil then sum -= old
  -- and return the current item
  return sum / queue~items

-- extra method to retrieve current average
::method average
  expose queue sum
  -- undefined really, but just return 0
  if queue~isempty then return 0
  -- return current queue
  return sum / queue~items

```

{{out}}

```txt

Period size = 3

   Next number = 1, moving average = 1
   Next number = 2, moving average = 1.5
   Next number = 3, moving average = 2
   Next number = 4, moving average = 3
   Next number = 5, moving average = 4
   Next number = 5, moving average = 4.66666667
   Next number = 4, moving average = 4.66666667
   Next number = 3, moving average = 4
   Next number = 2, moving average = 3
   Next number = 1, moving average = 2

Period size = 5

   Next number = 1, moving average = 1
   Next number = 2, moving average = 1.5
   Next number = 3, moving average = 2
   Next number = 4, moving average = 2.5
   Next number = 5, moving average = 3
   Next number = 5, moving average = 3.8
   Next number = 4, moving average = 4.2
   Next number = 3, moving average = 4.2
   Next number = 2, moving average = 3.8
   Next number = 1, moving average = 3

```



## OxygenBasic


```oxygenbasic
def max 1000

Class MovingAverage
'
### ============


indexbase 1
double average,invperiod,mdata[max]
sys    index,period

method Setup(double a,p)
sys i
Period=p
invPeriod=1/p
index=0
average=a
for i=1 to period
  mdata[i]=a
next
end method

method Data(double v) as double
sys i
index++
if index>period then index=1 'recycle
i=index+1 'for oldest data
if i>period then i=1 'recycle
mdata[index]=v
average=average+invperiod*(v-mdata[i])
end method

end class

'TEST
'====

MovingAverage A

A.Setup 100,10 'initial value and period

A.data 50
'...
print A.average 'reult 95

```



## Oz


```oz
declare

  fun {CreateSMA Period}
     Xs = {NewCell nil}
  in
     fun {$ X}
        Xs := {List.take X|@Xs Period}

        {FoldL @Xs Number.'+' 0.0}
        /
        {Int.toFloat {Min Period {Length @Xs}}}
     end
  end

in

  for Period in [3 5] do
     SMA = {CreateSMA Period}
  in
     {System.showInfo "\nSTART PERIOD "#Period}
     for I in 1..5 do
        {System.showInfo "  Number = "#I#" , SMA = "#{SMA {Int.toFloat I}}}
     end
     for I in 5..1;~1 do
        {System.showInfo "  Number = "#I#" , SMA = "#{SMA {Int.toFloat I}}}
     end
  end
```



## PARI/GP

Partial implementation: does not (yet?) create different stores on each invocation.

```parigp
sma_per(n)={
  sma_v=vector(n);
  sma_i = 0;
  n->if(sma_i++>#sma_v,sma_v[sma_i=1]=n;0,sma_v[sma_i]=n;0)+sum(i=1,#sma_v,sma_v[i])/#sma_v
};
```


## Pascal

{{works with|Free Pascal}}
Like in other implementations the sum of the last p values is only updated by subtracting the oldest value and addindg the new. To minimize rounding errors after p values the sum is corrected to the real sum.

```Pascal
program sma;
type
  tsma = record
            smaValue : array of double;
            smaAverage,
            smaSumOld,
            smaSumNew,
            smaRezActLength : double;
            smaActLength,
            smaLength,
            smaPos   :NativeInt;
            smaIsntFull: boolean;
         end;

procedure smaInit(var sma:tsma;p: NativeUint);
Begin
  with sma do
  Begin
    setlength(smaValue,0);
    setlength(smaValue,p);
    smaLength:= p;
    smaActLength := 0;
    smaAverage:= 0.0;
    smaSumOld := 0.0;
    smaSumNew := 0.0;
    smaPos := p-1;
    smaIsntFull := true
    end;
end;

function smaAddValue(var sma:tsma;v: double):double;
Begin
  with sma do
  Begin
    IF smaIsntFull then
    Begin
      inc(smaActLength);
      smaRezActLength := 1/smaActLength;
      smaIsntFull :=  smaActLength < smaLength ;
    end;
    smaSumOld := smaSumOld+v-smaValue[smaPos];
    smaValue[smaPos] := v;
    smaSumNew := smaSumNew+v;

    smaPos := smaPos-1;
    if smaPos < 0 then
    begin
      smaSumOld:= smaSumNew;
      smaSumNew:= 0.0;
      smaPos := smaLength-1;
    end;
    smaAverage := smaSumOld *smaRezActLength;
    smaAddValue:= smaAverage;
  end;
end;

var
 sma3,sma5:tsma;
 i : LongInt;
begin
  smaInit(sma3,3);
  smaInit(sma5,5);
  For i := 1 to 5 do
  Begin
    write('Inserting ',i,' into sma3 ',smaAddValue(sma3,i):0:4);
    writeln(' Inserting ',i,' into sma5 ',smaAddValue(sma5,i):0:4);
  end;
  For i := 5 downto 1 do
  Begin
    write('Inserting ',i,' into sma3 ',smaAddValue(sma3,i):0:4);
    writeln(' Inserting ',i,' into sma5 ',smaAddValue(sma5,i):0:4);
  end;
  //speed test
  smaInit(sma3,3);
  For i := 1 to 100000000 do
    smaAddValue(sma3,i);
  writeln('100''000''000 insertions ',sma3.smaAverage:0:4);
end.
```

;output:

```txt

time ./sma
Inserting 1 into sma3 1.0000 Inserting 1 into sma5 1.0000
Inserting 2 into sma3 1.5000 Inserting 2 into sma5 1.5000
Inserting 3 into sma3 2.0000 Inserting 3 into sma5 2.0000
Inserting 4 into sma3 3.0000 Inserting 4 into sma5 2.5000
Inserting 5 into sma3 4.0000 Inserting 5 into sma5 3.0000
Inserting 5 into sma3 4.6667 Inserting 5 into sma5 3.8000
Inserting 4 into sma3 4.6667 Inserting 4 into sma5 4.2000
Inserting 3 into sma3 4.0000 Inserting 3 into sma5 4.2000
Inserting 2 into sma3 3.0000 Inserting 2 into sma5 3.8000
Inserting 1 into sma3 2.0000 Inserting 1 into sma5 3.0000
100'000'000 insertions 99999999.0000

real  0m0.780s { 64-Bit }
```


## Perl


Using an initializer function which returns an anonymous closure which closes over an instance ''(separate for each call to the initializer!)'' of the lexical variables $period, @list, and $sum:


```perl
sub sma_generator {
    my $period = shift;
    my (@list, $sum);

    return sub {
        my $number = shift;
        push @list, $number;
        $sum += $number;
        $sum -= shift @list if @list > $period;
        return $sum / @list;
    }
}

# Usage:
my $sma = sma_generator(3);
for (1, 2, 3, 2, 7) {
    printf "append $_ --> sma = %.2f  (with period 3)\n", $sma->($_);
}
```


{{out}}

```txt

append 1 --> sma = 1.00  (with period 3)
append 2 --> sma = 1.50  (with period 3)
append 3 --> sma = 2.00  (with period 3)
append 2 --> sma = 2.33  (with period 3)
append 7 --> sma = 4.00  (with period 3)

```



## Perl 6


{{works with|Rakudo|2016.08}}

```perl6
sub sma-generator (Int $P where * > 0) {
    sub ($x) {
        state @a = 0 xx $P;
        @a.push($x).shift;
        @a.sum / $P;
    }
}

# Usage:
my &sma = sma-generator 3;

for 1, 2, 3, 2, 7 {
    printf "append $_ --> sma = %.2f  (with period 3)\n", sma $_;
}
```


{{out}}

```txt

append 1 --> sma = 0.33  (with period 3)
append 2 --> sma = 1.00  (with period 3)
append 3 --> sma = 2.00  (with period 3)
append 2 --> sma = 2.33  (with period 3)
append 7 --> sma = 4.00  (with period 3)

```



## Phix

First create a separate file sma.e to encapsulate the private variables. Note in particular the complete lack of any special magic/syntax: it is just a table with some indexes.

```Phix

sequence sma = {}       -- {{period,history,circnxt}}  (private to sma.e)
integer sma_free = 0

global function new_sma(integer period)
integer res
    if sma_free then
        res = sma_free
        sma_free = sma[sma_free]
        sma[res] = {period,{},0}
    else
        sma = append(sma,{period,{},0})
        res = length(sma)
    end if
    return res
end function

global procedure add_sma(integer sidx, atom val)
integer period, circnxt
sequence history
    {period,history,circnxt} = sma[sidx]
    sma[sidx][2] = 0 -- (kill refcount)
    if length(history)period then
            circnxt = 1
        end if
        sma[sidx][3] = circnxt
        history[circnxt] = val
    end if
    sma[sidx][2] = history
end procedure

global function get_sma_average(integer sidx)
sequence history = sma[sidx][2]
integer l = length(history)
    if l=0 then return 0 end if
    return sum(history)/l
end function

global function moving_average(integer sidx, atom val)
    add_sma(sidx,val)
    return get_sma_average(sidx)
end function

global procedure free_sma(integer sidx)
    sma[sidx] = sma_free
    sma_free = sidx
end procedure
```

and the main file is:

```Phix
include sma.e

constant sma3 = new_sma(3)
constant sma5 = new_sma(5)
constant s = {1,2,3,4,5,5,4,3,2,1}
integer si

for i=1 to length(s) do
    si = s[i]
    printf(1,"%2g: sma3=%8g, sma5=%8g\n",{si,moving_average(sma3,si),moving_average(sma5,si)})
end for
```

{{out}}

```txt

 1: sma3=       1, sma5=       1
 2: sma3=     1.5, sma5=     1.5
 3: sma3=       2, sma5=       2
 4: sma3=       3, sma5=     2.5
 5: sma3=       4, sma5=       3
 5: sma3= 4.66667, sma5=     3.8
 4: sma3= 4.66667, sma5=     4.2
 3: sma3=       4, sma5=     4.2
 2: sma3=       3, sma5=     3.8
 1: sma3=       2, sma5=       3

```



## PicoLisp


```PicoLisp
(de sma (@Len)
   (curry (@Len (Data)) (N)
      (push 'Data N)
      (and (nth Data @Len) (con @))  # Truncate
      (*/ (apply + Data) (length Data)) ) )
```


```PicoLisp
(def 'sma3 (sma 3))
(def 'sma5 (sma 5))

(scl 2)
(for N (1.0 2.0 3.0 4.0 5.0 5.0 4.0 3.0 2.0 1.0)
   (prinl
      (format N *Scl)
      "   (sma3) "
      (format (sma3 N) *Scl)
      "   (sma5) "
      (format (sma5 N) *Scl) ) )
```

{{out}}

```txt
1.00   (sma3) 1.00   (sma5) 1.00
2.00   (sma3) 1.50   (sma5) 1.50
3.00   (sma3) 2.00   (sma5) 2.00
4.00   (sma3) 3.00   (sma5) 2.50
5.00   (sma3) 4.00   (sma5) 3.00
5.00   (sma3) 4.67   (sma5) 3.80
4.00   (sma3) 4.67   (sma5) 4.20
3.00   (sma3) 4.00   (sma5) 4.20
2.00   (sma3) 3.00   (sma5) 3.80
1.00   (sma3) 2.00   (sma5) 3.00
```



## PL/I


### version 1


```pli
SMA: procedure (N) returns (float byaddr);
   declare N fixed;
   declare A(*) fixed controlled,
           (p, q) fixed binary static initial (0);

   if allocation(A) = 0 then signal error;

   p = p + 1; if q < 20 then q = q + 1;
   if p > hbound(A, 1) then p = 1;
   A(p) = N;
   return (sum(float(A))/q);

I: ENTRY (Period);
   declare Period fixed binary;

   if allocation(A) > 0 then FREE A;
   allocate A(Period);
   A = 0;
   p = 0;
end SMA;
```


### version 2

{{trans|REXX}}

```pli
*process source attributes xref;
 mat: Proc Options(main);
 Dcl a(10) Dec Fixed(8,6);
 Dcl s     Dec Fixed(10,8);
 Dcl n Bin Fixed(31) init(hbound(a)); /* number of items in the list. */
 Dcl p Bin Fixed(31) init(3);         /* the 1st period               */
 Dcl q Bin Fixed(31) init(5);         /* the 2nd period               */
 Dcl m Bin Fixed(31);
 Call i(a);

 Put Edit('            SMA with   SMA with',
          '  number    period 3   period 5',
          ' --------  ---------- ----------')
         (Skip,a);
 Do m=1 To n;
   Put Edit(m,sma(p,m),sma(q,m))(Skip,f(5),2(f(13,6)));
   End;

 i: Proc(a);
 Dcl a(*) Dec Fixed(8,6);
 Dcl (j,m) Bin Fixed(31);
 Do j=1 To hbound(a)/2;
   a(j)=j;                            /* ··· increasing values.       */
   End;
 Do k=hbound(a)/2 To 1 By -1;
   a(j)=k;                            /* ··· decreasing values.       */
   j+=1;
   End;
 End;

 sma: Proc(p,j) Returns(Dec Fixed(8,6));
 Dcl s Dec fixed(8,6) Init(0);
 Dcl i Bin Fixed(31) Init(0);
 Dcl j Bin Fixed(31) Init((hbound(a)+1));
 Dcl (p,i,k,ka,kb) Bin Fixed(31);
   ka=max(1,j-p+1);
   kb=j+p;
   Do k=ka To kb While(k<=j);
     i+=1;
     s+=a(k)
     End;
   s=s/i+0.5e-6;
   Return(s);
 End;
 End;
```

 {{out}}

```txt
            SMA with   SMA with
  number    period 3   period 5
 --------  ---------- ----------
    1     1.000000     1.000000
    2     1.500000     1.500000
    3     2.000000     2.000000
    4     3.000000     2.500000
    5     4.000000     3.000000
    6     4.666667     3.800000
    7     4.666667     4.200000
    8     4.000000     4.200000
    9     3.000000     3.800000
   10     2.000000     3.000000
```



## PureBasic


```PureBasic
Procedure.d SMA(Number, Period=0)
  Static P
  Static NewList L()
  Protected Sum=0
  If Period<>0
    P=Period
  EndIf
  LastElement(L())
  AddElement(L())
  L()=Number
  While ListSize(L())>P
    FirstElement(L())
    DeleteElement(L(),1)
  Wend
  ForEach L()
    sum+L()
  Next
  ProcedureReturn sum/ListSize(L())
EndProcedure
```



## Python

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

Both implementations use the [http://www.doughellmann.com/PyMOTW/collections/index.html deque] datatype.

### Procedural


```python
from collections import deque

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

    summ = n = 0.0
    values = deque([0.0] * period)     # old value queue

    def sma(x):
        nonlocal summ, n

        values.append(x)
        summ += x - values.popleft()
        n = min(n+1, period)
        return summ / n

    return sma
```



### Class based


```python
from collections import deque

class Simplemovingaverage():
    def __init__(self, period):
        assert period == int(period) and period > 0, "Period must be an integer >0"
        self.period = period
        self.stream = deque()

    def __call__(self, n):
        stream = self.stream
        stream.append(n)    # appends on the right
        streamlength = len(stream)
        if streamlength > self.period:
            stream.popleft()
            streamlength -= 1
        if streamlength == 0:
            average = 0
        else:
            average = sum( stream ) / streamlength

        return average
```


'''Tests'''

```python
if __name__ == '__main__':
    for period in [3, 5]:
        print ("\nSIMPLE MOVING AVERAGE (procedural): PERIOD =", period)
        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):
            print ("  Next number = %-2g, SMA = %g " % (i, sma(i)))
    for period in [3, 5]:
        print ("\nSIMPLE MOVING AVERAGE (class based): PERIOD =", period)
        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):
            print ("  Next number = %-2g, SMA = %g " % (i, sma(i)))
```


{{out}}

```txt
SIMPLE MOVING AVERAGE (procedural): PERIOD = 3
  Next number = 1 , SMA = 1
  Next number = 2 , SMA = 1.5
  Next number = 3 , SMA = 2
  Next number = 4 , SMA = 3
  Next number = 5 , SMA = 4
  Next number = 5 , SMA = 4.66667
  Next number = 4 , SMA = 4.66667
  Next number = 3 , SMA = 4
  Next number = 2 , SMA = 3
  Next number = 1 , SMA = 2

SIMPLE MOVING AVERAGE (procedural): PERIOD = 5
  Next number = 1 , SMA = 1
  Next number = 2 , SMA = 1.5
  Next number = 3 , SMA = 2
  Next number = 4 , SMA = 2.5
  Next number = 5 , SMA = 3
  Next number = 5 , SMA = 3.8
  Next number = 4 , SMA = 4.2
  Next number = 3 , SMA = 4.2
  Next number = 2 , SMA = 3.8
  Next number = 1 , SMA = 3

SIMPLE MOVING AVERAGE (class based): PERIOD = 3
  Next number = 1 , SMA = 1
  Next number = 2 , SMA = 1.5
  Next number = 3 , SMA = 2
  Next number = 4 , SMA = 3
  Next number = 5 , SMA = 4
  Next number = 5 , SMA = 4.66667
  Next number = 4 , SMA = 4.66667
  Next number = 3 , SMA = 4
  Next number = 2 , SMA = 3
  Next number = 1 , SMA = 2

SIMPLE MOVING AVERAGE (class based): PERIOD = 5
  Next number = 1 , SMA = 1
  Next number = 2 , SMA = 1.5
  Next number = 3 , SMA = 2
  Next number = 4 , SMA = 2.5
  Next number = 5 , SMA = 3
  Next number = 5 , SMA = 3.8
  Next number = 4 , SMA = 4.2
  Next number = 3 , SMA = 4.2
  Next number = 2 , SMA = 3.8
  Next number = 1 , SMA = 3
```



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

```R
#concat concatenates the new values to the existing vector of values, then discards any values that are too old.
lastvalues <- local(
{
   values <- c();
   function(x, len)
   {
      values <<- c(values, x);
      lenv <- length(values);
      if(lenv > len) values <<- values[(len-lenv):-1]
      values
   }
})

#moving.average accepts a numeric scalars input (and optionally a length, i.e. the number of values to retain) and calculates the stateful moving average.
moving.average <- function(latestvalue, len=3)
{
   #Check that all inputs are numeric scalars
   is.numeric.scalar <- function(x) is.numeric(x) && length(x)==1L
   if(!is.numeric.scalar(latestvalue) || !is.numeric.scalar(len))
   {
      stop("all arguments must be numeric scalars")
   }

   #Calculate mean of variables so far
   mean(lastvalues(latestvalue, len))
}
moving.average(5)  # 5
moving.average(1)  # 3
moving.average(-3) # 1
moving.average(8)  # 2
moving.average(7)  # 4
```



## Racket


```Racket
#lang racket

(require data/queue)

(define (simple-moving-average period)
  (define queue (make-queue))
  (define sum 0.0)

  (lambda (x)
    (enqueue! queue x)
    (set! sum (+ sum x))
    (when (> (queue-length queue) period)
      (set! sum (- sum (dequeue! queue))))
    (/ sum (queue-length queue))))

;; Tests
(define sma3 (simple-moving-average 3))
(define sma5 (simple-moving-average 5))
(for/lists (lst1 lst2)
           ([i '(1 2 3 4 5 5 4 3 2 1)])
  (values (sma3 i) (sma5 i)))

```



## REXX

The same list of numbers was used as in the   '''ALGOL68'''   example.

The 1st and 2nd periods (number of values) were parametrized,   as well as the total number of values.

```rexx
/*REXX program illustrates and displays a simple moving average using a constructed list*/
parse arg p q n .                                /*obtain optional arguments from the CL*/
if p=='' | p==","  then p=  3                    /*Not specified?  Then use the default.*/
if q=='' | q==","  then q=  5                    /* "      "         "   "   "     "    */
if n=='' | n==","  then n= 10                    /* "      "         "   "   "     "    */
@.= 0                                            /*default value, only needed for odd N.*/
      do j=1    for n%2;       @.j= j            /*build 1st half of list, increasing #s*/
      end   /*j*/

      do k=n%2  by -1  to 1;   @.j= k;   j= j+1  /*  "   2nd   "   "   "   decreasing " */
      end   /*k*/

                      say '  number  '     " SMA with period" p' '   " SMA with period" q
                      say ' ──────── '     "───────────────────"     '───────────────────'
                                           pad='     '
      do m=1  for n;  say center(@.m, 10)  pad left(SMA(p, m), 19)     left(SMA(q, m), 19)
      end   /*m*/
exit                                             /*stick a fork in it,  we're all done. */
/*──────────────────────────────────────────────────────────────────────────────────────*/
SMA: procedure expose @.;  parse arg p,j;                          i= 0    ;    $= 0
                 do k=max(1, j-p+1)  to j+p  for p  while k<=j;    i= i + 1;    $= $ + @.k
                 end   /*k*/
     return $/i                                  /*SMA   ≡   simple moving average.     */
```

{{out|output|text=  when using the generated default input numbers:}}

```txt

  number    SMA with period 3   SMA with period 5
 ────────  ─────────────────── ───────────────────
    1            1                   1
    2            1.5                 1.5
    3            2                   2
    4            3                   2.5
    5            4                   3
    5            4.66666667          3.8
    4            4.66666667          4.2
    3            4                   4.2
    2            3                   3.8
    1            2                   3

```



## Ring


### version 1


```ring

load "stdlib.ring"
decimals(8)
maxperiod = 20
nums = newlist(maxperiod,maxperiod)
accum = list(maxperiod)
index = list(maxperiod)
window = list(maxperiod)
for i = 1 to maxperiod
    index[i] = 1
    accum[i] = 0
    window[i] = 0
next
for i = 1 to maxperiod
    for j = 1 to maxperiod
        nums[i][j] = 0
    next
next
for n = 1 to 5
    see "number = " + n + "  sma3 = " + left((string(sma(n,3)) + "        "),9) + "  sma5 = " + sma(n,5) + nl
next
for n = 5 to 1 step -1
    see "number = " + n + "  sma3 = " + left((string(sma(n,3)) + "        "),9) + "  sma5 = " + sma(n,5) + nl
next
see nl

func sma number, period
     accum[period] += number - nums[period][index[period]]
     nums[period][index[period]] = number
     index[period]= (index[period] + 1) % period + 1
     if window[period] size ? nums.shift : 0
    sum += hello - goodbye
    sum / nums.length
  end
end

ma3 = simple_moving_average(3)
ma5 = simple_moving_average(5)

(1.upto(5).to_a + 5.downto(1).to_a).each do |num|
  printf "Next number = %d, SMA_3 = %.3f, SMA_5 = %.1f\n",
    num, ma3.call(num), ma5.call(num)
end
```


A class

```ruby
class MovingAverager
  def initialize(size)
    @size = size
    @nums = []
    @sum = 0.0
  end
  def <<(hello)
    @nums << hello
    goodbye = @nums.length > @size ? @nums.shift : 0
    @sum += hello - goodbye
    self
  end
  def average
    @sum / @nums.length
  end
  alias to_f average
  def to_s
    average.to_s
  end
end

ma3 = MovingAverager.new(3)
ma5 = MovingAverager.new(5)

(1.upto(5).to_a + 5.downto(1).to_a).each do |num|
  printf "Next number = %d, SMA_3 = %.3f, SMA_5 = %.1f\n",
    num, ma3 << num, ma5 <
}

impl SimpleMovingAverage {
    fn new(p: usize) -> SimpleMovingAverage {
        SimpleMovingAverage {
            period: p,
            numbers: Vec::new()
        }
    }

    fn add_number(&mut self, number: usize) -> f64 {
        self.numbers.push(number);

        if self.numbers.len() > self.period {
            self.numbers.remove(0);
        }

        if self.numbers.is_empty() {
            return 0f64;
        }else {
            let sum = self.numbers.iter().fold(0, |acc, x| acc+x);
            return sum as f64 / self.numbers.len() as f64;
        }
    }
}

fn main() {
    for period in [3, 5].iter() {
        println!("Moving average with period {}", period);

        let mut sma = SimpleMovingAverage::new(*period);
        for i in [1, 2, 3, 4, 5, 5, 4, 3, 2, 1].iter() {
            println!("Number: {} | Average: {}", i, sma.add_number(*i));
        }
    }
}
```


===Double-ended Queue Based===

```rust
use std::collections::VecDeque;

struct SimpleMovingAverage {
    period: usize,
    numbers: VecDeque
}

impl SimpleMovingAverage {
    fn new(p: usize) -> SimpleMovingAverage {
        SimpleMovingAverage {
            period: p,
            numbers: VecDeque::new()
        }
    }

    fn add_number(&mut self, number: usize) -> f64 {
        self.numbers.push_back(number);

        if self.numbers.len() > self.period {
            self.numbers.pop_front();
        }

        if self.numbers.is_empty() {
            return 0f64;
        }else {
            let sum = self.numbers.iter().fold(0, |acc, x| acc+x);
            return sum as f64 / self.numbers.len() as f64;
        }
    }
}

fn main() {
    for period in [3, 5].iter() {
        println!("Moving average with period {}", period);

        let mut sma = SimpleMovingAverage::new(*period);
        for i in [1, 2, 3, 4, 5, 5, 4, 3, 2, 1].iter() {
            println!("Number: {} | Average: {}", i, sma.add_number(*i));
        }
    }
}
```



```txt
Moving average with period 3
Number: 1 | Average: 1
Number: 2 | Average: 1.5
Number: 3 | Average: 2
Number: 4 | Average: 3
Number: 5 | Average: 4
Number: 5 | Average: 4.666666666666667
Number: 4 | Average: 4.666666666666667
Number: 3 | Average: 4
Number: 2 | Average: 3
Number: 1 | Average: 2
Moving average with period 5
Number: 1 | Average: 1
Number: 2 | Average: 1.5
Number: 3 | Average: 2
Number: 4 | Average: 2.5
Number: 5 | Average: 3
Number: 5 | Average: 3.8
Number: 4 | Average: 4.2
Number: 3 | Average: 4.2
Number: 2 | Average: 3.8
Number: 1 | Average: 3

```



## Run Basic


```runbasic
data 1,2,3,4,5,5,4,3,2,1
dim sd(10)                          ' series data
global sd                           ' make it global so we all see it
for i = 1 to 10:read sd(i): next i

x = sma(3)                          ' simple moving average for 3 periods
x = sma(5)                          ' simple moving average for 5 periods

function sma(p)                     ' the simple moving average function
print "----- SMA:";p;" -----"
  for i = 1 to 10
    sumSd = 0
    for j = max((i - p) + 1,1) to i
      sumSd = sumSd + sd(j)         ' sum series data for the period
    next j
  if p > i then p1 = i else p1 = p
  print  sd(i);" sma:";p;" ";sumSd / p1
  next i
end function
```


```txt
----- SMA:3 -----
1 sma:3 1
2 sma:3 1.5
3 sma:3 2
4 sma:3 3
5 sma:3 4
5 sma:3 4.6666665
4 sma:3 4.6666665
3 sma:3 4
2 sma:3 3
1 sma:3 2
----- SMA:5 -----
1 sma:5 1
2 sma:5 1.5
3 sma:5 2
4 sma:5 2.5
5 sma:5 3
5 sma:5 3.79999995
4 sma:5 4.1999998
3 sma:5 4.1999998
2 sma:5 3.79999995
1 sma:5 3
```



## Scala


```scala
class MovingAverage(period: Int) {
  private var queue = new scala.collection.mutable.Queue[Double]()
  def apply(n: Double) = {
    queue.enqueue(n)
    if (queue.size > period)
      queue.dequeue
    queue.sum / queue.size
  }
  override def toString = queue.mkString("(", ", ", ")")+", period "+period+", average "+(queue.sum / queue.size)
  def clear = queue.clear
}
```



```txt

scala> List(3,5) foreach { period =>
     |   println("SIMPLE MOVING AVERAGE: PERIOD = "+period)
     |   val sma = new MovingAverage(period)
     |   1.0 to 5.0 by 1.0 foreach {i => println("  Next number = %-2g, SMA = %g " format (i, sma(i)))}
     |   5.0 to 1.0 by -1.0 foreach {i => println("  Next number = %-2g, SMA = %g " format (i, sma(i)))}
     |   println(sma+"\n")
     | }
SIMPLE MOVING AVERAGE: PERIOD = 3
  Next number = 1.00000, SMA = 1.00000
  Next number = 2.00000, SMA = 1.50000
  Next number = 3.00000, SMA = 2.00000
  Next number = 4.00000, SMA = 3.00000
  Next number = 5.00000, SMA = 4.00000
  Next number = 5.00000, SMA = 4.66667
  Next number = 4.00000, SMA = 4.66667
  Next number = 3.00000, SMA = 4.00000
  Next number = 2.00000, SMA = 3.00000
  Next number = 1.00000, SMA = 2.00000
(3.0, 2.0, 1.0), period 3, average 2.0

SIMPLE MOVING AVERAGE: PERIOD = 5
  Next number = 1.00000, SMA = 1.00000
  Next number = 2.00000, SMA = 1.50000
  Next number = 3.00000, SMA = 2.00000
  Next number = 4.00000, SMA = 2.50000
  Next number = 5.00000, SMA = 3.00000
  Next number = 5.00000, SMA = 3.80000
  Next number = 4.00000, SMA = 4.20000
  Next number = 3.00000, SMA = 4.20000
  Next number = 2.00000, SMA = 3.80000
  Next number = 1.00000, SMA = 3.00000
(5.0, 4.0, 3.0, 2.0, 1.0), period 5, average 3.0

```



## Scheme


```scheme
(define ((simple-moving-averager size . nums) num)
  (set! nums (cons num (if (= (length nums) size) (reverse (cdr (reverse nums))) nums)))
  (/ (apply + nums) (length nums)))

(define av (simple-moving-averager 3))
(map av '(1 2 3 4 5 5 4 3 2 1))

```

{{out}}

```txt

(1 3/2 2 3 4 14/3 14/3 4 3 2)

```




## Sidef

Implemented with closures:

```ruby
func simple_moving_average(period) {

    var list = []
    var sum = 0

    func (number) {
        list.append(number)
        sum += number
        if (list.len > period) {
            sum -= list.shift
        }
        (sum / list.length)
    }
}

var ma3 = simple_moving_average(3)
var ma5 = simple_moving_average(5)

for num (1..5, flip(1..5)) {
  printf("Next number = %d, SMA_3 = %.3f, SMA_5 = %.1f\n",
    num, ma3.call(num), ma5.call(num))
}
```


Implemented as a class:

```ruby
class sma_generator(period, list=[], sum=0) {

    method SMA(number) {
        list.append(number)
        sum += number
        if (list.len > period) {
            sum -= list.shift
        }
        (sum / list.len)
    }
}

var ma3 = sma_generator(3)
var ma5 = sma_generator(5)

for num (1..5, flip(1..5)) {
  printf("Next number = %d, SMA_3 = %.3f, SMA_5 = %.1f\n",
    num, ma3.SMA(num), ma5.SMA(num))
}
```


{{out}}

```txt

Next number = 1, SMA_3 = 1.000, SMA_5 = 1.0
Next number = 2, SMA_3 = 1.500, SMA_5 = 1.5
Next number = 3, SMA_3 = 2.000, SMA_5 = 2.0
Next number = 4, SMA_3 = 3.000, SMA_5 = 2.5
Next number = 5, SMA_3 = 4.000, SMA_5 = 3.0
Next number = 5, SMA_3 = 4.667, SMA_5 = 3.8
Next number = 4, SMA_3 = 4.667, SMA_5 = 4.2
Next number = 3, SMA_3 = 4.000, SMA_5 = 4.2
Next number = 2, SMA_3 = 3.000, SMA_5 = 3.8
Next number = 1, SMA_3 = 2.000, SMA_5 = 3.0

```



## Smalltalk

{{works with|GNU Smalltalk}}


```smalltalk
Object subclass: MovingAverage [
    |valueCollection period collectedNumber sum|
    MovingAverage class >> newWithPeriod: thePeriod [
	|r|
	r := super basicNew.
	^ r initWithPeriod: thePeriod
    ]
    initWithPeriod: thePeriod [
    	valueCollection := OrderedCollection new: thePeriod.
	period := thePeriod.
	collectedNumber := 0.
	sum := 0
    ]
    sma [   collectedNumber < period
            ifTrue: [ ^ sum / collectedNumber ]
            ifFalse: [ ^ sum / period ] ]
    add: value [
        collectedNumber < period
   	ifTrue: [
	   sum := sum + value.
	   valueCollection add: value.
	   collectedNumber := collectedNumber + 1.
	]
	ifFalse: [
	   sum := sum - (valueCollection removeFirst).
	   sum := sum + value.
	   valueCollection add: value
	].
	^ self sma
    ]
].
```



```smalltalk
|sma3 sma5|

sma3 := MovingAverage newWithPeriod: 3.
sma5 := MovingAverage newWithPeriod: 5.

#( 1 2 3 4 5 5 4 3 2 1 ) do: [ :v |
  ('Next number %1, SMA_3 = %2, SMA_5 = %3' % {
         v . (sma3 add: v) asFloat . (sma5 add: v) asFloat
    }) displayNl
]
```



## Tcl

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

```tcl
oo::class create SimpleMovingAverage {
    variable vals idx
    constructor {{period 3}} {
        set idx end-[expr {$period-1}]
        set vals {}
    }
    method val x {
        set vals [lrange [list {*}$vals $x] $idx end]
        expr {[tcl::mathop::+ {*}$vals]/double([llength $vals])}
    }
}
```

Demonstration:

```tcl
SimpleMovingAverage create averager3
SimpleMovingAverage create averager5 5
foreach n {1 2 3 4 5 5 4 3 2 1} {
    puts "Next number = $n, SMA_3 = [averager3 val $n], SMA_5 = [averager5 val $n]"
}
```

{{out}}

```txt
Next number = 1, SMA_3 = 1.0, SMA_5 = 1.0
Next number = 2, SMA_3 = 1.5, SMA_5 = 1.5
Next number = 3, SMA_3 = 2.0, SMA_5 = 2.0
Next number = 4, SMA_3 = 3.0, SMA_5 = 2.5
Next number = 5, SMA_3 = 4.0, SMA_5 = 3.0
Next number = 5, SMA_3 = 4.666666666666667, SMA_5 = 3.8
Next number = 4, SMA_3 = 4.666666666666667, SMA_5 = 4.2
Next number = 3, SMA_3 = 4.0, SMA_5 = 4.2
Next number = 2, SMA_3 = 3.0, SMA_5 = 3.8
Next number = 1, SMA_3 = 2.0, SMA_5 = 3.0
```


=={{header|TI-83 BASIC}}==

Continuously prompts for an input I, which is added to the end of a list L1.  L1 can be found by pressing "2ND"/"1", and mean can be found in "List"/"OPS"

Press ON to terminate the program.


```ti83b
:1->C
:While 1
:Prompt I
:C->dim(L1)
:I->L1(C)
:Disp mean(L1)
:1+C->C
:End
```


=={{header|TI-89 BASIC}}==


Function that returns a list containing the averaged data of the supplied argument

```ti89b
movinavg(list,p)
Func
  Local r, i, z

  For i,1,dim(list)
    max(i-p,0)→z
    sum(mid(list,z+1,i-z))/(i-z)→r[i]
  EndFor
  r
EndFunc


```


Program that returns a simple value at each invocation:

```ti89b
movinav2(x_,v_)
Prgm
  If getType(x_)="STR" Then
    {}→list
    v_→p
    Return
  EndIf

  right(augment(list,{x_}),p)→list
  sum(list)/dim(list)→#v_
EndPrgm

```


Example1: Using the function

movinavg({1,2,3,4,5,6,7,8,9,10},5)


list is the list being averaged: {1,2,3,4,5,6,7,8,9,10}

p is the period: 5

returns the averaged list: {1, 3/2, 2, 5/2, 3, 4, 5, 6, 7, 8}



Example 2: Using the program

movinav2("i",5)  - Initializing moving average calculation, and define period of 5

movinav2(3, "x"):x - new data in the list (value 3), and result will be stored on variable x, and displayed

movinav2(4, "x"):x - new data (value 4), and the new result will be stored on variable x, and displayed (4+3)/2

...




Description of the function movinavg:

variable r - is the result (the averaged list) that will be returned

variable i - is the index variable, and it points to the end of the sub-list the list being averaged.

variable z - an helper variable



The function uses variable i to determine which values of the list will be considered in the next average calculation.

At every iteration, variable i points to the last value in the list that will be used in the average calculation.

So we only need to figure out which will be the first value in the list.

Usually we'll have to consider p elements, so the first element will be the one indexed by (i-p+1).

However on the first iterations that calculation will usually be negative, so the following equation will avoid negative indexes: max(i-p+1,1) or, arranging the equation, max(i-p,0)+1.

But the number of elements on the first iterations will also be smaller, the correct value will be (end index - begin index + 1)   or, arranging the equation,   (i - (max(i-p,0)+1) +1) ,and then,  (i-max(i-p,0)).

Variable z holds the common value (max(i-p),0) so the begin_index will be (z+1) and the number_of_elements will be (i-z)


mid(list,z+1, i-z) will return the list of value that will be averaged

sum(...) will sum them

sum(...)/(i-z) → r[i] will average them and store the result in the appropriate place in the result list



## VBA

This is a "simple" moving average.

```vb
Class sma
'to be stored in a class module with name "sma"
Private n As Integer 'period
Private arr() As Double 'circular list
Private index As Integer 'pointer into arr
Private oldsma As Double

Public Sub init(size As Integer)
    n = size
    ReDim arr(n - 1)
    index = 0
End Sub

Public Function sma(number As Double) As Double
    sma = oldsma + (-arr(index) + number) / n
    oldsma = sma
    arr(index) = number
    index = (index + 1) Mod n
End Function

Normal module
Public Sub main()
    s = [{1,2,3,4,5,5,4,3,2,1}]
    Dim sma3 As New sma
    Dim sma5 As New sma
    sma3.init 3
    sma5.init 5
    For i = 1 To UBound(s)
        Debug.Print i, Format(sma3.sma(CDbl(s(i))), "0.00000"),
        Debug.Print Format(sma5.sma(CDbl(s(i))), "0.00000")
    Next i
End Sub
```
{{out}}

```txt
 1            0,33333       0,20000
 2            1,00000       0,60000
 3            2,00000       1,20000
 4            3,00000       2,00000
 5            4,00000       3,00000
 6            4,66667       3,80000
 7            4,66667       4,20000
 8            4,00000       4,20000
 9            3,00000       3,80000
 10           2,00000       3,00000
```


## VBScript


```vb
data = "1,2,3,4,5,5,4,3,2,1"
token = Split(data,",")
stream = ""
WScript.StdOut.WriteLine "Number" & vbTab & "SMA3" & vbTab & "SMA5"
For j = LBound(token) To UBound(token)
	If Len(stream) = 0 Then
		stream = token(j)
	Else
		stream = stream & "," & token(j)
	End If
	WScript.StdOut.WriteLine token(j) & vbTab & Round(SMA(stream,3),2) & vbTab & Round(SMA(stream,5),2)
Next

Function SMA(s,p)
	If Len(s) = 0 Then
		SMA = 0
		Exit Function
	End If
	d = Split(s,",")
	sum = 0
	If UBound(d) + 1 >= p Then
		c = 0
		For i = UBound(d) To LBound(d) Step -1
			sum = sum + Int(d(i))
			c = c + 1
			If c = p Then
				Exit For
			End If
		Next
		SMA = sum / p
	Else
		For i = UBound(d) To LBound(d) Step -1
			sum = sum + Int(d(i))
		Next
		SMA = sum / (UBound(d) + 1)
	End If
End Function
```


{{Out}}

```txt

Number	        SMA3	        SMA5
1		1		1
2		1.5		1.5
3		2		2
4		3		2.5
5		4		3
5		4.67	        3.8
4		4.67	        4.2
3		4		4.2
2		3		3.8
1		2		3

```



## zkl


```zkl
fcn SMA(P){
   fcn(n,ns,P){
      sz:=ns.append(n.toFloat()).len();
      if(P>sz) return(0.0);
      if(P