As agreed, I have created a full-fledged Differential Equations system of
classes rather than the calculator.  Rather than designing a user interface,
I have used operator overloading and other techniques to reach an intuitive
programming interface.

A full description:
  The general Class setup can be represented as follows:

		    SpaceDifferentialEquation
                     _____|     |     |______
                   /   SpaceDiffEqByFouriers  \
             SpaceFunction      |         SpaceField   
             ///||||\\\  |------^---------| ///||\\\
            Function-Nodes                Field-Nodes

With the exception of the Accessory Classes (Complex and SpaceVector) all
classes are derived from the SpaceDifferentialEquation Class.  These are
further separated into two groups by inheritance: SpaceFunctions which have
a value at every point, and SpaceFields which have a vector at every point.
In addition, there are two main types of each, depending on how they are
defined: either by an equation or by a file of Fourier coefficients.  More
on these later.  In addition, all DifferentialEquations defined by Fouriers
have some common pieces of information, so they have multiple inheritance
from SpaceDiffEqByFouriers as well.

A rather sophistocated example of the use of these classes is provided in
main.cpp.  There, you will find a set of differential equations that can
be used to model the sun using Magnetohydrodynamics.  Because such a comp-
licated set of equations cannot be mathematically solved, one must use iter-
ative methods to approximate the solutions through time.  To hold the state
of the system at one point in time, each function which is defined only by
its derivative (how it changes with time) has a file of Fourier coefficients.

The other functions can be defined in terms of more functions.  Similar to
the way the calculator works, as the set of equations are be defined, a tree
structure is set up, holding pointers to the various SpaceFunctions or
SpaceFields different operators act upon, using polymorphism.  Then, to find
out the state of any of these functions at a point, the syntax Function(phi,
theta, rho) is used, where phi is the degres from the x-axis, theta from the
z-axis, and rho is the radius of a system of spherical coordinates.  Each
function then calls the () operator on its operands, recursively collecting
data until everything is eventually defined in terms of Fourier coefficients.

I studied C++ methods of file input and output for this project... and there
is its downfall.  When you try to compile these source code files on Jupiter,
the compiler complains that a certain header file (cdefs.h) does not exist.
However, I have been able to get the program compiled using g++ on my own
computer, so it should work.  If you do find a way to compile the program, the
command is:

g++ *.cpp -o diffeq

Also a description of the files:
  readme.txt  - this file
  diffeq.h    - declarations of abstract base classes and accessory classes
  diffeq.cpp  - function definitions for diffeq.h classes
  defield.h   - declarations of classes which inherit from SpaceField
  defield.cpp - function definitions for defield.h classes
  defuncn.h   - declarations of classes which inherit from SpaceFunction
  defuncn.cpp - function definitions for defuncn.h classes
  fftalg.cpp  - highly modified version of the Fast Fourier Transform algorithm
  main.cpp    - example of the use of these classes (using MHD equations)
                  
I don't know if everything works, but I simply did not have time for completely
testing the classes.  I did, however, put considerable work into these classes
and far more time (and research?) than I would have with just the calculator
project, so if I could use some extra credit, I think I have earned it.

I think I covered everything.  If you want to know all the various types of
operations, you can see most of them in diffeq.h.  I also designed a couple of
classes which take doubles, double references, vectors, and vector references
(the references allow one to change the variable within the equation), and a
class which returns the current position being queried, when queried.  If you
have any questions, email me (profxanth@aol.com).