                         Ideas to code in Mathomatic
                         ---------------------------

A free software GUI needs to be written for Mathomatic. Anyone interested in
writing one should contact the author at some point, so it can be included in
the Mathomatic distribution.

Implement natural logarithms as the "log(x)" (or "ln(x)"?) function, using a
dummy operand internally. The dummy operand can be the V_NULL variable (or
V_E variable or M_E constant for logarithms with changeable base) and should
be first. The rules for logarithms can be slowly added later. This is a large
project that only George Gesslein II knows how to do properly (well, maybe).
An easier idea to implement will be to make logarithms a binary operator like
in the J programming language, then use m4 to map it to the log(x) and ln(x)
functions.

Simplify nested radicals like ((9 + 4*(2^.5))^.5) to (1 + 2*(2^.5)). This may
be difficult, I don't know how this is generally done. Slow trial and error
algorithms are not acceptable for this. Here is an article on how to do this:
http://www.almaden.ibm.com/cs/people/fagin/symb85.pdf

Use the GNU Scientific Library (GSL) to automatically numerically solve any
degree numeric polynomial equation, like "misc/roots.c" does, when symbolic
solving fails. Unfortunately, this will make Mathomatic dependent on the GSL,
so I may not do this. Instead, the general cubic formula in "tests/cubic.in"
could easily be hard-coded into the Mathomatic poly_solve() function, so any
cubic equation could be automatically solved. I just haven't figured out how
Mathomatic is going to easily handle 3 solutions per equation space. Solving
quartic equations with "tests/quartic.in" is not recommended, due to the
large, accumulated round-off error of floating point when approximating large
formulas, though handling 4 solutions is very easy in Mathomatic.

Implement complex number factorials, when an accurate floating point complex
number gamma calculating function is found. The GSL does this.

Make polynomial gcd calculation partially recursive. This is difficult, as
the expression storage areas are currently static globals. If successful,
this will make polynomial gcd calculation multivariate, so it will succeed
with larger expressions with many variables. There is no need for total
recursion, because it would never be used anyways, with the amount of
floating point round-off error that occurs in Mathomatic. Every inexact
floating point mathematical operation has a small round-off error that adds
up with many operations.

Add a "polynomial" command that tells what type and degree polynomial the
current expression is, if it is a polynomial in the specified variable. Study
Maxima's facsum() function, it does a related thing.

matho and rmath don't work perfectly; because they use m4 as a front end,
there are some user interface problems. I probably should write some C code
to do the string macro expansion as part of the main mathomatic program. If I
am feeling better I will do that and add logarithm function support.


This file was written by George Gesslein II of www.mathomatic.org
