Derive 6

Derive 6 was the final version of Derive, a computer algebra system (CAS) that let students and teachers work with exact symbolic mathematics (factoring, solving, differentiating, integrating, simplifying and plotting) on ordinary personal computers. Albert D. Rich and David R. Stoutemyer of Soft Warehouse in Honolulu first released Derive for MS-DOS in October 1988, and it was always unusually compact. Texas Instruments bought the company in 1999, shipped Derive 5 and Derive 6 for Windows, and discontinued the product in 2007.

Derive is also a small programming language. Every Derive session is a sequence of expressions, and users extend the system by writing function definitions such as FACT(n) := IF(n = 0, 1, n·FACT(n - 1)). Collections of definitions are saved as .mth utility files and loaded as libraries. From version 5 onward, the PROG and LOOP constructs added sequential, procedural programming on top of the original functional style. Derive 6’s own help system says it plainly: “In Derive, a program is a mth file of related function definitions and variable assignments.”

History & Origins

muMATH: computer algebra on microcomputers (1979–1985)

In the 1970s, computer algebra lived on mainframes. Stoutemyer recalled in a 2008 talk that, when he was teaching engineering students, his “entire semester course computing budget was exhausted by the first assignment on our campus mainframe”. Soft Warehouse’s own history states that he and Albert D. Rich founded The Soft Warehouse as a partnership on 1 January 1979. Their goal was “to make computer algebra widely available to the masses on small computers.”

The company’s products came out in this order:

Stoutemyer’s 2008 slides date muMATH to 1978, a year earlier than the company history. The difference probably reflects development versus release. Microsoft licensed muMATH for the TRS-80. The company was incorporated as Soft Warehouse, Inc. on 5 February 1985.

muMATH was written in muSIMP, a surface syntax over Soft Warehouse’s own muLISP. In muSIMP you wrote 2+3 instead of LISP’s (+ 2 3), and the history gives the conditional exit When x=0, y Exit as another example.

Derive replaces muMATH (1988)

Instead of refining muMATH, Rich and Stoutemyer decided that “an entire re-write was needed.” Derive was written directly in muLISP rather than muSIMP, and it represented expressions “in an implicit form that makes for much more compact storage and efficient algorithms.” Stoutemyer explained the commercial reason: muMATH had “a teletype-style interface, like MS-DOS,” but users wanted plots, two-dimensional display of results and a menu-driven interface, “so we introduced Derive with its own windowing system in 1988 as replacement for muMATH.”

The name was chosen as a verb: “We wanted a name that suggested the dynamic, creative process of doing math on a computer. So we finally converged on the verb ‘DERIVE’, rather than a static noun beginning with ‘M’.”

According to the company history, DERIVE was released in October 1988 with “an easy to use menu-oriented CAS interface, 2D and 3D graphics,” for PC compatibles running MS-DOS with at least 512K of memory. The first edition of the manual, Derive: A Mathematical Assistant Program, is dated September 1988. Scientific Computing World’s 2004 review gives 1989 as the first release year instead; the sources reviewed do not explain the discrepancy.

Windows and Texas Instruments (1996–2003)

DERIVE for Windows followed in October 1996. It had a graphical interface, and Stoutemyer described it as built on a new 386 assembly-language version of muLISP with full 32-bit addresses, with C++ used for the Windows interface. Bernhard Kutzler of Soft Warehouse Europe in Austria joined Rich, Stoutemyer and Theresa Shelby as a principal author of the Windows version.

In August 1999, Texas Instruments bought Soft Warehouse to integrate Derive with its graphing calculators. Derive 5 was the first Windows version released under TI, and the authors’ Introduction to DERIVE 5 was first printed in March 2000.

Derive 6 (2003–2004)

The authors’ Introduction to DERIVE 6 was first printed in September 2003. Soft Warehouse Europe’s product page called Derive 6 “an (upward-compatible) extension” of Derive 5 and listed its major new features:

• Display Steps: showing “the steps in the simplification of an expression along with the transformation rules applied”
• sending and receiving worksheets to and from the TI-89, TI-92 Plus and Voyage 200 CAS handhelds
• slider bars to animate parameterized plots, and 3D plots that rotate with the mouse
• customizable menus, toolbars and shortcut keys
• a scalable Derive Unicode font, HTML link hot spots in text objects, multi-line editing and parenthesis matching
• a function for computing the Gröbner basis of a system of polynomials

Because of the switch to Unicode, Derive 6.00 required Windows XP or 2000, and users of older Windows were told to stay on Derive 5.06. Two updates followed:

• 6.01 (English version dated 3 March 2004) expanded Display Steps, sped up factoring of Mersenne numbers (the revision notes say 2^170 − 1 factored in under a fifth of the time earlier versions took), widened the class of integrands with continuous antiderivatives and fixed a bug with assignments inside ITERATE.
• 6.10 (October 2004) restored compatibility with Windows 98 and Me, added a USB link to the new TI-89 Titanium, bundled TI-Connect 1.5, and added name completion in the Author dialogs.

6.10 was the final version. According to the University of Hawaii mathematics department and Wikipedia, TI discontinued Derive on 29 June 2007 in favour of the TI-Nspire CAS. No primary TI announcement of that date was found.

Design Philosophy

Derive was designed to be small. Stoutemyer’s 2008 talk, Ways to Implement Computer Algebra Compactly, explains why: he wanted computer algebra usable “in an ordinary classroom on a spontaneous as-needed basis”, and “for student problems, a compact program is more important than compact data or speed.” He credits muLISP with several space-saving features:

• Symbols without assigned values evaluate to themselves rather than raising an error, “which is what you want for computer algebra.”
• Function definitions are cdr-coded: they are stored as arrays of pointers, not linked cons cells.
• Identical sub-forms are stored only once.
• Non-public symbol names can be blanked out to save memory.

The same thinking shaped Derive’s arithmetic. The original DOS version had exact rational arithmetic but no floating point, so approximate results were done with rounded rational arithmetic at adjustable precision. Stoutemyer reported that at the default 6 digits, which he considered enough for most plots, it ran at “about the same speed as the then-prevalent 8 to 16 digit software floating point.” That comparison is with the software floating point common on late-1980s PCs that had no maths coprocessor. Later, once hardware floating point was common, the Windows version compiled expressions into reverse-Polish form and evaluated them in C with IEEE floating point to plot faster.

Even Derive 6 stayed small. A Scientific Computing World review called it “unusually compact for a symbolic package: 3.3Mb for the main program—about 8Mb with all support files.”

The second principle was pedagogy. Derive was sold mainly to schools, and Derive 6’s step-by-step display, which shows each transformation rule, was aimed at students who need to see why an expression simplifies, not just the result.

Key Features of the Language

Expressions, assignments and function definitions

Everything is entered on an edit line and becomes a numbered expression in the Algebra window. Variables are assigned with :=, and functions are defined the same way:

SUMSQ(x, y := 0, z := 0) := x^2 + y^2 + z^2
[SUMSQ(5), SUMSQ(5, 3), SUMSQ(5, 3, 2)]

The second expression simplifies to [25, 34, 38].

Extra formal parameters double as local variables, and they can be given default values in the parameter list, as above. If a function’s single formal argument is written without parentheses, it receives all its arguments as a vector:

FOO v := SUM(v)
FOO(2, 3, 5, 7, 11)

The call simplifies to 28.

Because Derive is a CAS, unassigned variables stay symbolic. Without the default values, SUMSQ(5) simplifies to y^2 + z^2 + 25, not an error.

IF with a third branch for “unknown”

Derive’s conditional takes four arguments:

IF(test, then, else, unknown)

The fourth branch is used when Derive cannot decide whether the test is true. If it is omitted, the whole IF expression is returned unevaluated, so later assignments or domain declarations can resolve it. The help system’s examples:

IF(h <= 40, 10h, 400 + 15·(h - 40))
SUM(IF(PRIME(n)), n, 1, 100)
REAL_ONLY(x) := IF(IM(x) = 0, x)

The first is a piecewise pay schedule. The second uses the one-argument form of IF, which returns 1 or 0, to count the primes up to 100 (25). The third is a filter that returns ? (Derive’s “unknown” value) when its argument is not real.

Recursion and iteration

The help system recommends recursion and the ITERATE/ITERATES functions for repetition:

FACT(n) := IF(n = 0, 1, n·FACT(n - 1))
POWER(x, n) := ITERATE(a·x, a, 1, n)
FIB(n) := ITERATE([k, j+k], [j, k], [0, 1], n)

With this definition, FIB(100) simplifies to [354224848179261915075, 573147844013817084101], the 100th and 101st Fibonacci numbers.

It also warns that the naive doubly recursive Fibonacci is slow because subproblems are recomputed, and shows how to fix this with an accumulator-passing helper function.

Procedural programming: PROG, LOOP, EXIT, RETURN

From version 5, Derive added explicit control constructs. The Derive 6 help defines them like this. PROG evaluates its statements in order “until an EXIT or RETURN statement is encountered or until its last statement is evaluated”. LOOP evaluates them “repeatedly until an EXIT or RETURN statement is encountered”. RETURN leaves the whole function, and EXIT leaves only the enclosing construct. The help system’s example reverses a vector:

Rev(v, w) := PROG(w := [], LOOP(IF(v = [], RETURN w), w := ADJOIN(FIRST(v), w), v := REST(v)))

After entry, Derive redisplays the definition as an indented block:

Rev(v, w) :=
  Prog
    w := []
    Loop
      If v = []
         RETURN w
      w := ADJOIN(FIRST(v), w)
      v := REST(v)

FIRST, REST and ADJOIN work on vectors “analogous to the way lists are processed in the LISP programming language”. This reflects Derive’s muLISP roots.

Update operators :+, :-, :* and :/ modify a variable in place. Here is an example from Johann Wiesenbauer in the DERIVE Newsletter (#53, 2004), which finds the smallest Taylor polynomial degree that meets an error bound:

napprox(u, x, x0, x1, epsilon, n := 0) :=
  LOOP(
    IF(ABS(SUBST(u - TAYLOR(u, x, x0, n), x, x1)) < epsilon, RETURN n),
    n :+ 1)

Other programming aids in Derive 6 include MAP_LIST, ASSIGN (assignment to a computed variable name), WRITE (show a value on the status line, for example a loop counter while debugging), DISPLAY (show intermediate results in a text box), and a quote operator ' that suppresses evaluation. For example, TERMS('(x + x + x)) gives [x, x, x] instead of [3·x].

Programs as utility files

A Derive “program” is an .mth file of definitions loaded with File > Load > Utility. Its functions can then be used like built-ins. Derive 6 shipped with many such files, including EquationSolving.mth (with NEWTONS and FIXED_POINT), ODEApproximation.mth (with PICARD, EULER and RK) and BesselFunctions.mth. These files show the language’s style in larger programs. The Scientific Computing World review counted 250 built-in functions plus more than 300 specialist functions and 30 user-contributed packages in loadable utility files.

Evolution

Platforms

Derive ran on MS-DOS PC compatibles (512K minimum for the 1988 release) and on Microsoft Windows from 1996. According to Stoutemyer, a ROM edition of the DOS version was also made for the HP 95LX palmtop. Derive 6.00 officially required Windows XP or 2000, and 6.10 added Windows 98 and Me. No official Macintosh or Unix version is documented in the sources reviewed.

Current Relevance

Derive is no longer sold or supported. TI’s replacement is the TI-Nspire CAS. Derive’s influence continued in TI’s handheld computer algebra, which TI France described as coming from a collaboration with Derive’s authors. Its community also lasted. The DERIVE User Group widened its scope to the TI-89 and TI-92 (“DERIVE USER GROUP + CAS-TI”), and its newsletter archive is still online. A volunteer has converted the Derive 6.1 help file to HTML so the language reference can still be read.

There is no Docker image and no open-source reimplementation. Running Derive 6 today requires an original copy on Windows or a compatible environment.

Why It Matters

• It brought computer algebra to ordinary computers. muMATH and then Derive put symbolic mathematics on 8-bit microcomputers and DOS PCs at a time when computer algebra otherwise needed mainframes.
• It showed how small a CAS could be. Derive’s muLISP engine, cdr-coded definitions and rounded rational arithmetic are practical examples of building a capable computer algebra system in a small amount of memory, which Stoutemyer argued still mattered in 2008.
• Many students learned to program with it. With function definitions, recursion, a four-way IF and later PROG/LOOP, Derive gave a generation of secondary-school students in Austria and elsewhere their first experience of defining their own functions.
• It led to TI’s handheld CAS. TI bought Soft Warehouse to bring Derive’s algebra to its calculators, and computer algebra on the TI-89, TI-92 Plus and Voyage 200 followed from that collaboration.

Sources and Verification Notes

• Soft Warehouse Europe, “A Brief History of the muMATH / DERIVE CASs” and “The authors of Derive” (archived derive-europe.com pages, last updated 10 July 2001): founding date, incorporation date, muMATH versions, October 1988 and October 1996 release dates, muSIMP details, naming, and the authors list.
• Soft Warehouse Europe, Derive 6 product description (archived January 2004) and “Revision Summary of Derive 6” (archived 2008): Derive 6 features, system requirements, and the 6.01 and 6.10 dates and changes.
• David R. Stoutemyer, Ways to Implement Computer Algebra Compactly: A Personal History (slides, July 2008, CCA 2008): muLISP design, the 1988 introduction of Derive, rounded rational arithmetic and its speed comparison, the HP 95LX ROM edition, the Windows engine, and the TI handheld implementation.
• Derive 6 online help (“Programming in DERIVE”, “Procedural Programming”, “IF Expressions”, “The ITERATE Function”, “Recursive Functions”, “Programming Functions”; © 1988–2003 Texas Instruments), via the WaluigiBSOD/derive6.1-online-help conversion. All language examples marked as coming from the help system are taken from these pages.
• B. Kutzler and V. Kokol-Voljc, Introduction to DERIVE 5 (first printing March 2000) and Introduction to DERIVE 6 (first printing September 2003), Texas Instruments.
• Scientific Computing World, “Derive 6: Far too good just for students” (the URL suggests the March/April 2004 issue): TI acquisition in August 1999, program size, and function counts.
• DERIVE Newsletter #53 (March 2004) and #56 (December 2004 editorial), austromath.at/dug: the Wiesenbauer LOOP example, the 1991 Austrian licence and its 6.10 renewal, and the 1992 Krems Spring School. DUG homepage: founded 1991, more than 500 members, Josef Böhm 1945–2024.
• Bergamini, Trifone and Barozzi, “Il linguaggio di programmazione di Derive” (Zanichelli, 2009): “Dalla versione 5” dating of the programming language.
• Texas Instruments France Derive 6 product page (archived 2009, as quoted on Wikipedia): the TI-89/TI-92 Plus algorithms statement.

Not verified: the 29 June 2007 discontinuation date (only secondary sources were found, not a TI notice); the exact release month of Derive 5 and of Derive 6.00 (dated here from their manuals’ first printings); whether PROG/LOOP first appeared in Derive 5.00 or in a later 5.x update (only the Zanichelli text was found for this); and the year of the HP 95LX ROM edition.