Clojure loop and recur or reduce in state space model

Question

I am trying to write up a simple Markovian state space models, that, as the name suggests iteratively looks back one step to predict the next state.

Here is what is supposed to be a MWE, though it is not because I cannot quite figure out how I am supposed to place (recur ... ) in the below code.

;; helper function
(defn dur-call 
  [S D]
    (if (< 1 D)
      (- D 1)
      (rand-int S)))

;; helper function
(defn trans-call
  [S D]
    (if (< 1 D)
      S
      (rand-int 3)))

;; state space model
(defn test-func
  [t]
  (loop 
    [S (rand-int 3)]
    (if (<= t 0)
      [S (rand-int (+ S 1))] 
      (let [pastS (first (test-func (- t 1)))
            pastD (second (test-func (- t 1)))
            S (trans-call pastS pastD)]

           (recur ...?)

        [S (dur-call S pastD)]))))

My target is to calculate some a state at say time t=5 say, in which case the model needs to look back and calculate states t=[0 1 2 3 4] as well. This should, in my mind, be done well with loop/recur but could also be done with reduce perhaps (not sure how, still new to Clojure). My problem is really that it would seemt have to use recur inside let but that should not work given how loop/recur are designed.

leetwinski · Accepted Answer · 2016-11-02T13:46:10.477

your task is really to generate the next item based on the previous one, starting with some seed. In clojure it can be fulfilled by using iterate function:

user> (take 10 (iterate #(+ 2 %) 1))
(1 3 5 7 9 11 13 15 17 19)

you just have to define the function to produce the next value. It could look like this (not sure about the correctness of the computation algorithm, just based on what is in the question):

(defn next-item [[prev-s prev-d :as prev-item]]
  (let [s (trans-call prev-s prev-d)]
    [s (dur-call s prev-d)]))

and now let's iterate with it, starting from some value:

user> (take 5 (iterate next-item [3 4]))
([3 4] [3 3] [3 2] [3 1] [0 0])

now your test function could be implemented this way:

(defn test-fn [t]
  (when (not (neg? t))
    (nth (iterate next-item
                  (let [s (rand-int 3)]
                    [s (rand-int (inc s))]))
         t)))

you can also do it with loop (but it is still less idiomatic):

(defn test-fn-2 [t]
  (when (not (neg? t))
    (let [s (rand-int 3)
          d (rand-int (inc s))]
      (loop [results [[s d]]]
        (if (< t (count results))
          (peek results)
          (recur (conj results (next-item (peek results)))))))))

here we pass all the accumulated results to the next iteration of the loop.

also you can introduce the loop's iteration index and just pass around the last result together with it:

(defn test-fn-3 [t]
  (when (not (neg? t))
    (let [s (rand-int 3)
          d (rand-int (inc s))]
      (loop [result [s d] i 0]
        (if (= i t)
          result
          (recur (next-item result) (inc i)))))))

and one more example with reduce:

(defn test-fn-4 [t]
  (when (not (neg? t))
    (reduce (fn [prev _] (next-item prev))
            (let [s (rand-int 3)
                  d (rand-int (inc s))]
              [s d])
            (range t))))

That is just beautiful! I suppose what I do not understand then is when to use `loop/recur`, `reduce` and `iterate`. Presumably one could make a recursion out of this as well? Why wouldn't you? — Astrid, Nov 02 '16 at 11:39
updated my answer with the recursive solution. I wouldn't use recursion here, since this case is so frequent, that there's a function for it. Moreover, since it produces a lazy seq, it's usage bounds are much wider in general than simple loop's (well it still depends on your requirements) — leetwinski, Nov 02 '16 at 11:46

Clojure loop and recur or reduce in state space model

1 Answers1