Yacas future plans
Future plans
The main targets Yacas is aiming at are:
- Yacas will be a library that is good at just one thing:
be a symbolic calculator. It should then be easy to
embed in other applications, or contemporary
platform-dependent user interfaces. It is just meant to fill
a void in symbolic manipulation tools currently available
for free.
- Bitrot-resistent. Yacas should be around ten years from now.
This is facilitated through:
- Neat coding style. No contemporary optimalizations.
- Small. This will allow easily targeting the code
to other platforms.
- platform-independent. It should even be easy to port
from its current c++ base to Java, when Java becomes
an option.
- Usability. It should be fairly easy to pick up on Yacas.
This is done through:
- Again, neat coding, so the code is readable to others.
- Good documentation. Code as well as utilized algorithms
will be documented.
Current progress is in the area of implemented algorithms. There
currently is limited support for doing integration (anti-derivatives),
and none for doing differential equations.
Also, the solver needs to be made more powerful. Object-oriented
programming is planned. Yacas is currently very suited for doing
calculations that need to be hand-coded though.
User interfacing
The plans are to have a user interface through an internet browser.
This opens up a myriad of possibilities.
The calculation would be sent back to a cgi script, which calls
Yacas, or Octave or GAP or whichever calculation engine is best,
and the results are sent back as a nicely formatted graphical
html page, possibly with nice graphics and nicely formatted formulas.
Graphics could even be done through Povray. Formula formatting
could be done through latex (with a resulting gif sent back), or
MathML, when all browsers support MathML. Online help, different
forms for different types of calculations. Yacas could then even
be accessible to portable devices. No need for installing
additional software. Tutorial or educational pages could
be made. Etc. etc. etc. And it separates the calculation engine from
the user interface, which could be a separate project altogether.
Documentation:
- document new functions:
- Conjugate, Rationalize, Find, MapArgs, Simplify
- Add documentation on used algorithms.
Test code:
Test code has not been updated in a while
Improvements to the engine
- Karatsuba multiplication
- faster Pi() calculation
- binarysearch in some places, in stead of linear search.
- it seems I can still optimize InternalEval
- trace facility.
- have a default RuleBase("Printable",{expression}), which returns
the same if no printable exists.
Rule("Printable",1,0,Type(expression) = "+" And NrArgs(expression)=1)...;
- bitwise MathNand.
- LispStringPtr also a magic pointer.
- give standard LispInput a line counter. Use it when printing
parsing errors. ("Error on line %d:\n")
- invalid argument: also print some more interesting info!
- severely clean up the code.
- Remove ALL TODO's
- javadoc-documentation.
- change all Yacas... to Lisp...
- Make a SysUtils class, with: free, malloc, file opening and closing,
strlen, and other needed function calls that might be different on
different platforms.
- split mathenvironment into that plus commands.cpp/h
- Remove all global functions, so it can be easily ported to Java!
- Add support for access to some engine information:
- GetPrecision()
- IsInFix, IsPreFix, IsPostFix, Precedence.
- io to strings in stead of to file: ToString, FromString, working
similarly to ToFile/FromFile, but from a string.
- additional debug code: count number of defined functions:
built-ins, RuleBases. This can be mentioned on the home page.
New mathematical functionality in scripting
- Lagrange interpolant
- Chinese remainder algorithm
- Partial fraction decomposition
- Singular value decomposition
- Factoring polynomials
- Groebner bases
- Some algorithms for solving differential equations
- expand on integrals. Rational functions, partial integration
and standard analytic function integration.
- Numerically solving polynomials of high degree.
- Severely improve simplification algorithms.
- redivide some code ('newly')
- gcd over many objects, as opposed to over only two items from
a field.
- Content, PrimitivePart
- InverseTaylor should also take initial values into account
- Change syntax for Limit: Limit(var,value) function
- Sylvester matrices.
- Resultants
- Bessel functions. Other special functions
- Eigenvector determination.
- Extend [[]] and [[]] := operators to also allow for other types
of objects, like assiociative lists, special sparse matrices,
algorithmic matrices, etc.
- AVL trees package.
- Support for multi variates in a native format
- Try to speed up Univariate code.
- improve on auto-simplification of forms like x^2*x.
- build BitAnd, BitOr, BitNot.
- Deal with 'Infinity'
- try changing all the 'math' code to use x and y in stead of aLeft/aRight.
- Exp,Log,Tan,Asin,Acos,Atan,pow in GMP form.
- Assume
- AssumeEnvironment
- support for object-oriented programming.
- support for some statistics functionality