I am currently working on a New and Improved version of
PhysCalc, a total rewrite using C++ templates, lex and yacc,
and a small lisp engine I am writing.  It is of course not
at all ready for release yet.  I'm doing development work
under both Linux and Win95.

Planned features include:

    * Continued use of command line interface & GNU GPL.

    * Improved expression evaluation:

        - make exponentiation less of a kludge

        - minimal distinctions made between units,
            variables, and functions: any can be used in
            place of the other.  For example, "5 * meters"
            will become legal syntax, and functions without
            arguments can be used syntactically the same as
            variables.

        - implicit multiplication ("a b" means "a * b").
          Thus "5 meters" is literally the same as "5 *
          meters".  Signed numbers must be surrounded by
          parentheses or multiplication must be explicit.

        - More object-oriented style: a variable can hold
            values for many different aspects of something,
            with other values being automatically computed
            as needed.  For example, if Sphere.Mass and
            Sphere.Volume are set, then Sphere.Density can
            be deduced.  Default behaviors/formulas are
            programmable via some sort of "Default" object.

        - The Linux version will use the GNU "Rational"
            class to provide "infinite" precision math
            (everything will be internally represented as
            rationals, not reals.  The GNU Rational class is
            in turn based on an Integer class that can work
            with 128 kilobyte integers).  Since templates
            are used, it should be easy to change and
            recompile with the (GNU-style licensed) numeric
            class of your choice.

    * C++ code designed to allow easy inclusion of unit
        conversion (but not the full expression evaluator)
        into your code to enable easier and safer math, with
        minimal run-time overhead.

    * The lisp engine should allow total programmability, at
        least as far as doing math goes, if not as a general
        purpose language.

Features that should not be too hard to do once the planned features are done:

    * GUI versions

    * Vector, matrix and other new intrinsic capabilities

Other ideas:

    * Put PhysCalc capabilities into a user-friendly spreadsheet application