calc: History and Acknowledgments
1.6 History and Acknowledgments
===============================
Calc was originally started as a two-week project to occupy a lull in
the author’s schedule. Basically, a friend asked if I remembered the
value of ‘2^32’. I didn’t offhand, but I said, “that’s easy, just call
up an ‘xcalc’.” ‘Xcalc’ duly reported that the answer to our question
was ‘4.294967e+09’—with no way to see the full ten digits even though we
knew they were there in the program’s memory! I was so annoyed, I vowed
to write a calculator of my own, once and for all.
I chose Emacs Lisp, a) because I had always been curious about it and
b) because, being only a text editor extension language after all, Emacs
Lisp would surely reach its limits long before the project got too far
out of hand.
To make a long story short, Emacs Lisp turned out to be a
distressingly solid implementation of Lisp, and the humble task of
calculating turned out to be more open-ended than one might have
expected.
Emacs Lisp didn’t have built-in floating point math (now it does), so
this had to be simulated in software. In fact, Emacs integers would
only comfortably fit six decimal digits or so (at the time)—not enough
for a decent calculator. So I had to write my own high-precision
integer code as well, and once I had this I figured that arbitrary-size
integers were just as easy as large integers. Arbitrary floating-point
precision was the logical next step. Also, since the large integer
arithmetic was there anyway it seemed only fair to give the user direct
access to it, which in turn made it practical to support fractions as
well as floats. All these features inspired me to look around for other
data types that might be worth having.
Around this time, my friend Rick Koshi showed me his nifty new HP-28
calculator. It allowed the user to manipulate formulas as well as
numerical quantities, and it could also operate on matrices. I decided
that these would be good for Calc to have, too. And once things had
gone this far, I figured I might as well take a look at serious algebra
systems for further ideas. Since these systems did far more than I
could ever hope to implement, I decided to focus on rewrite rules and
other programming features so that users could implement what they
needed for themselves.
Rick complained that matrices were hard to read, so I put in code to
format them in a 2D style. Once these routines were in place, Big mode
was obligatory. Gee, what other language modes would be useful?
Scott Hemphill and Allen Knutson, two friends with a strong
mathematical bent, contributed ideas and algorithms for a number of Calc
features including modulo forms, primality testing, and
float-to-fraction conversion.
Units were added at the eager insistence of Mass Sivilotti. Later,
Ulrich Mueller at CERN and Przemek Klosowski at NIST provided invaluable
expert assistance with the units table. As far as I can remember, the
idea of using algebraic formulas and variables to represent units dates
back to an ancient article in Byte magazine about muMath, an early
algebra system for microcomputers.
Many people have contributed to Calc by reporting bugs and suggesting
features, large and small. A few deserve special mention: Tim Peters,
who helped develop the ideas that led to the selection commands, rewrite
rules, and many other algebra features; François Pinard, who contributed
an early prototype of the Calc Summary appendix as well as providing
valuable suggestions in many other areas of Calc; Carl Witty, whose
eagle eyes discovered many typographical and factual errors in the Calc
manual; Tim Kay, who drove the development of Embedded mode; Ove
Ewerlid, who made many suggestions relating to the algebra commands and
contributed some code for polynomial operations; Randal Schwartz, who
suggested the ‘calc-eval’ function; Juha Sarlin, who first worked out
how to split Calc into quickly-loading parts; Bob Weiner, who helped
immensely with the Lucid Emacs port; and Robert J. Chassell, who
suggested the Calc Tutorial and exercises as well as many other things.
Among the books used in the development of Calc were Knuth’s _Art of
Computer Programming_ (especially volume II, _Seminumerical
Algorithms_); _Numerical Recipes_ by Press, Flannery, Teukolsky, and
Vetterling; Bevington’s _Data Reduction and Error Analysis for the
Physical Sciences_; _Concrete Mathematics_ by Graham, Knuth, and
Patashnik; Steele’s _Common Lisp, the Language_; the _CRC Standard Math
Tables_ (William H. Beyer, ed.); and Abramowitz and Stegun’s venerable
_Handbook of Mathematical Functions_. Also, of course, Calc could not
have been written without the excellent _GNU Emacs Lisp Reference
Manual_, by Bil Lewis and Dan LaLiberte.
Final thanks go to Richard Stallman, without whose fine
implementations of the Emacs editor, language, and environment, Calc
would have been finished in two weeks.
Info Catalog
calc: Using Calc
calc: Getting Started