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.

Answer 1

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