How does one clear the memory of a recursive function

Question

I want to implement the recursive function

 v[n_] := v[n] = v[n-1] + f[n-1] + Random[NormalDistribution[0,s]]

to get vel = {v[0], v[1],..., v[N]}.

I want to compute $M$ replicates of vel. How do I clear the memory of $v$ after each replicate of vel? If I don't I get the same vel repeated $M$ times.

Welcome to Mathematica.SE! 1) As you receive help, try to give it too, by answering questions in your area of expertise. 2) Take the tour and check the faqs!
3) When you see good questions and answers, vote them up by clicking the gray triangles, because the credibility of the system is based on the reputation gained by users sharing their knowledge. Also, please remember to accept the answer, if any, that solves your problem, by clicking the checkmark sign! — , Nov 09 '15 at 18:26
I think this should be reopened, because the best way to deal with this is not, IMO, clearing DownValues. — Pillsy, Nov 09 '15 at 18:31
@Pillsy, why wouldn't it be an appropriate answer for the other question? — J. M.'s missing motivation, Nov 09 '15 at 18:33
Anyway, here's how to clear selected values: Scan[Composition[Unset, v], {2, 3, 7, 8}]. You can use Range[n] as the list of values to clear, thus leaving v[0] and the general rule. — J. M.'s missing motivation, Nov 09 '15 at 18:34
@J.M., I don't think so, since the reasons for clearing are different. There it was about resource use, here it's about resetting the computation each time so different RandomVariates are generated. — Pillsy, Nov 09 '15 at 18:35
Then the post should be edited to reflect that, @Pillsy. With just the title and the last two sentences, it reads like a dupe of the other. — J. M.'s missing motivation, Nov 09 '15 at 18:38
Just for completeness: recursion is absolutely unnecessary in the OP's presented case: Accumulate[RandomVariate[NormalDistribution[0, s], n]]. — J. M.'s missing motivation, Nov 09 '15 at 18:43
@J.M. : I don't see that this captures the calls to f[]. However, something equally terse should work. — Eric Towers, Nov 10 '15 at 04:15
@Eric, well, two Accumulate[]'s should do the trick in that case; I just wanted to give the OP an alternate view. — J. M.'s missing motivation, Nov 10 '15 at 04:20

score 15 · Answer 1 · edited May 23 '17 at 12:35

15

Example

For example:

ClearAll[f, v, s, vv];
s = 1;
f[x_] := x;
v[0] := 0;
v[n_] := v[n] = v[n - 1] + f[n - 1] + Random[NormalDistribution[0, s]];
vv[n_] := Internal`InheritedBlock[{v}, v /@ Range[n]];

Test:

vv[10]

(* {-0.0712327, 1.67558, 4.93819, 9.21973, 13.7199, 17.3607, 22.7843, 31.0941, 37.9027, 47.6244} *)

vv[10]

(* {-3.29625, -2.51668, -0.464889, 1.71271, 4.70297, 9.78192, 15.8081, 22.5965, 29.3856, 38.323} *)

Links

Closely related questions:

edited May 23 '17 at 12:35

Community

1

answered Nov 09 '15 at 18:43

Leonid Shifrin

114,335
15
329
420

1

Array[v, n] could be used, too. Is there any reason why Internal`InheritedBlock[] is necessary here? – J. M.'s missing motivation Nov 09 '15 at 18:44
3

@J.M. I added the explanation to the post. The reason is to clear the memoized values, after each run. – Leonid Shifrin Nov 09 '15 at 18:49
I didn't see this answer before I wrote this one where I automate the process of storing and clearing cached values with a wrapper function. – Sjoerd Smit Oct 04 '20 at 11:25
1

@SjoerdSmit Sure thing (it is hard to know about all the answers, probably impossible). I wouldn't vote it up if I didn't think it had novel parts, too :). I don't think there is an exact answer like yours anywhere on the site (although as I said, there are bits and pieces scattered), and I think your answer is valuable. – Leonid Shifrin Oct 04 '20 at 11:37

score 0 · Answer 2 · answered Nov 10 '15 at 04:35

You really want to define the collection of vs when you produce a realization of vel, so I'd replace this with

vel[n_] := Module[{},
  Table[
    v[k] = v[k - 1] + f[k - 1] + Random[NormalDistribution[0, s]],
  {k, 0, n}]
]

This generates a new set of vs every time you call vel[]. (The bulk of this could be replaced by NestList[], but I'm not convinced it buys much to do so.) You don't give any hints about the base case of your recursion, about s, or about what f does, so

Block[{s = 1},
  Print[vel[3]];
  Print[v[2]];
  Print[v[2]];
  Print[vel[3]];
]
v[2]
(*  {-1.39483+f[-1]+v[-1],-1.17269+f[-1]+f[0]+v[-1],-0.19439+f[-1]+f[0]+f[1]+v[-1],0.863082 +f[-1]+f[0]+f[1]+f[2]+v[-1]}  *)
(*  -0.19439+f[-1]+f[0]+f[1]+v[-1]  *)
(*  -0.19439+f[-1]+f[0]+f[1]+v[-1]  *)
(*  {-0.811165+f[-1]+v[-1],-0.959559+f[-1]+f[0]+v[-1],-2.25842+f[-1]+f[0]+f[1]+v[-1],-1.75508+f[-1]+f[0]+f[1]+f[2]+v[-1]}  *)
(*  -2.25842 + f[-1] + f[0] + f[1] + v[-1]  *)

The vs keep their values between calls to vel[] and change on each call to vel[]. If you want to reuse a vel without changing the vs, store it.

How does one clear the memory of a recursive function

2 Answers2

Suggested solution

Example

Links

Linked