Re: V8 slow like a snail

• To: mathgroup at smc.vnet.net
• Subject: [mg127770] Re: V8 slow like a snail
• From: "Dr. Wolfgang Hintze" <weh at snafu.de>
• Date: Mon, 20 Aug 2012 21:30:23 -0400 (EDT)
• Delivered-to: l-mathgroup@mail-archive0.wolfram.com
• Delivered-to: l-mathgroup@wolfram.com
• Delivered-to: mathgroup-newout@smc.vnet.net
• Delivered-to: mathgroup-newsend@smc.vnet.net
• References: <k0fjaj\$q71\$1@smc.vnet.net> <k0fqto\$r07\$1@smc.vnet.net>

```On 18 Aug., 09:57, Roland Franzius <roland.franz... at uos.de> wrote:
> Am 16.08.2012 08:06, schrieb Dr. Wolfgang Hintze:
>
>
>
>
>
> > On 15 Aug., 11:42, Roland Franzius <roland.franz... at uos.de> wrote:
> >> Am 15.08.2012 09:32, schrieb Dr. Wolfgang Hintze:
>
> >>> Great disappointment on my side with 8.0.4.0 Home edition which I
> >>> installed yesterday!
> >>> My first impression: looks good, many nice features ... but incredibl=
y
> >>> slow in comparision to my good old 5.2.
> >>> I then carried out a modest benchmark test the results of which I'll
> >>> show below and which I like to express in terms of a "snail
> >>> factor" ( = time in v5.2/ time in v8).
>
> >>> Consider this integral for which we can safely expect Mathematica to
> >>> be expert in solving:
>
> >>> f1[n_, m_] :=
> >>>    Integrate[n t^m Exp[-n t] (Exp[t] - 1)^(n - 1), {t, 0, \[Infin=
ity]},
> >>>     Assumptions -> {{n, m} \[Element] Integers, m >= 0, n > 0}]
>
> >>> I carried out Timing[f1[n, m]] for m=0,1,2,3,10 in both versions. H=
ere
> >>> are the results in the format
>
> >>> {m, V5.2 f1 first call, V5.2 second call, V8 first call, V8 second
> >>> call, snail factor first call, snail factor second call}
>
> >>> {
> >>> { 0, 0.328, 0.078, 2.122, 2.044, 6.46951, 26.2051},
> >>> { 1, 0.109,  0.063, 30.202, 30.483, 277.083, 483.857},
> >>> { 2, 0.421, 0.11,  30.42, 30.17, 72.2565, 274.273},
> >>> { 3, 0.452, 0.156, 31.528, 31.325, 69.7522, 200.801},
> >>> {10, 5.366, 5.382, 42.448, 42.682, 7.91055, 7.93051}
> >>> }
>
> >>> Even if we compare only the first calls the range of the snail factor
> >>> goes up to 277 at m = 1, is 72 for m = 2, and is still close to 8=
for
> >>> larger m.
>
> >>> This is my story in other words: I own a very old car, and have
> >>> considered for a long time to change to a newer one - although it
> >>> still can go at 200 km/h on the Autobahn.
> >>> So now I am proud owner of the new brilliant car, and I must learn th=
e
> >>> on important tours (m=1) =EDts maximum speed turns out to be less=
than 1
> >>> km/h,  about 3 km/h (m=2) or at most about 30 km/h. Who laughes? =
Me
> >>> not! Obviously I'll definitely keep the old car!
>
> >>> Ok, maybe I have chosen the wrong example (though in other test runs =
a
> >>> similar pictures emerged and this example is just the type I'm using
> >>> Mathematica for). Are there perhaps acknowleged benchmarks for such a
> >>> comparison of versions?
>
> >>> Finally, dear group, as you might have noticed, I'm asking for
> >>> consolation. Please comment and give me useful hints. Many thanks in
> >>> advance.
>
> >> It is a good idea, to split seaching solutions and simplifying the
> >> solutions. In this very special case the indefinite integrals produce
> >> series of hypergeometric functions of n terms in 1/10 of a second.
>
> >> And now vs 8 Simplifies this rather trival result for the definite cas=
e
> >> on {t,0,oo} into sums of polygammas.
>
> >> Of course, nobody can foresee the results of additional simplification
> >> rules in case of special algebraic expressions. This happens with each
> >> new version. More simplification rules, more time.
>
> >> My hope is that Wolfram at some point may give much more open control
> >> over implicit function simplification to his mathematical skilled user=
s.
>
> >>    This is already a problem in trigonometric simpilfications. A s=
imple
> >> body of explicit rules choosen from the appropriate chapters of a
> >> standard formula website would be much more usable than the obscure
> >> dependency on an universal body of rules and an algorithm depending on
> >> time and leafcount. I completely stopped using Sin&Co and I am now
> >> writing all formulas in sin and cos and 1/sin  and feed the
> >> simplification rules by hand. Saves hours of computation time.
>
> >> The same is true for the superflous work that has to be done in order =
to
> >> get an expression grouped in a conventional way readable for Mathemati=
ca
> >> non-experts.
>
> >> --
>
> >> Roland Franzius
>
> > The problem is not the simplification but the basic calculation of an
> > integral.
> > Here are two striking examples:
>
> > Example 1
> > ~~~~~~~~~
> > v 8
> > Timing[Integrate[n*t*Exp[(-n)*t]*(Exp[t] - 1)^(n - 1), {t, 0,
> > Infinity}]]
> > {30.840999999999994, ConditionalExpression[HarmonicNumber[n], Re[n] >
> > -1]}
>
> > v 5.2:
> > Timing[Integrate[n*t*Exp[(-n)*t]*(Exp[t] - 1)^(n - 1), {t, 0,
> > Infinity}]]
> > {0.53*Second, n*If[Re[n] > -1, HarmonicNumber[n]/n,
> >      Integrate[((-1 + E^t)^(-1 + n)*t)/E^(n*t), {t, 0, Infinity},
> > Assumptions -> Re[n] <= -1]]}
>
> > Snail factor s = 30.8/0.53 ~= 60
>
> > Example 2
> > ~~~~~~~~~
> > v 8 without Simplify
> > Timing[f = Integrate[Log[Abs[(Tan[x] + Sqrt[7])/(Tan[x] - Sqrt[7])]],
> >         {x, Pi/3, Pi/2}]]
>
> > {656.4209999999998,
> >   Integrate[Log[Abs[(Sqrt[7] + Tan[x])/(-Sqrt[7] + Tan[x])]],
> >       {x, Pi/3, Pi/2}]}
>
> > No result at all in more than 10 minutes!
> > Therefore I tried FullSimplify in order to get at least a result.
>
> > v 8 with FullSimplify
> > Timing[f = FullSimplify[Integrate[
> >           Log[Abs[(Tan[x] + Sqrt[7])/(Tan[x] - Sqrt[7])]], {x=
, Pi/3,
> >       Pi/2}]]]
>
> > Out[1]= {3191.391,
> >   Integrate[Log[Abs[(Sqrt[7] + Tan[x])/(Sqrt[7] - Tan[x])]],
> >       {x, Pi/3, Pi/2}]}
>
> > Again, no result, but now it took almost 1 hour of "thinking".
>
> > Now v 5.2
> > Timing[f = FullSimplify[Integrate[
> >       Log[Abs[(Tan[x] + Sqrt[7])/(Tan[x] - Sqrt[7])]], {x, Pi/3, =
Pi/
> > 2}]]]
> > {32.667*Second, (1*(-9*ArcCot[Sqrt[7]]*Log[2] - (Pi -
> > 6*ArcCot[Sqrt[7]])*
> >        Log[-Sqrt[3] + Sqrt[7]] + Pi*Log[Sqrt[3] + Sqrt[7]] +
> >       3*I*(-PolyLog[2, (-Sqrt[3] + Sqrt[7])/(-I + Sqrt[7])] +
> >         PolyLog[2, (-Sqrt[3] + Sqrt[7])/(I + Sqrt[7])] +
> >         PolyLog[2, (-I + Sqrt[7])/(Sqrt[3] + Sqrt[7])] -
> >         PolyLog[2, (I + Sqrt[7])/(Sqrt[3] + Sqrt[7])])))/6}
>
> > Oops, half a minute and here we are with the result !
>
> > Snail factor s = oo (because no solution was found) or s = 3191/32.=
7
> > ~= 100 (if we count the times of "absense" for v8).
>
> > Is it exagerated to speak of a disaster?
>
> As an integrator frontend you may be right.
>
> But compare your results with thos after the standard substitution
>
> exp(-t) ->u, t->-Log[u], dt -> -du/u  {t,0,oo}-> {u,0,1}
>
> h1[n_, m_] :=
>   Integrate[n (-Log[u])^m  (1 - u)^(n - 1), {u, 0, 1},
>    Assumptions -> {{n} \[Element] Integers, n > 0}]
>
> Parallelize[
> Timing[h1[n, #]] & /@ {0, 1, 2, 3, 10}]
> {{0.40500000000000114`, 1},
> {0.6549999999999869`,   HarmonicNumber[n]},
> {0.7959999999999994`, \[Pi]^2/6 +    HarmonicNumber[n]^2 - PolyGamma[=
1,
> 1 + n]},
> {1.622000000000007`,    HarmonicNumber[n]^3 +   1/2 HarmonicNumber[=
n]
> (\[Pi]^2 - 6 PolyGamma[1, 1 + n]) +    PolyGamma[2, 1 + n] + 2 Zeta[3=
]},
> {10.`,   1/352 (352 EulerGamma^10 + 2640 EulerGamma^8 \[Pi]^2 +
>
> ..... some 400 lines
>
>               1 + n] (20 EulerGamma^4 + 20 EulerGamma^2 \[P=
i]^2 +
>                3 \[Pi]^4 - 20 PolyGamma[3, 1 + n] +
>                160 EulerGamma Zeta[3]) + 12096 EulerGamma=
^2 Zeta[5] +
>             2016 \[Pi]^2 Zeta[5] + 17280 Zeta[7]) + 3225600 Z=
eta[9]))}}
>
> In most cases, the problems consuming the life time of young scientists,
> are inappropriate programming models.
>
> Playing around with Mathematica and applying  the worlds knowledge abou=
t
> equivalence classes of mathematical problems may possibly save years of
> CPU time and GBs of additional memory.
>
> --
>
> Roland Franzius
>
>

I'm well aware of how to handle Mathematica i.e. to help it get to
results (since 2003 in this group).
However, as a conservative software user this was my first version
change in Mathematica, and I didn't expect the differences be so grave
when simply comparing the same commands.

Your substitution is so obvious that exactly for this reason one could
possibly expect Mathematica to do it by itself. But ok, in this form
the integration in V8 is quick.

And after all, one of the charming features of Mathematica is just the
"human-like" behaviour to sometimes failing but with some help finally
reaching the goal.

Regards,
Wolfgang

```

• Prev by Date: Problem with NIntegrate
• Next by Date: Constraining a Location to Move Along a Plot in a Manipulate
• Previous by thread: Re: V8 slow like a snail
• Next by thread: Re: V8 slow like a snail