# Mathematica Mathematica Computation Time

1. Jul 30, 2017

### joshmccraney

Hi PF!

I am using the following code in Mathematica
Code (Text):

mat = {{1, Cos[2], Cos[4], Sin[2],
Sin[4}, {1, 1, 1, 0, 0}};
Li[x_] :=
Transpose[
NullSpace[
mat].{{1}, {Cos[x}, {Cos[
2 x]}, {Sin[x]}, {Sin[2 x]}}];
Li1[x_] := Li[x].{{1}, {0}, {0}};
f[x_] :=
Li1[x]/Sqrt[Integrate[Li1[s]^2, {s, -1, 1}]];

Then when I want to compute something simple, say
Code (Text):
Integrate[f[x]^2, {x, -1, 1}]
It takes Mathematica a very long time to compute. However, if I first do
Code (Text):
f[x]//N
and then redefine $f$ in terms of the result mathematica prints and ask for the integral, Mathematica computes the integration in much less time. Does anyone know how to define $f$ to begin with in this "numeric" fashion to decrease run time?

2. Jul 30, 2017

### Fightfish

The main reason for the slow speed is because
Code (Text):
f[x_]:= (some stuff here)
is a functional definition, so that whenever $f(\alpha)$ is called for a particular argument $\alpha$, the sequence of instructions given in (some stuff here) will be evaluated from scratch. So, if (some stuff here) contains something relatively complicated such as an integral, you can see why the complexity builds up tremendously fast (especially when you're trying to integrate $f(x)$ itself!). That is to say, the right hand side will only be evaluated when the function is called.

Conversely if you instead adopt the definition
Code (Text):
f[x_]= (some stuff here)
where the colon has been omitted, then the right-hand-side is immediately evaluated. This greatly reduces the subsequent overhead.

I personally almost always use the "=" (immediate definition) instead of ":=" (delayed definition) unless I need to keep the right hand side in unevaluated form for some reason.

3. Jul 31, 2017

### joshmccraney

Good to know, thanks!

This way is quicker but is still taking a significant amount of time to evaluate integrals. For example, if after running
Code (Text):
f[x]//N
I redefine $f$ as
Code (Text):
f[x_]=
0.9073859955296714 (0.534409621782702 -
0.534409621782702 Cos[x] + Sin[2 x])

subsequent operations on $f$ are computed almost instantly. But I have to manually redefine $f$ in this fashion. Since I will be performing many iterations it would be nice to automate this process. Do you have any ideas how to do this?

Thanks for your interest!