Groups | Search | Server Info | Keyboard shortcuts | Login | Register [http] [https] [nntp] [nntps]

Groups > comp.soft-sys.math.mathematica > #16882 > unrolled thread

How to avoid repeated recalculation of the same function

Back to article view | Back to comp.soft-sys.math.mathematica

Contents

  How to avoid repeated recalculation of the same function pgeipi10@gmail.com - 2014-05-02 06:18 +0000
    Re: How to avoid repeated recalculation of the same function Richard Fateman <fateman@cs.berkeley.edu> - 2014-05-03 07:39 +0000
    Re: How to avoid repeated recalculation of the same function Joe Gwinn <joegwinn@comcast.net> - 2014-05-03 07:40 +0000
    Re: How to avoid repeated recalculation of the same function psycho_dad <s.nesseris@gmail.com> - 2014-05-04 06:27 +0000
    Re: How to avoid repeated recalculation of the same function Roland Franzius <roland.franzius@uos.de> - 2014-05-04 06:28 +0000

#16882 — How to avoid repeated recalculation of the same function

Hi,

I'm doing a calculaton that's purly symbolic (no graphing, numerical integration, etc.).

Suppose I have a function f[x_]:=... that's very complex to build. In fact, f[x] ends up being a manageable expression (about 30 characters) but it takes Mathematica about 30 min to build that expression.

Another function g[] uses the function f[x] and references it many times. I've discovered that g[] actually builds f[x] every time it's referenced which takes 30 minutes each time. Theoretically, Mathematica could build it once and then use the resulting expression every time it's referenced.

So how do I accomplish that? That is, how do I make it build f[x] once and then use the resulting expression when it's needed?

Thanks,


Pavel

[toc] | [next] | [standalone]

#16890

On 5/1/2014 11:18 PM, pgeipi10@gmail.com wrote:


Instead of  f[x_]:=   stuff,  write

f[x_]:= (f[x]= stuff).

Then it remembers.

[toc] | [prev] | [next] | [standalone]

#16896

In article <ljvdcg$bal$1@smc.vnet.net>, <pgeipi10@gmail.com> wrote:

> Hi,
> 
> I'm doing a calculaton that's purly symbolic (no graphing, numerical
> integration, etc.).
> 
> Suppose I have a function f[x_]:=... that's very complex to build. In fact,
> f[x] ends up being a manageable expression (about 30 characters) but it takes
> Mathematica about 30 min to build that expression.
> 
> Another function g[] uses the function f[x] and references it many times.
> I've discovered that g[] actually builds f[x] every time it's referenced
> which takes 30 minutes each time. Theoretically, Mathematica could build it
> once and then use the resulting expression every time it's referenced.
> 
> So how do I accomplish that? That is, how do I make it build f[x] once and
> then use the resulting expression when it's needed?

That bit me a few times as well.

Instead write f[x_]= ..., dropping the colon.

If you write only =, the ... is evaluated once and the result saved
under f[x_].  

If you write :=, the whole ... is saved under f[x_], and evaluated
every time f[x] is invoked.

Joe Gwinn

[toc] | [prev] | [next] | [standalone]

#16900

Hey!

Consider the behavior of the two functions f and f1 (I have added the Pause[2] to give the impression of a long calculation):

f[x_]:=(Pause[2];x^2)
f1[x_]:= f1[x]=(Pause[2];x^2)

(Notice the f1[x_]:= f1[x] "trick" used above...)

Now evaluate both of them:
f[x]
f1[x]

both take a long time to evaluate the first time. Now repeat:
f[x]
f1[x]

you will notice that f1[x] was done instantaneously! The reason is that Mathematica has included the value as part of the definition due to the f1[x_]:= f1[x] "trick", so it remembers it after it evaluates it once.

There are also other ways to do what you want, eg hardcoding by hand the result for f[x] after you evaluate it once (assuming it it always the same) etc.

Cheers

[toc] | [prev] | [next] | [standalone]

#16904

Am 02.05.2014 08:18, schrieb pgeipi10@gmail.com:
> Hi,
>
> I'm doing a calculaton that's purly symbolic (no graphing, numerical integration, etc.).
>
> Suppose I have a function f[x_]:=... that's very complex to build. In fact, f[x] ends up being a manageable expression (about 30 characters) but it takes Mathematica about 30 min to build that expression.
>
> Another function g[] uses the function f[x] and references it many times. I've discovered that g[] actually builds f[x] every time it's referenced which takes 30 minutes each time. Theoretically, Mathematica could build it once and then use the resulting expression every time it's referenced.
>
> So how do I accomplish that? That is, how do I make it build f[x] once and then use the resulting expression when it's needed?

Mostly its enough to set (=) which evaluates the right hand side before 
writing the definition

f[x_]=Integrate[1/(1+x^2),x]

?f

ArtTan[x]

The standard SetDelayed[ a,b ] - definitions don't evaluate b.

You can always write

SetDelayed@@{a, FullSimplify[b] }

to force b to be reduced to the simplest explicit form before making the 
definition with :=.

But sometimes one wants to evaluate an expression but define the 
expression with free patterns not to be evaluated.

For this case the best method is to use Evaluate, a function that 
overides the Hold-Attribute and forces Hold-arguments in functions to 
evaluated during input time

g[x_,a_ ]:= Integrate[1/(a + x^2),x]
h[x_,a_] := Evaluate[Integrate[1/(a + x^2),x]]

Unfortunately Mathematica lacks the input Attribute "Immediate", so 
useful in the language FORTH.

This makes it very complicated to force the parser to evaluate certain 
functions always regardless of Hold Attributes of function expression 
are fed to.

The only workaround I see is to use the mouse selecting and 
Shift+Contol+Enter replacement shortcut that Evaluates an expression in 
the input line already and replaces it there with its current value, 
text-symbolically

j[x_,a_]:= Shift+Ctr+Enter("FullSimplify[Integrate[1/(a + x^2),x]]")

-- 

Roland Franzius

[toc] | [prev] | [standalone]

Back to top | Article view | comp.soft-sys.math.mathematica

csiph-web