Back to Questions
2.1k
views2
comments
How To: Write a Simple Moving Average Function in F#
f#

I'm trying to learn F# and wondered if someone could help me write a function that computes the Simple Moving Average (SMA) for an array of numbers (could be prices or volume). The problem domain is trading/finance. The business case is take an array of closing prices (or volume) and create a new array that contains the Simple Moving Average #'s for each day (ordinals should line up).

I want to get the hang of writing recursive functions and believe this is a good example.

The formula is pretty simple and here's a good link that documents it. [link:support.integratedtrading.com]

assume:

INPUT:

A.) an array of longs or floating point #'s are passed in (would be interesting to extend this to use generics after the basic function is defined)

B.) the number of days to average over

OUTPUT: an array of longs or floating points comprising the averaged values in the same order as the input array (the ordinals of the array should correlate to the same day)

Any help is greatly appreciated.

p.s. I named the topic so that others looking for howto type advice could easily find it after I get an answer

.

By looking again at multiple windows every time you lose quite a bit of time...

For the simple MA, the seemingly most common way is to compute the first value, and then compute the MA values incrementally, as in the following.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

 

exception NotEnoughData

let SimpleMovingAverage periods data =
  if periods <= 0 then invalid_arg "periods <= 0"
  let len = Array.length data 
  if len < periods then raise NotEnoughData
  let coeff = 1.0 / float periods
  [|let acc = ref 0.0
    for i in 0 .. periods - 1 do
      acc := !acc + coeff * data.[ i ]
    yield !acc
    //compute the following values incrementally
    for i in periods .. len - 1 do
     let delta = data.[ i ] - data.[ i - periods ]
     do acc := !acc + coeff * delta
     yield !acc
  |]

Most often in TA algorithms, since the last value of an indicator depends on values n bars ago, I suppose you'll probably use imperative idioms...

By on 12/21/2008 3:59 PM ()

Is something like the following what you are looking for?

1
2

let inline avg days =
    Seq.map (Seq.take days >> Seq.average)

The "inline" is necessary to allow it to work over generic types.

Example of using with a list of lists of values:

1
2
3
4
5

let input = [ [ 1;2;3;4 ]; [4;3;2;1]; [2;3;2;3]; [3;3;3;3]; [3;3;3;4] ]
            |> Seq.map (Seq.map decimal)

input
|> avg 2

Which results in the following output:

1
2
3
4
5
6
7
8
9

val inline avg :
  int -> (seq<#seq< ^b>> -> seq< ^b>)
    when  ^b : (static member ( + ) :  ^b *  ^b ->  ^b) and
          ^b : (static member DivideByInt :  ^b * int ->  ^b) and
          ^b : (static member get_Zero : ->  ^b)

val input : seq<seq<decimal>>> 

val it : seq<decimal> = seq [1.5M; 3.5M; 2.5M; 3M; ...]>
By on 12/20/2008 11:25 PM ()

    Topic tags

    IntelliFactory Offices Copyright (c) 2011-2012 IntelliFactory. All rights reserved.
    Home | Products | Consulting | Trainings | Blogs | Jobs | Contact Us | Terms of Use | Privacy Policy | Cookie Policy     		Built with WebSharper