Has anyone here ever used Mathematica before? I'm just starting to
get into Lisp, but I've used Mathematica for quite some time. Both
strike me as very similar, especially in terms of the development
process (constructing programs a line at a time, seeing the results of
each action) as well as their list and functionally oriented nature.
I'm not saying they're exactly the same, but could anyone with more
Lisp experience perhaps comment? If they truely are as similar as I
think they are, then Lisp is mana sent from heaven for me.
In article <····························@posting.google.com>,
·········@hotmail.com (Steve Fedele) wrote:
> Has anyone here ever used Mathematica before? I'm just starting to
> get into Lisp, but I've used Mathematica for quite some time. Both
> strike me as very similar, especially in terms of the development
> process (constructing programs a line at a time, seeing the results of
> each action) as well as their list and functionally oriented nature.
> I'm not saying they're exactly the same, but could anyone with more
> Lisp experience perhaps comment? If they truely are as similar as I
> think they are, then Lisp is mana sent from heaven for me.
There are stories somewhere on the net that when Wolfram was
a wunderkind at Caltech, he used Macsyma -- the original
mathematical software package, written in Mac Lisp -- and
talked to some of the programmers about it. However, he
didn't like the style or something about Macsyma or Lisp,
and so wrote his own language. He wanted to sell it but
Caltech claimed ownership, so he left, went to the Institute
for Advanced Study and the Illinois, played around will
cellulor automata, wrote Mathematica, and launched his
company.
Perhaps Mathematica resembles Lisp more than procedural
or object-oriented languages because of this story. Or
perhaps because both sprung from the minds of mathematically-
oriented scientists rather than engineers, who thought
naturally in a functional style.
In article <··························@news.vanderbilt.edu>,
Sashank Varma <····@vanderbilt.edu> wrote:
> There are stories somewhere on the net that when Wolfram was
> a wunderkind at Caltech, he used Macsyma -- the original
> mathematical software package, written in Mac Lisp -- and
> talked to some of the programmers about it. However, he
> didn't like the style or something about Macsyma or Lisp,
> and so wrote his own language. He wanted to sell it but
> Caltech claimed ownership, so he left, went to the Institute
> for Advanced Study and the Illinois, played around will
> cellulor automata, wrote Mathematica, and launched his
> company.
Actually Mathematica strongly resembles an earlier symbolic math package
called "SMP", which I believe was done at Caltech. All I can find on
the net in a few minutes that is /not/ at wolfram.com is:
Steven Wolfram's earlier language for performing symbolic
mathematics, before he turned to Mathematica.
"SMP Handbook", C. Cole, Steven Wolfram et al, Caltech 1981.
I believe there were co-authors to SMP, but I can't find mention of
them other than C. Cole above.
I don't know if Macsyma was referenced to develop SMP.
-bcd
--
*** Brian Downing <bdowning at lavos dot net>
Sashank Varma wrote:
>
> There are stories somewhere on the net that when Wolfram was
> a wunderkind at Caltech, he used Macsyma -- the original
> mathematical software package, written in Mac Lisp -- and
> talked to some of the programmers about it.
Worth noting that Common Lisp Maxima is a descendant
of Macsyma, still around thanks to William Schelter
getting it open sourced before he died. Pretty cool,
and in debian with the rather understated package description
"A fairly complete computer algebra system".
http://maxima.sourceforge.net/
I agree with the comments by Albert Reiner.
Wolfram wrote SMP because he felt that Macsyma, which he used
extensively, was too slow. Wolfram thought that he was
cleverer than anyone else and could read Knuth's books and
then write a better computer algebra system. He wrote it
with
S. Cole, Geoffrey C. Fox, Jeffrey M. Greif, Eric D. Mjolsness, Larry J.
Romans, Timothy Shaw, and Anthony E. Terrano.
SMP was terrible.
It had some bad designs, naive and buggy.
For example, Wolfram thought he could use
double precision to approximate rational numbers, and no one
would notice.
Comments on its successor, Mathematica:
Since the fundamental paradigm for the user-level programming
language is pattern matching, what you usually get is a simulation
of functional programming using patterns and replacements. If you
look at this too closely, the analogy breaks. Wolfram would
like to claim that Mathematica combines (the best?) ideas from
many languages, including Lisp.
At least in the past, the time to add an element to the front
of a list, or the back of the list, was the same, but it depended
on the length of the list. How would you like "cons" to depend
on the size of the inputs? I haven't timed this Mathematica feature
recently.
Also, the evaluation model is quite bizarre. A value of a variable V
is re-evaluated whenever it is touched, iff something that V depends
upon has been changed since V was last touched. This is approximated
by keeping a collection of pages of items which have values on which
V depends.
Since side effects are possible, you can have values change
non-deterministically. Sorry I can't give you a reproducible example:)
Note also, that if one value in an array a[n,m] is changed, then the
time to access any other value of that array increases, because they
have to be re-evaluated. This makes some algorithms that one would
think were (say) quadratic, into cubic or even exponential time.
Mathematica is interesting, but the programming language provided
to the user violates many rules of good behavior. But then, this
is true of other systems catering to scientific applications programmers
who are just fiddling around, whose answers probably don't matter,
or can be checked by physical experiment, whose programs are either
single commands or short programs, and never heard of big-Oh notation,
or floating-point error analysis.
I wrote a Mathematica parser and cut-down pattern matcher/evaluator in
Common Lisp. Wolfram made noises about copyright infringement, but
eventually stopped. Search on google for "mockmma" to find a copy
to download.
Of course another difference is that Mathematica is proprietary
and definitely not free.
RJF
ps. for the source of the "runic" comment, see
http://www.cs.berkeley.edu/~fateman/papers/mma.review.pdf
David Golden wrote:
> Sashank Varma wrote:
>
>
>>There are stories somewhere on the net that when Wolfram was
>>a wunderkind at Caltech, he used Macsyma -- the original
>>mathematical software package, written in Mac Lisp -- and
>>talked to some of the programmers about it.
>
>
> Worth noting that Common Lisp Maxima is a descendant
> of Macsyma, still around thanks to William Schelter
> getting it open sourced before he died. Pretty cool,
> and in debian with the rather understated package description
> "A fairly complete computer algebra system".
>
> http://maxima.sourceforge.net/
>
Richard Fateman <········@sbcglobal.net> writes:
> ps. for the source of the "runic" comment, see
>
> http://www.cs.berkeley.edu/~fateman/papers/mma.review.pdf
Ah yes, that's it. A very interesting reading, and a lot of it is
still valid for the latest version.
Albert.
Christopher C. Stacy wrote:
> You can order Macsyma by contacting Symbolics.
> The phone number has been posted here before.
I looked for an email adress for sales, but with
no luck. However I am not quite sure I found the
right company web page.
--
Jens Axel S�gaard
David Golden <············@oceanfree.net> writes:
> Worth noting that Common Lisp Maxima is a descendant
> of Macsyma, still around thanks to William Schelter
> getting it open sourced before he died. Pretty cool,
> and in debian with the rather understated package description
> "A fairly complete computer algebra system".
>
> http://maxima.sourceforge.net/
Well, how complete is it? I just went to maxima.franz.com and tried:
,----
| <1> (run)
| Maxima 5.9.0 http://maxima.sourceforge.net
| Distributed under the GNU Public License. See the file COPYING.
| Dedicated to the memory of William Schelter.
| This is a development version of Maxima. The function bug_report()
| provides bug reporting information.
| (C1) integrate(sin(x)/x, x);
|
| /
| [ SIN(x)
| (D1) I ------ dx
| ] x
| /
`----
I have no idea how easy it would be to teach Maxima about the sine
integral or to make it recognize this integral - but that is hardly
what I would call a "complete" CAS in any sense.
Albert.
Albert Reiner wrote:
> David Golden <············@oceanfree.net> writes:
>
>
>>Worth noting that Common Lisp Maxima is a descendant
>>of Macsyma, still around thanks to William Schelter
>>getting it open sourced before he died. Pretty cool,
>>and in debian with the rather understated package description
>>"A fairly complete computer algebra system".
>>
>>http://maxima.sourceforge.net/
>
>
> Well, how complete is it? I just went to maxima.franz.com and tried:
You'll have to decide that for yourself.
>
> ,----
> | <1> (run)
> | Maxima 5.9.0 http://maxima.sourceforge.net
> | Distributed under the GNU Public License. See the file COPYING.
> | Dedicated to the memory of William Schelter.
> | This is a development version of Maxima. The function bug_report()
> | provides bug reporting information.
> | (C1) integrate(sin(x)/x, x);
> |
> | /
> | [ SIN(x)
> | (D1) I ------ dx
> | ] x
> | /
> `----
>
> I have no idea how easy it would be to teach Maxima about the sine
> integral or to make it recognize this integral - but that is hardly
> what I would call a "complete" CAS in any sense.
What kind of answer did you expect? That it returns si(x) or something
like that instead of the original integral?
Ray
> > ,----
> > | <1> (run)
> > | Maxima 5.9.0 http://maxima.sourceforge.net
> > | Distributed under the GNU Public License. See the file COPYING.
> > | Dedicated to the memory of William Schelter.
> > | This is a development version of Maxima. The function bug_report()
> > | provides bug reporting information.
> > | (C1) integrate(sin(x)/x, x);
> > | | /
> > | [ SIN(x)
> > | (D1) I ------ dx
> > | ] x
> > | /
> > `----
> > I have no idea how easy it would be to teach Maxima about the sine
> > integral or to make it recognize this integral - but that is hardly
> > what I would call a "complete" CAS in any sense.
>
> What kind of answer did you expect? That it returns si(x) or
> something like that instead of the original integral?
Yes, that was my expectation.
Albert.
>>>>> "Albert" == Albert Reiner <·······@tph.tuwien.ac.at> writes:
>> > ,----
>> > | <1> (run)
>> > | Maxima 5.9.0 http://maxima.sourceforge.net
>> > | Distributed under the GNU Public License. See the file COPYING.
>> > | Dedicated to the memory of William Schelter.
>> > | This is a development version of Maxima. The function bug_report()
>> > | provides bug reporting information.
>> > | (C1) integrate(sin(x)/x, x);
>> > | | /
>> > | [ SIN(x)
>> > | (D1) I ------ dx
>> > | ] x
>> > | /
>> > `----
>> > I have no idea how easy it would be to teach Maxima about the sine
>> > integral or to make it recognize this integral - but that is hardly
>> > what I would call a "complete" CAS in any sense.
>>
>> What kind of answer did you expect? That it returns si(x) or
>> something like that instead of the original integral?
Albert> Yes, that was my expectation.
That could probably be added fairly easily, but it probably wouldn't
be very useful until you taught maxima about all the properties of
si(x) too. And that's a bit of work.
Also, AFAICT, no one has complained about the lack of si(x), so, of
course, no one has done anything about it.
Ray
Re teaching Maxima about integral of sine(x)/x...
1. The commercial Macsyma produces sin_int.
2. Ray is right that you would need to teach Maxima a few things
about sin_int, like a way to evaluate it, differentiate,
and special values for simplification.
3. For many purposes the original expression may be preferable,
though.
There is a tradeoff in computer algebra systems
"The good of the one outweighs the good of the many." to reverse
Spock's quote.
Do you want a/b to be (quotient a b)
or do you want to minimize the proliferation of "kernels" like quotient,
and use (times a (expt b -1)) ?
which is wordier, but re-uses kernels that you can't really get rid of.
Si(x), the sine integral is one of those kernels that you can
pretty much get rid of: just use the integral. In some cases you want to
pander to
the common usage. e.g. sine and cosine could be expressed in terms
of each other or in terms of complex exponentials, but are so
familiar, they must all coexist somehow.
But I think the original question was really about the
programming language issues, not the mathematical capabilities
of lisp...
RJF
Raymond Toy wrote:
>>>>>>"Albert" == Albert Reiner <·······@tph.tuwien.ac.at> writes:
>
>
> >> > ,----
> >> > | <1> (run)
> >> > | Maxima 5.9.0 http://maxima.sourceforge.net
> >> > | Distributed under the GNU Public License. See the file COPYING.
> >> > | Dedicated to the memory of William Schelter.
> >> > | This is a development version of Maxima. The function bug_report()
> >> > | provides bug reporting information.
> >> > | (C1) integrate(sin(x)/x, x);
> >> > | | /
> >> > | [ SIN(x)
> >> > | (D1) I ------ dx
> >> > | ] x
> >> > | /
> >> > `----
> >> > I have no idea how easy it would be to teach Maxima about the sine
> >> > integral or to make it recognize this integral - but that is hardly
> >> > what I would call a "complete" CAS in any sense.
> >>
> >> What kind of answer did you expect? That it returns si(x) or
> >> something like that instead of the original integral?
>
> Albert> Yes, that was my expectation.
>
> That could probably be added fairly easily, but it probably wouldn't
> be very useful until you taught maxima about all the properties of
> si(x) too. And that's a bit of work.
>
> Also, AFAICT, no one has complained about the lack of si(x), so, of
> course, no one has done anything about it.
>
> Ray
>
Richard Fateman <········@sbcglobal.net> writes:
> There is a tradeoff in computer algebra systems "The good of the
> one outweighs the good of the many." to reverse Spock's quote.
> Do you want a/b to be (quotient a b) or do you want to minimize the
> proliferation of "kernels" like quotient, and use (times a (expt b
> -1)) ? which is wordier, but re-uses kernels that you can't really
> get rid of.
> Si(x), the sine integral is one of those kernels that you can pretty
> much get rid of: just use the integral. In some cases you want to
> pander to the common usage. e.g. sine and cosine could be expressed
> in terms of each other or in terms of complex exponentials, but are
> so familiar, they must all coexist somehow.
Of course, but in my case si and ci (or actually some related
functions called, I think, f and g in Abramowitz-Stegun) are just as
basic as sin and cos, simply because I have an efficient numerical
implementation for them to use in later processing.
> But I think the original question was really about the
> programming language issues, not the mathematical capabilities
> of lisp...
Actually I am no longer talking about the OP's question but rather
about something related to my own work (involving 3-dimensional
Fourier transforms of interaction potentials in simple liquids with
cutoffs in both k- and r-space), where the symbolic end result I need
to get should be in terms of si, ci (or the f and g mentioned above)
and I also need the small-k series expansions of those expressions,
all of these written in a way suitable for numerical evaluation. The
types of expressions that arise are pretty limited, and their
numerical properties are well understood, so one basically knows what
form one needs to produce.
In the past I just did all of this by hand, with my good old
Gradstein-Ryzhik by my side, but this is barely feasible with the
scheme to be considered now. Also, I would like to be able to have
those manipulations automated for the standard potentials in liquid
state physics; note that I do not really need integrate() to do those
things automatically, I only need to arrive at a procedure that will
yield the end result in a usable form, checking the validity of the
transformations on the way, and telling me if I need to expand that
procedure.
If I were doing this in Mathematica, I wouldn't rely on Integrate
either (branch cuts!) but rather work with replacement rules; but then
again, Mathematica is terrible for scripting, and it seems I cannot
use mash, <http://ai.eecs.umich.edu/people/dreeves/mash/>, at this
place.
My idea was that by using Maxima I could get the basics of those
manipulations, simple simplifications in particular, for free, that I
would be able to do what I need with replacements (I see subst and
substpart etc. in the manual), and that it would integrate well into
the rest of the software if written in Common Lisp; actually, this was
the primary reason for considering CL at all.
BTW, does anyone have an example of using a Maxima result for a lambda
body? I am thinking of a function that returns a function for
evaluating the maxima result numerically. E.g., given a
representation of cos(x), such a function should compute the
derivative and return
'(lambda (x)
(declare (type long-float x))
(- (sin x)))
On a related note, does anyone know how close the Maxima
representation of algebraic expressions is to that of CL or Fortran?
Albert.
Just have a look at emacs calc, symbolic manipulator written in elisp. In the
algebra tutorial Si(x) is used as an exercise, and with elisp you have kind
of an interactive interface
On 22 Jun 2004 11:45:22 +0200, Albert Reiner <·······@tph.tuwien.ac.at> wrote:
> Richard Fateman <········@sbcglobal.net> writes:
>
>> There is a tradeoff in computer algebra systems "The good of the
>> one outweighs the good of the many." to reverse Spock's quote.
>> Do you want a/b to be (quotient a b) or do you want to minimize the
>> proliferation of "kernels" like quotient, and use (times a (expt b
>> -1)) ? which is wordier, but re-uses kernels that you can't really
>> get rid of.
>> Si(x), the sine integral is one of those kernels that you can pretty
>> much get rid of: just use the integral. In some cases you want to
>> pander to the common usage. e.g. sine and cosine could be expressed
>> in terms of each other or in terms of complex exponentials, but are
>> so familiar, they must all coexist somehow.
>
> Of course, but in my case si and ci (or actually some related
> functions called, I think, f and g in Abramowitz-Stegun) are just as
> basic as sin and cos, simply because I have an efficient numerical
> implementation for them to use in later processing.
>
>> But I think the original question was really about the
>> programming language issues, not the mathematical capabilities
>> of lisp...
>
> Actually I am no longer talking about the OP's question but rather
> about something related to my own work (involving 3-dimensional
> Fourier transforms of interaction potentials in simple liquids with
> cutoffs in both k- and r-space), where the symbolic end result I need
> to get should be in terms of si, ci (or the f and g mentioned above)
> and I also need the small-k series expansions of those expressions,
> all of these written in a way suitable for numerical evaluation. The
> types of expressions that arise are pretty limited, and their
> numerical properties are well understood, so one basically knows what
> form one needs to produce.
>
> In the past I just did all of this by hand, with my good old
> Gradstein-Ryzhik by my side, but this is barely feasible with the
> scheme to be considered now. Also, I would like to be able to have
> those manipulations automated for the standard potentials in liquid
> state physics; note that I do not really need integrate() to do those
> things automatically, I only need to arrive at a procedure that will
> yield the end result in a usable form, checking the validity of the
> transformations on the way, and telling me if I need to expand that
> procedure.
>
> If I were doing this in Mathematica, I wouldn't rely on Integrate
> either (branch cuts!) but rather work with replacement rules; but then
> again, Mathematica is terrible for scripting, and it seems I cannot
> use mash, <http://ai.eecs.umich.edu/people/dreeves/mash/>, at this
> place.
>
> My idea was that by using Maxima I could get the basics of those
> manipulations, simple simplifications in particular, for free, that I
> would be able to do what I need with replacements (I see subst and
> substpart etc. in the manual), and that it would integrate well into
> the rest of the software if written in Common Lisp; actually, this was
> the primary reason for considering CL at all.
>
> BTW, does anyone have an example of using a Maxima result for a lambda
> body? I am thinking of a function that returns a function for
> evaluating the maxima result numerically. E.g., given a
> representation of cos(x), such a function should compute the
> derivative and return
>
> '(lambda (x)
> (declare (type long-float x))
> (- (sin x)))
>
> On a related note, does anyone know how close the Maxima
> representation of algebraic expressions is to that of CL or Fortran?
>
>
> Albert.
·········@hotmail.com (Steve Fedele) writes:
> Has anyone here ever used Mathematica before? I'm just starting to
> get into Lisp, but I've used Mathematica for quite some time. Both
> strike me as very similar, especially in terms of the development
> process (constructing programs a line at a time, seeing the results of
> each action) as well as their list and functionally oriented nature.
> I'm not saying they're exactly the same, but could anyone with more
> Lisp experience perhaps comment? If they truely are as similar as I
> think they are, then Lisp is mana sent from heaven for me.
I've used Mathematica a lot and taught it at university, but I started
with CL only in Februarz, so everzthing I say about it should be taken
with a grain of salt.
At least on a superficial level, both languages are definitely quite
similar, and I am sure that a working knowledge of the core language
of Mathematica is very helpful for learning CL (some dabbling in
Haskell and m4 might also be helpful, though). The basic underlying
reason, it seems to me, is that Mathematica tries to mimic a
functional system while being deeply non-functional in its
implementation, whereas side effects are similarlz always to be
reckoned with in CL despite the strong functional feeling of a large
part of the laguage.
Of course, there are any number of important differences. Off the top
of my head:
- Symbols: In Mathematica, symbols are basically just entries in the
pattern database, and they can be accessed only by their names;
uninterned symbols like the GENSYMs routinely used in macros just
don't exist - look for Unique[] and Module[] / $ModuleNumber for the
poor Mathematica substitute.
- Scoping: Mathematica cannot correctly do lexical scoping and only
tries to simulate that with re-naming of symbols:
,----
| In[30]:= Function[{a}, Function[{b}, a+b]] @ b
|
| Out[30]= Function[{b$}, b + b$]
|
| In[31]:= Function[{a}, Function[{b}, a+b]] @ b$
|
| Out[31]= Function[{b$}, b$ + b$]
`----
That won't happen with LABELS and LAMBDA.
- Expressions: In Mathematica, (head and) argument list are basically
stored in an array, which means that adding to the front of a list
is just as expensive as adding to its end. In CL you have cons
cells, which is like the old idiom of building up a long list as
Flatten[{value, {value, {...}}}].
- Macros: You can do similar things in Mathematica with HoldAll
functions, but if there is no simple mapping from your input to the
final Mathematica expression, things rapidlz get nasty. (Put
everzthing into Hold[], perform replacements and evaluations,
ReleaseHold[] - sometimes you even have to Block[{Block}, ...].)
- Functions: In CL, functions are opaque: all you can do is apply them
to some input. In Mathematica, Function[] is an expression like any
other, and you can just perform substitutions: g[f_] := f ·@ # & /;
···········@Map[Identity, x_] :> x and the like just work.
- Syntax: Beginners like to complain about the syntax. Mathematica
now has style sheets and what-have-you just to hide the brackets and
the capital I and E for the imaginary unit and Euler's number
(though I don't think they can make real code more palatable - I've
even read someone call ...& notation "runic syntax"); Lisp is still
stuck with parentheses (except for Dylan).
- Standard: You have a CL standard vs. only the (mainly PR effective)
documentation for a single implementation of Mathematica. Things
like the recent changes in evaluation of some numerical functions in
Mathematica won't happen in that part of CL that is covered by the
standard.
- Packages: Very similar at first glance, but I think that shadowing
works differently in CL.
- Replacement rules: Very important in Mathematica, whereas CL doesn't
seem to have those (I suspect generic functions and CLOS are similar
in some respects); on the other hand, most of the time patterns and
replacement rules (especially those automatically applied, Set and
SetDelayed) are just used for passing arguments anyway.
- Evaluation generally works very differently, with all the attributes
you can set and the search for a fixed point of the transformations
implemented by the applicable rules in Mathematica, and there is
nothing like CL's clear distinction between macro expansion time and
run time (read time you have, though most users are not aware of
it's effects).
At least that is according to mz current understanding of CL.
Regards,
Albert.
P.S.: Sorry for misspellings - adjusting to Norvegian keyboard.