Re: Mathematica daily WTF
- To: mathgroup at smc.vnet.net
- Subject: [mg115175] Re: Mathematica daily WTF
- From: Murray Eisenberg <murray at math.umass.edu>
- Date: Mon, 3 Jan 2011 03:58:14 -0500 (EST)
I'd argue, rather, that little minds often have no choice but to take
little steps, while big minds often prefer to take big steps.
As a familiar mathematical example, take the Newton-Raphson method.
Coding this could be an early exercise with Mathematica. (Of course you
can just use FindRoot with the Method -> "Newton" option, but the
purpose of the exercise here is to "roll one's own".)
The "little-step" approach might be something like this:
f[x_] := x^6 - x - 1
x0 = 1.;
Module[{i, x},
x[0] = x0;
For[i = 0, i < 5,
x[i + 1] = x[i] - f[x[i]]/f'[x[i]];
Print[x[i]];
i++]
]
The "big-step" approach might be:
f[x_] := x^6 - x - 1
newtonStep[x_] := x - f[x]/f'[x]
NestList[newtonStep, 1., 4]
And I'd maintain that the latter not only is shorter to type and quicker
to code (if you know the constructs involved), but much more directly
expresses what's going on with the Newton-Raphson method.
The "little-step" approach is definitely easier for those who either
have not reached learning about NestList, e.g.; or who think it's fun
"playing computer" instead of solving problems; or whose minds have been
rotted by previous programming with languages where you were forced to
set up a loop explicitly -- including specifying a counter and
explicitly incrementing that counter.
Moreover, if you want to generalize the code so as to vary the target
function and the initial guess, it's a lot simpler to modify the
"big-step" code to do so:
Clear[newtonStep]
newtonStep[f_, x_]:= x - f[x]/f'[x]
newton[f_, x0_, n_] := NestList[newtonStep[f, #] &, x0, n]
newton[#^6 - # - 1&, -1., 4]
newton[#^2 - 2 &, 1., 5] // NumberForm[#, 12] &
(Of course one might eventually recode either approach so as to
calculate the derivative function just once.)
None of this is to make any claim whatsoever as to which approach --
explicitly programming the iteration yourself in detail, or letting
Mathematica handle all the details behind the scenes -- might ultimately
be more efficient. (Although the whole point of the Newton-Raphson
method is to get good approximations with few iterations.)
Nor is this to deny that there are times when you may want or need to
program a loop explicitly, e.g., when a number of arrays' values are
involved.
Nor, finally, is what I've said meant to discourage those who come to
Mathematica from some other programming-paradigm background and who want
to just get on with their work without learning anything essentially
new. Although such folks might save themselves a lot of time ultimately
by learning and exploiting the higher-order constructs available in
Mathematica.
On 1/2/2011 4:55 AM, AES wrote:
> ...
> I'd argue [procedural programming ] is also extremely helpful to people who _think_ physically,
> or if you like procedurally, and who are primarily focused on solving
> problems that have an inherently procedural character.
>
> The successive steps (lines, cells, expressions) in a procedural program
> will very often state or mimic or reproduce what happens as a function
> of time in a dynamic system, or as a function of distance as a wave
> propagates, or mimic the flow of control in a complex system, or . . .
>
> As such, they simplify the process of _coding_ these programs; they
> _document_ and make readable what the program is doing, step by step;
> they make it easy to _insert later refinements_ inside the procedure
> (e.g., tests for current values or for exceptional cases at points
> within the procedure)....
--
Murray Eisenberg murray at math.umass.edu
Mathematics & Statistics Dept.
Lederle Graduate Research Tower phone 413 549-1020 (H)
University of Massachusetts 413 545-2859 (W)
710 North Pleasant Street fax 413 545-1801
Amherst, MA 01003-9305