Nrthugu

I am trying to implement a "Function That Remembers Values It Has Found" (name adjusted from the similarly named Mathematica guide (clicky here)). I have an optional argument and I believe that is giving me some issues, I know that it would be easy if I just gave the value of the optional argument when attempting to recall the function, but that seems to defeat the point of such a mechanism.

Here is an example of my problem (function anonymised for privacy reasons, it is not a function specific issue):

In[1]:= myFun[d_,m_,method_String,degrees_:False]:=

             myFun[d,m,method,degrees]=foo[d,m,method,degrees];

If I run it and time it without the optional argument specified, it does not save the result.

In[2]:= Timing[myFun[2,6,"myMethod"];]

Out[2]= {1.73822, Null}



In[3]:= Timing[myFun[2,6,"myMethod"];]

Out[3]= {1.74781, Null}

So I checked with ? myFun and saw that it had indeed been saved with the optional argument specified, so gave that a try:

In[4]:= Timing[myFun[2,6,"myMethod",False];]

Out[4]= {0.000102, Null}

Giving what would have been expected. Is there any way so that I do not have to include my optional argument, it would be a shame if it were no longer optional!

You can name the user-call with a pattern and use that for memoization:

call : myFun2[x_, y_: 23] := call = (Pause[1]; x + y);



call : myFun3[x_, y_: 23] := call = myFun3[x, y] = (Pause[1]; x + y);

The first memoizes just the call:

AbsoluteTiming[myFun2[3]]

(*  {1.00087, 26}  *)



AbsoluteTiming[myFun2[3]]

(*  {1.*10^-6, 26}  *)



AbsoluteTiming[myFun2[3, 23]]  (* not memoized *)

(*  {1.00064, 26}  *)

The second memoizes the call, if the call was of the form myFun3[x], and it will memoize the call with the default, myFun3[x, 23], too:

AbsoluteTiming[myFun3[3]]

(*  {1.00028, 26}  *)



AbsoluteTiming[myFun3[3]]

(*  {1.*10^-6, 26}  *)



AbsoluteTiming[myFun3[3, 23]]

(*  {1.*10^-6, 26}  *)

The double assigment call = myFun3[x, y] =... is innocuously redundant if the call is of the form myFun3[x, y].

There might be more elegant ways to handle this, but a very simple one is to use an extra definition. That means instead of:

f[x_, n_: 2] := (f[x, n] = (Pause[1]; x^n))

(note that it usually is a good idea to include a minimal working example in your questions so that people who answer have something to start with...)

use this:

ClearAll@f

f[x_] := f[x, 2]

f[x_, n_] := (f[x, n] = (Pause[1]; x^n))