Hi everyone,

I have another question. Now I'm trying to generalize it this way. I still have $F = \log(f)$, but $f$ and $F$ depend on many variables $t_i$ whith $i\geq 1$. And I want to compute for example

$\displaystyle \frac{\partial f}{\partial t_1} = f \frac{\partial F}{\partial t_1}, $

$\displaystyle \frac{\partial^2 f}{\partial t_1\partial t_2} = f \frac{\partial F}{\partial t_1} \frac{\partial F}{\partial t_2} + f\frac{\partial^2 F}{\partial t_1\partial t_2}, $

I tried to adapt the code but I couldn't do it :/

Thanks, Clément

Hi Celement,

I think the best way is to use Faa Di Bruno's formula, which gives a nice generalization of the chain rule. Compare the following one-line calc. codes:

DerivativeList1[n_] :=  With[{rep = Rule[D[f[x], {x, #}] /. x -> F[x], 1] & /@ Range[n]},
  (D[f[F[x]], {x, #}] & /@ Range[n]) /. rep]
DerivativeList2[n_] :=  Table[BellY[i, j, D[F[x], {x, #}] & /@ Range[n]], {i, 1, n}, {j, 1, i}]    

Short of doing the recursive analysis, you can see that these are ouput equivalent by writing a logical function that applies SameQ to the output and returns true for any $n$. You should also check the timing statistics:

t1 = AbsoluteTiming[DerivativeList1[#];][[1]] & /@ Range[30]
t2 = AbsoluteTiming[DerivativeList2[#];][[1]] & /@ Range[30]

which show that BellY does much better than the naive implementation. However, in other threads I have shown that the current implementation of BellY is slow, and that's true again here. Using the recursion relations we get more time savings

DerivativeList3[n_] := Table[B2[i, j], {i, 1, n}, {j, 1, i}]
t3 = AbsoluteTiming[
     Clear@B2;
     B2[0, 0] = 1;
     B2[n_ /; n > 0, 0] := 0;
     B2[0, k_ /; k > 0] := 0;
     B2[n_ /; n > 0, k_ /; k > 0] := 
      B2[n, k] =        Total[Binomial[n - 1, # - 1] D[F[x], {x, #}] B2[n - #, 
            k - 1] & /@ Range[1, n - k + 1]];
     DerivativeList3[#];][[1]] & /@ Range[30]
ListLinePlot[{t1, t2, t3}, PlotStyle -> {Red, Orange, Green}]

and the output up to $n=5$ :

DerivativeList1[5] // TableForm
DerivativeList2[5] // TableForm
DerivativeList3[5] // TableForm

Brad

Edit: Code from Gianluca Gorni seems to be time-equivalent to the naive implementation above:

myDerivationRule = f'[x_] :> f[x]*F'[x];
AbsoluteTiming[  NestList[D[#, x] /. myDerivationRule &, f[x]*F'[x], 30] /. f[x] -> 1;][[1]]
Out[]=3.14197(s)

Oh, wow! An unexpected approximation of Pi.

Hi Gianluca, well it seems to work fine! But I don't even understand the code... Could you explain it to me? Like, what is the meaning of the $==$ sign here? I thought it was for conditions. And what does the $:>$ mean? Is it like a rule and a definition at the same time?

Thanks! Clément