Question

I’m still working on groking the F# thing – trying to work out how to ‘think’ in F# rather than just translating from other languages I know.

I’ve recently been thinking about the cases where you don’t have a 1:1 map between before and after. Cases where List.map falls down.

One example of this is moving averages, where typically you will have len-n+1 results for a list of length len when averaging over n items.

For the gurus out there, is this a good way to do it (using queue pinched from Jomo Fisher)?

//Immutable queue, with added Length member type Fifo<'a> =     new()={xs=[];rxs=[]}     new(xs,rxs)={xs=xs;rxs=rxs}      val xs: 'a list;     val rxs: 'a list;      static member Empty() = new Fifo<'a>()     member q.IsEmpty = (q.xs = []) && (q.rxs = [])     member q.Enqueue(x) = Fifo(q.xs,x::q.rxs)     member q.Length() = (List.length q.xs) + (List.length q.rxs)     member q.Take() =         if q.IsEmpty then failwith 'fifo.Take: empty queue'         else match q.xs with                 | [] -> (Fifo(List.rev q.rxs,[])).Take()                 | y::ys -> (Fifo(ys, q.rxs)),y  //List module, add function to split one list into two parts (not safe if n > lst length) module List =     let splitat n lst =         let rec loop acc n lst =             if List.length acc = n then                 (List.rev acc, lst)             else                 loop (List.hd lst :: acc) n (List.tl lst)         loop [] n lst  //Return list with moving average accross len elements of lst let MovingAverage (len:int) (lst:float list) =      //ugly mean - including this in Fifo kills genericity     let qMean (q:Fifo<float>) = ((List.sum q.xs) + (List.sum q.rxs))/(float (q.Length()))      //get first part of list to initialise queue     let (init, rest) = List.splitat len lst      //initialise queue with first n items     let q = new Fifo<float>([], init)      //loop through input list, use fifo to push/pull values as they come     let rec loop (acc:float list) ls (q:Fifo<float>) =         match ls with         | [] -> List.rev acc         | h::t ->              let nq = q.Enqueue(h) //enqueue new value             let (nq, _) = nq.Take() //drop old value             loop ((qMean nq)::acc) t nq //tail recursion      loop [qMean q] rest q  //Example usage     MovingAverage 3 [1.;1.;1.;1.;1.;2.;2.;2.;2.;2.] 

(Maybe a better way would be to implement a MovingAverageQueue by inheriting from Fifo?)

Answer 1

If you don’t care too much about performance, here is a very simple solution:

#light  let MovingAverage n s =    Seq.windowed n s    |> Seq.map Array.average  let avgs = MovingAverage 5000 (Seq.map float [|1..999999|])  for avg in avgs do     printfn '%f' avg     System.Console.ReadKey() |> ignore 

This recomputes the average of each ‘window’ from scratch, so it is poor if the windows are large.

In any case, check out Seq.windowed:

http://research.microsoft.com/projects/cambridge/fsharp/manual/FSharp.Core/Microsoft.FSharp.Collections.Seq.html

as it’s handy to have in your back pocket for such things.