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

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

{{trans|PL/I}}

AVGSMA CSECT

USING AVGSMA,R12

moving.ads:

Max_Elements : Positive;

type Number is digits <>;

moving.adb:

package body Moving is

main.adb:

with Moving;

procedure Main is

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

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

For Integers:

MsgBox % MovingAverage(1) ; 3

MsgBox % MovingAverage(-3) ; 1

}</syntaxhighlight>

For floating point numbers:

Static

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

=={{header|AWK}}==

# Moving average over the first column of a data file

BEGIN {

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

=={{header|Bracmat}}==

= buffer

. (new$=):?freshEmptyBuffer

=={{header|Brat}}==

Object version

SMA = object.new

Function version

list = []

=={{header|C}}==

#include <stdlib.h>

#include <stdarg.h>

}</syntaxhighlight>

int main()

{{works with|C sharp|C#|3}}

using System.Collections.Generic;

using System.Linq;

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

#include <iostream>

#include <stddef.h>

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]

=={{header|CoffeeScript}}==

I = (P) ->

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

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

Use

=={{header|Crystal}}==

a = Array(Float64).new

->(x : Float64) {

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

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

Same output:

struct SMA(T, int period) {

{{Trans|Pascal}}

Small variation of [[#Pascal]].

program Simple_moving_average;

{{trans|C#}}

var acc = 0.0

var c = 0

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

def makeMovingAverage(period) {

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

}</syntaxhighlight>

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

> println(`Period $period:`)

=={{header|EchoLisp}}==

(lib 'tree) ;; queues operations

=={{header|Elena}}==

ELENA 5.0 :

import system'collections;

import extensions;

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

SMA.run</syntaxhighlight>

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

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

=={{header|Erlang}}==

SMA3 = sma(3),

SMA5 = sma(5),

{{out}}

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

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

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

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;

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

let sma_aux queue v =

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

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

=={{header|Fantom}}==

class MovingAverage

{

=={{header|Forth}}==

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

=={{header|Fortran}}==

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

implicit none

=={{header|FreeBASIC}}==

Type FuncType As Function(As Double) As Double

=={{header|GAP}}==

local sma, buffer, pos, sum, len;

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

=={{header|Go}}==

import "fmt"

=={{header|Groovy}}==

{{trans|Ruby}}

def nums = []

double total = 0.0

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

{{works with|GHC|6.10.4}}

import Control.Monad

{{works with|GHC|6.10.4}}

import Control.Arrow

import Control.Monad

{{works with|GHC|7.8.3}}

import Control.Monad

import Control.Monad.State

=={{header|HicEst}}==

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

=={{header|Icon}} and {{header|Unicon}}==

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

every write(sma(!A))

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)

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:

3 3.8 4.2 4.2 3.8 3</syntaxhighlight>

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

1 1.5 2 2.5 3 3.8 4.2 4.2 3.8 3</syntaxhighlight>

Or, a more traditional approach could be used:

SEQ=:''

moveAvg=:4 :0"0

=={{header|Java}}==

{{works with|Java|1.5+}}

import java.util.Queue;

=={{header|JavaScript}}==

===Using for loop===

var nums = [];

return function(num) {

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

Array.prototype.simpleSMA=function(N) {

return this.map(

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

Non-stateful:

v:v,|v:1+!5

v

Stateful:

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

=={{header|Kotlin}}==

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

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

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

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

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

...

=={{header|Lua}}==

local t = {}

function sum(a, ...)

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

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

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

=={{header|NetRexx}}==

{{trans|Java}}

options replace format comments java crossref symbols nobinary

=={{header|Nim}}==

proc simplemovingaverage(period: int): auto =

=={{header|Objeck}}==

{{trans|Java}}

use Collection;

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

@interface MovingAverage : NSObject {

=={{header|OCaml}}==

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

Queue.push x q;

More imperatively:

let q = Queue.create ()

and sum = ref 0.0 in

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)

Usage:

| sma3 sma5 l |

3 createSMA -> sma3

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

=={{header|OxygenBasic}}==

Class MovingAverage

=={{header|Oz}}==

fun {CreateSMA Period}

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

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

sma_v=vector(n);

sma_i = 0;

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

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

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

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

<span style="color: #004080;">sequence</span> <span style="color: #000000;">sma</span> <span style="color: #0000FF;">=</span> <span style="color: #0000FF;">{}</span> <span style="color: #000080;font-style:italic;">-- ((period,history,circnxt)) (private to sma.e)</span>

<!--</syntaxhighlight>-->

and the main file is:

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

<span style="color: #008080;">include</span> <span style="color: #000000;">sma</span><span style="color: #0000FF;">.</span><span style="color: #000000;">e</span>

=={{header|Picat}}==

L=[1, 2, 3, 4, 5, 5, 4, 3, 2, 1],

Map3 = new_map([p=3]),

=={{header|PicoLisp}}==

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

(push 'Data N)

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

(*/ (apply + Data) (length Data)) ) )</syntaxhighlight>

(def 'sma5 (sma 5))

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

===version 1===

declare N fixed;

declare A(*) fixed controlled,

===version 2===

{{trans|REXX}}

mat: Proc Options(main);

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

=={{header|Pony}}==

class MovingAverage

let period: USize

=={{header|PowerShell}}==

#This version allows a user to enter numbers one at a time to figure this into the SMA calculations

=={{header|PureBasic}}==

Static P

Static NewList L()

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

===Procedural===

def simplemovingaverage(period):

===Class based===

class Simplemovingaverage():

'''Tests'''

for period in [3, 5]:

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

=={{header|Quackery}}==

[ over size -

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

{

=={{header|Racket}}==

(require data/queue)

{{works with|Rakudo|2016.08}}

sub ($x) {

state @a = 0 xx $P;

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

=={{header|Ring}}==

===version 1===

load "stdlib.ring"

decimals(8)

===version 2===

load "stdlib.ring"

decimals(8)

===version 3===

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

=={{header|Ruby}}==

A closure:

nums = []

sum = 0.0

A class

def initialize(size)

@size = size

=={{header|Run Basic}}==

dim sd(10) ' series data

global sd ' make it global so we all see it

=={{header|Rust}}==

===Vector Based===

period: usize,

numbers: Vec<usize>

===Double-ended Queue Based===

struct SimpleMovingAverage {

=={{header|Scala}}==

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

def apply(n: Double) = {

=={{header|Scheme}}==

(set! nums (cons num (if (= (length nums) size) (reverse (cdr (reverse nums))) nums)))

(/ (apply + nums) (length nums)))

=={{header|Sidef}}==

Implemented with closures:

var list = []

Implemented as a class:

method SMA(number) {

{{works with|GNU Smalltalk}}

|valueCollection period collectedNumber sum|

MovingAverage class >> newWithPeriod: thePeriod [

].</syntaxhighlight>

sma3 := MovingAverage newWithPeriod: 3.

{{trans|Rust}}

var period: Int

var numbers = [Double]()

=={{header|Tcl}}==

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

variable vals idx

constructor {{period 3}} {

}</syntaxhighlight>

Demonstration:

SimpleMovingAverage create averager5 5

foreach n {1 2 3 4 5 5 4 3 2 1} {

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

:While 1

:Prompt I

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

Func

Local r, i, z

Program that returns a simple value at each invocation:

Prgm

If getType(x_)="STR" Then

=={{header|VBA}}==

This is a "simple" moving average.

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

Private n As Integer 'period

=={{header|VBScript}}==

token = Split(data,",")

stream = ""

=={{header|Vlang}}==

{{trans|Go}}

mut i := int(0)

mut sum := f64(0)

{{trans|Go}}

{{libheader|Wren-fmt}}

var sma = Fn.new { |period|

=={{header|zkl}}==

fcn(n,ns,P){

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

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

parameters

T(1,2,3,4,5,5,4,3,2,1).apply(SMA(5)).println();</syntaxhighlight>

{{out}}