Averages/Simple moving average: Difference between revisions

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

 

 

Create a [[wp:Stateful|stateful]] function/class/instance that takes a period and returns a routine that takes a number as argument and returns a simple moving average of its arguments so far.

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

{{trans|D}}

[Float] data

sum = 0.0

 

L(e) [1, 2, 3, 4, 5, 5, 4, 3, 2, 1]

{{out}}

<pre>

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

{{trans|PL/I}}

AVGSMA CSECT

USING AVGSMA,R12

EDMASK DC X'4020202020202021204B202020' CL13

YREGS

{{out}}

<pre>

 

moving.ads:

Max_Elements : Positive;

type Number is digits <>;

function Moving_Average (N : Number) return Number;

function Get_Average return Number;

 

moving.adb:

 

package body Moving is

end Moving_Average;

 

 

main.adb:

with Moving;

procedure Main is

" into max-5: " & Float'Image (Five_Average.Moving_Average (Float (I))));

end loop;

 

{{out}}

<!-- {{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: This following code is a direct translation of the [[Average/Simple_moving_average#C|C]] code sample. It mimics C's var_list implementation, and so it probably isn't the most natural way of dong this actual task in '''ALGOL 68'''.

LONG REAL sma,

LONG REAL sum,

sma(SMAFREE(h5))

#

{{out}}

<pre>

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

# Moving average over the first column of a data file

BEGIN {

Z[i] = x;

print MA;

 

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

{{works with|BBC BASIC for Windows}}

FOR n = 1 TO 5

PRINT "Number = ";n TAB(12) " SMA3 = ";FNsma(n,3) TAB(30) " SMA5 = ";FNsma(n,5)

index%(period%) = (index%(period%) + 1) MOD period%

IF window%(period%)<period% window%(period%) += 1

{{out}}

<pre>

Number = 1 SMA3 = 2 SMA5 = 3

</pre>

 

=={{header|Bracmat}}==

= buffer

. (new$=):?freshEmptyBuffer

$ (str$(!k " - sma3:" pad$(sma3$!k) " sma5:" pad$(sma5$!k)))

)

{{out}}

<pre>1 - sma3: 1 sma5: 1

=={{header|Brat}}==

Object version

SMA = object.new

 

[1, 2, 3, 4, 5, 5, 4, 3, 2, 1].each { n |

p n, " - SMA3: ", sma3.add(n), " SMA5: ", sma5.add(n)

 

Function version

 

list = []

 

[1, 2, 3, 4, 5, 5, 4, 3, 2, 1].each { n |

p n, " - SMA3: ", sma3(n), " SMA5: ", sma5(n)

 

{{out}}

 

=={{header|C}}==

#include <stdlib.h>

#include <stdarg.h>

va_end(vl);

return r;

 

 

int main()

sma(SMA_FREE, h5);

return 0;

 

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

#include <iostream>

#include <stddef.h>

return 0;

}

 

=={{header|Clojure}}==

This version uses a persistent queue to hold the most recent ''p'' values.

Each function returned from ''init-moving-average'' has its state in an atom holding a queue value.

 

(defn enqueue-max [q p n]

(let [state (atom PersistentQueue/EMPTY)]

(fn [n]

 

=={{header|CoffeeScript}}==

I = (P) ->

# The cryptic name "I" follows the problem description;

for i in [1..10]

console.log i, sma3(i), sma7(i), sma11(i)

{{out}}

<pre>

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

===Using a Closure===

Currently this <code>sma</code> can't be @nogc because it allocates a closure on the heap. Some escape analysis could remove the heap allocation.

 

auto sma(T, int period)() pure nothrow @safe {

foreach (immutable e; [1, 2, 3, 4, 5, 5, 4, 3, 2, 1])

writefln("Added %d, sma(3) = %f, sma(5) = %f", e, s3(e), s5(e));

{{out}}

<pre>Added 1, sma(3) = 1.000000, sma(5) = 1.000000

keeping the data in the stack frame of the main function.

Same output:

 

struct SMA(T, int period) {

foreach (immutable e; [1, 2, 3, 4, 5, 5, 4, 3, 2, 1])

writefln("Added %d, sma(3) = %f, sma(5) = %f", e, s3(e), s5(e));

To avoid the floating point approximations keep piling up and growing, the code could perform a periodic sum on the whole circular queue array.

 

=={{header|Dyalect}}==

{{trans|C#}}

 

var acc = 0.0

var c = 0

acc / c

}

func sma(p) {

var s = []

x => {

}

avg(s)

};

}

var sma3 = sma(3)

var sma5 = sma(5)

for n in nums {

print("\(n)\t(sma3) \(sma3(n))\t(sma5) \(sma5(n))")

 

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

(lib 'tree) ;; queues operations

 

(// (for/sum ((x (queue->list Q))) x) (queue-length Q))))

{{out}}

<pre>

 

=={{header|Elena}}==

import system'collections;

import extensions;

count =>

0 { ^0.0r }

if (count > thePeriod)

{

count := thePeriod

};

^ sum / count

}

}

 

public program()

{

 

};

 

};

console.readChar()

{{out}}

<pre>

The elixir program below generates an anonymous function with an embedded period `p`, which is used as the period of the simple moving average. The `run` function reads numeric input and passes it to the newly created anonymous function, and then "inspects" the result to STDOUT.

 

#!/usr/bin/env elixir

 

end

 

 

elixir ./simple-moving-avg.exs <<EOF

1 2 3 4 5 6 7 8 9 8 7 6 5 4 3 2 1

2 4 6 8 10 12 14 12 10 8 6 4 2

 

The output is shown below, with the average, followed by the grouped input, forming the basis of each moving average.

 

=={{header|Erlang}}==

SMA3 = sma(3),

SMA5 = sma(5),

{average, Ave} ->

Ave

 

{{out}}

Added 1, sma(3) -> 1.000000, sma(5) -> 1.000000

Added 2, sma(3) -> 1.500000, sma(5) -> 1.500000

Added 2, sma(3) -> 3.000000, sma(5) -> 3.800000

Added 1, sma(3) -> 2.000000, sma(5) -> 3.000000

 

Erlang has closures, but immutable variables. A solution then is to use processes and a simple message passing based API.

Matrix languages have routines to compute the gliding avarages for a given sequence of items.

 

>n=1000; m=100; x=random(1,n);

>x10=fold(x,ones(1,m)/m);

>x10=fftfold(x,ones(1,m)/m)[m:n]; // more efficient

 

It is less efficient to loop as in the following commands.

 

>function store (x:number, v:vector, n:index) ...

$if cols(v)<n then return v|x;

>v

[ 11 12 13 14 15 16 17 18 19 20 ]

 

=={{header|F_Sharp|F#}}==

let sma_aux queue v =

let q = Seq.truncate period (v :: queue)

printf "\nsma5: "

[ 1.;2.;3.;4.;5.;5.;4.;3.;2.;1.] |> sma 5 (printf "%.2f ")

{{out}}

<pre>sma3: 1.00 1.50 2.00 3.00 4.00 4.67 4.67 4.00 3.00 2.00

=={{header|Factor}}==

The <code>I</code> word creates a quotation (anonymous function) that closes over a sequence and a period. This quotation handles adding/removing numbers to the simple moving average (SMA). We can then add a number to the SMA using <code>sma-add</code> and get the SMA's sequence and mean with <code>sma-query</code>. Quotations adhere to the <code>sequence</code> protocol so we can obtain the sequence of numbers simply by calling <code>first</code> on the SMA quotation.

random sequences ;

IN: rosetta-code.simple-moving-avg

] each drop ;

 

{{out}}

<pre>

=={{header|Fantom}}==

 

class MovingAverage

{

}

}

 

{{out}} for a period of 5:

 

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

 

Type FuncType As Function(As Double) As Double

Print

Print "Press any key to quit"

 

{{out}}

 

=={{header|GAP}}==

local sma, buffer, pos, sum, len;

buffer := List([1 .. n], i -> 0);

f(3); # 4

f(2); # 3

=={{header|Go}}==

 

import "fmt"

 

}

}

}

fmt.Printf("%5.3f %5.3f %5.3f\n", x, sma3(x), sma5(x))

}

{{out}}

<pre>

=={{header|Groovy}}==

{{trans|Ruby}}

def nums = []

double total = 0.0

 

(1..5).each{ printf( "%1.1f ", ma5(it)) }

{{out}}

<pre>1.0 1.5 2.0 2.5 3.0 3.8 4.2 4.2 3.8 3.0 </pre>

Conform version to the requirement, function SMA called multiple times with just a number:

{{works with|GHC|6.10.4}}

 

import Control.Monad

mapM_ (str <$> pure n <*> sma3 <*> sma5) series))

where str n mm3 mm5 =

{{out}}

<pre>Next number = 1.0, SMA_3 = 1.0, SMA_5 = 1.0

 

{{works with|GHC|6.10.4}}

import Control.Arrow

import Control.Monad

 

printSMA n p = mapM_ (\(n,a) -> putStrLn $ "Next number: " ++ show n ++ " Average: " ++ show a)

 

Stateful function using the state monad to keep track of state

 

{{works with|GHC|7.8.3}}

import Control.Monad

import Control.Monad.State

main :: IO ()

main = print $ evalState demostrateSMA []

 

{{out}}

 

=={{header|HicEst}}==

 

nums = (1,2,3,4,5, 5,4,3,2,1)

Past(Periods(ID)) = num

SMA = SUM(Past) / MIN( now(ID), Periods(ID) )

<pre>num=1 SMA3=1 SMA5=1

num=2 SMA3=1.5 SMA5=1.5

num=10 SMA3=2 SMA5=3</pre>

 

sma := buildSMA(3) # Use better name than "I".

every write(sma(!A))

}

return (@c, c)

Note: This program uses Unicon specific co-expression calling syntax. It can be easily modified to run under Icon.

 

If the <tt>Utils</tt> package is imported from the [https://tapestry.tucson.az.us/unilib Unicon code library] then a (Unicon only) solution is:

 

 

procedure main(A)

every (avg := 0.0) +:= !stream

return avg / *stream

 

with the sample run:

In that context, moving average is expressed very concisely in J as '''<code>(+/%#)\</code>''', though it is worth noting that this approach does not provide averages for the initial cases where not all data would be available yet:

 

 

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:

'''Example:'''

sma&> 1 2 3 4 5 5 4 3 2 1

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

 

Or, a more traditional approach could be used:

 

SEQ=:''

moveAvg=:4 :0"0

 

5 moveAvg 1 2 3 4 5 5 4 3 2 1

 

=={{header|Java}}==

{{works with|Java|1.5+}}

import java.util.Queue;

 

}

}

{{out}}

<pre>Next number = 1.0, SMA = 1.0

=={{header|JavaScript}}==

===Using for loop===

var nums = [];

return function(num) {

// using WSH

WScript.Echo("Next number = " + n + ", SMA_3 = " + sma3(n) + ", SMA_5 = " + sma5(n));

{{out}}

<pre>Next number = 1, SMA_3 = 1, SMA_5 = 1

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

 

Array.prototype.simpleSMA=function(N) {

return this.map(

console.log(g.simpleSMA(3));

console.log(g.simpleSMA(5));

{{out}}

<pre>

 

=={{header|Julia}}==

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

buffer = Vector{T}(0)

if lim == -1

@show test(1.0) # mean([1])

@show test(2.0) # mean([1, 2])

 

{{out}}

 

Non-stateful:

v:v,|v:1+!5

v

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

 

=={{header|Kotlin}}==

 

fun initMovingAverage(p: Int): (Double) -> Double {

println("num\tsma4\tsma5\n")

for (number in numbers) println("${number}\t${sma4(number)}\t${sma5(number)}")

 

{{out}}

=={{header|Lasso}}==

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

#a->size == 0 ? return 0.00

#s == 0 ? return 0.00

', SMA5 is: ' + simple_moving_average(#mynumbers,5)

'\r'

 

{{out}}

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

 

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

end function

=={{header|Logo}}==

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

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.

 

output quotient apply "sum :l count :l

end

 

; the internal queue is in the global namespace, easy to inspect

 

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]

 

=={{header|Lua}}==

 

local t = {}

end

function average(n)

if #t == period then table.remove(t, 1) end

t[#t + 1] = n

end

return average

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.

 

This version is stateful instead.

MAS[x_, t_: Null] :=

With[{r = If[t === Null, MAData[[2]], t]},

Mean[MAData[[1]] =

If[Length[#] > (MAData[[2]] = r), #[[-r ;; -1]], #] &@

 

Tests:

 

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

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.

 

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

 

:- type state ---> state(int, list(float)).

 

sma(N, Average, state(P, L0), state(P, L)) :-

take_upto(P, [N|L0], 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.

 

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

SMA.P = 5 // (a default; may be overridden)

SMA.buffer = null

num = round(rnd*100)

print "num: " + num + " sma3: " + sma3.next(num) + " sma5: " + sma5.next(num)

 

{{out}}

num: 41 sma3: 62.333333 sma5: 47

num: 94 sma3: 61 sma5: 64.2</pre>

 

=={{header|NetRexx}}==

{{trans|Java}}

options replace format comments java crossref symbols nobinary

 

run_samples(args)

return

{{out}}

<pre style="height: 25ex; overflow: scroll">

 

=={{header|Nim}}==

 

proc simplemovingaverage(period: int): auto =

var

summ, n = 0.0

for i in 1..period:

 

proc sma(x: float): float =

n = min(n+1, float(period))

result = summ / n

var sma2 = simplemovingaverage(5)

for i in 1..5: echo sma2(float(i))

{{out}}

 

 

=={{header|Objeck}}==

{{trans|Java}}

use Collection;

 

}

}

 

{{out}}

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

 

 

@interface MovingAverage : NSObject {

}

return 0;

 

{{out}}

 

=={{header|OCaml}}==

let l = Queue.length q and s = s +. x in

Queue.push x q;

);

print_newline ();

 

{{out}}

 

More imperatively:

let q = Queue.create ()

and sum = ref 0.0 in

) series;

print_newline ();

 

=={{header|Oforth}}==

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.

 

 

: createSMA(period)

| ch |

Channel new [ ] over send drop ->ch

 

Usage:

 

| sma3 sma5 l |

3 createSMA -> sma3

[ 1, 2, 3, 4, 5, 5, 4, 3, 2, 1 ] ->l

"SMA3" .cr l apply( #[ sma3 perform . ] ) printcr

 

{{out}}

=={{header|ooRexx}}==

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

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

 

-- return current queue

return sum / queue~items

{{out}}

<pre>

 

=={{header|OxygenBasic}}==

 

Class MovingAverage

'...

print A.average 'reult 95

 

=={{header|Oz}}==

 

fun {CreateSMA Period}

{System.showInfo " Number = "#I#" , SMA = "#{SMA {Int.toFloat I}}}

end

 

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

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

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

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

type

tsma = record

smaAddValue(sma3,i);

writeln('100''000''000 insertions ',sma3.smaAverage:0:4);

;output:

<pre>

 

real 0m0.780s { 64-Bit }</pre>

=={{header|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 <code>$period</code>, <code>@list</code>, and <code>$sum</code>:

 

my $period = shift;

my (@list, $sum);

for (1, 2, 3, 2, 7) {

printf "append $_ --> sma = %.2f (with period 3)\n", $sma->($_);

 

{{out}}

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)

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

and the main file is:

{{out}}

<pre>

1: sma3= 2, sma5= 3

</pre>

 

=={{header|PicoLisp}}==

(curry (@Len (Data)) (N)

(push 'Data N)

(and (nth Data @Len) (con @)) # Truncate

(def 'sma5 (sma 5))

 

(format (sma3 N) *Scl)

" (sma5) "

{{out}}

<pre>1.00 (sma3) 1.00 (sma5) 1.00

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

===version 1===

declare N fixed;

declare A(*) fixed controlled,

A = 0;

p = 0;

===version 2===

{{trans|REXX}}

mat: Proc Options(main);

Dcl a(10) Dec Fixed(8,6);

Return(s);

End;

{{out}}

<pre> SMA with SMA with

9 3.000000 3.800000

10 2.000000 3.000000</pre>

 

=={{header|PureBasic}}==

Static P

Static NewList L()

Next

ProcedureReturn sum/ListSize(L())

 

=={{header|Python}}==

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

===Procedural===

 

def simplemovingaverage(period):

return summ / n

 

 

===Class based===

 

class Simplemovingaverage():

average = sum( stream ) / streamlength

 

 

'''Tests'''

for period in [3, 5]:

print ("\nSIMPLE MOVING AVERAGE (procedural): PERIOD =", period)

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

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

 

{{out}}

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

 

=={{header|Racket}}==

 

(require data/queue)

([i '(1 2 3 4 5 5 4 3 2 1)])

(values (sma3 i) (sma5 i)))

 

=={{header|REXX}}==

 

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

parse arg p q n . /*obtain optional arguments from the CL*/

if p=='' | p=="," then p= 3 /*Not specified? Then use the default.*/

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 ' ──────── ' "───────────────────" '───────────────────'

do k=max(1, j-p+1) to j+p for p while k<=j; i= i + 1; $= $ + @.k

end /*k*/

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

<pre>

=={{header|Ring}}==

===version 1===

load "stdlib.ring"

decimals(8)

if window[period]<period window[period] += 1 ok

return (accum[period] / window[period])

Output:

<pre>

 

===version 2===

load "stdlib.ring"

decimals(8)

if window[period]<period window[period] += 1 ok

return (accum[period] / window[period])

Output:

<pre>

 

===version 3===

 

### RING: Function Moving Average. Bert Mariani 2016-06-22

###-------------------------------------------------------------

 

 

=={{header|Ruby}}==

A closure:

nums = []

sum = 0.0

printf "Next number = %d, SMA_3 = %.3f, SMA_5 = %.1f\n",

num, ma3.call(num), ma5.call(num)

 

A class

def initialize(size)

@size = size

printf "Next number = %d, SMA_3 = %.3f, SMA_5 = %.1f\n",

num, ma3 << num, ma5 <<num

=={{header|Rust}}==

===Vector Based===

period: usize,

numbers: Vec<usize>

}

}

 

===Double-ended Queue Based===

 

struct SimpleMovingAverage {

}

}

 

<pre>Moving average with period 3

Number: 1 | Average: 3

</pre>

 

=={{header|Scala}}==

private var queue = new scala.collection.mutable.Queue[Double]()

def apply(n: Double) = {

override def toString = queue.mkString("(", ", ", ")")+", period "+period+", average "+(queue.sum / queue.size)

def clear = queue.clear

 

<pre>

 

=={{header|Scheme}}==

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

<pre>

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

</pre>

 

=={{header|Sidef}}==

Implemented with closures:

 

var list = []

printf("Next number = %d, SMA_3 = %.3f, SMA_5 = %.1f\n",

num, ma3.call(num), ma5.call(num))

 

Implemented as a class:

 

method SMA(number) {

printf("Next number = %d, SMA_3 = %.3f, SMA_5 = %.1f\n",

num, ma3.SMA(num), ma5.SMA(num))

 

{{out}}

{{works with|GNU Smalltalk}}

 

|valueCollection period collectedNumber sum|

MovingAverage class >> newWithPeriod: thePeriod [

^ self sma

]

 

 

sma3 := MovingAverage newWithPeriod: 3.

v . (sma3 add: v) asFloat . (sma5 add: v) asFloat

}) displayNl

 

=={{header|Tcl}}==

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

variable vals idx

constructor {{period 3}} {

expr {[tcl::mathop::+ {*}$vals]/double([llength $vals])}

}

Demonstration:

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

<pre>Next number = 1, SMA_3 = 1.0, SMA_5 = 1.0

Press <tt>ON</tt> to terminate the program.

 

:While 1

:Prompt I

:Disp mean(L1)

:1+C->C

 

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

 

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

Func

Local r, i, z

EndFunc

 

 

Program that returns a simple value at each invocation:

Prgm

If getType(x_)="STR" Then

sum(list)/dim(list)→#v_

EndPrgm

 

Example1: Using the function<br>

=={{header|VBA}}==

This is a "simple" moving average.

'to be stored in a class module with name "sma"

Private n As Integer 'period

Debug.Print Format(sma5.sma(CDbl(s(i))), "0.00000")

Next i

<pre> 1 0,33333 0,20000

2 1,00000 0,60000

9 3,00000 3,80000

10 2,00000 3,00000</pre>

=={{header|VBScript}}==

token = Split(data,",")

stream = ""

SMA = sum / (UBound(d) + 1)

End If

 

{{Out}}

2 3 3.8

1 2 3

</pre>

 

=={{header|zkl}}==

fcn(n,ns,P){

sz:=ns.append(n.toFloat()).len();

ns.sum(0.0)/P;

}.fp1(List.createLong(P+1),P) // pre-allocate a list of length P+1

fp1 creates a partial application fixing the (in this case) the second and third

parameters

{{out}}

<pre>