
<html>
<HEAD>
<title>Yacas future plans</title>
<h1>Yacas todo list</h1>
</head>
<body BGCOLOR=WHITE>

<H1>Future plans</h1>

This is a todo list of things I want to get out of the way before version
2.0.

<H2>Engine functionality</H2>
These are the items specifying functionality that can not be implemented
from within Yacas, so have a rather high priority if the functionality
is needed.

<UL>
  <LI> pattern matching class.
  <LI> Add the karatsuba multiplication supplied by James Gilbertson (!).
  <LI> also define a Head and Tail for arrays, and append/concat/
       insert/delete/copy. This will ease swapping between lists
       and arrays.
  <LI> engine support for help on functions.
  <LI> export the reference manual in a form readable to the engine.
</UL>

<H2>Math high priority</H2>
This is the real meat, the functionality that should be in Yacas 2.0.

<ul>
<li> integrals const^f(x)
<li> redivide some code ('newly')
<li> make the current Solve command a SuchThat command.
<li> other structure for suchthat: x | a*x+b=z;
<li> Monic: return monic univar.
<li> LeadingCoef return leading coefficient of a poly.
<li> content: return {content,primitivepart} of a poly, where content
  is the gcd of the terms.
<li> InverseTaylor should also take initial values into account
<li> Deal with 'Infinity' everywhere

<li> factorizing polynomials
<li> groebner bases
<li> integrals over rational polys.
<li> see if using arrays for matrices speeds up things.
<li> Fix CanBeUni so that it deals correctly with 1/c
<li> InverseTaylor doesn't always seem to work correctly.
<li> Test script has been disregarded recently. Make a tests subdir,
     install it also, with a lot of small files that can be loaded,
     each implementing some tests.
<li> Eigenvalue of a matrix?
<li> EquateCoefs equate coefficients in two polys, and return as list.
<li> /. as with mathematica, treat args as locals.
<li> Content, PrimitivePart
<li> BUG: InverseTaylor not working correctly for Sin and Tan???
<li> BUG: complex^float.
<li> solving multiple equations, for multiple variables, returning
     multiple solutions
<li> allow solve to return a list usable in /.
<li> Sylvester
<li> GenMatrix
<li> MatrixRow
<li> MatrixColumn
<li> matrix^negative is inverse^positive
<li> render matrices nicely too.
<li> BesselJ
<li> Get started on differential equations: first order
</ul>



<H2>Documentation</H2>

The documentation can be improved. 

<UL>
<li> Future plans link on home page can now go into yacasinfo too.
     it will be just a short blurb.
<li> Add more of a general overview:
<pre>
  - introduction deals with:
    - what is Yacas? How did it come into existence? Why did I write it?
    - Who is it for?
  - getting started. deals with:
    - where to download.
    - how to compile and install
    - first steps on using it.
  - using yacas, a tutorial. takes the user through some concepts of yacas.
  - programming in yacas. describes the RuleBase/Rule mechanism, scoping
    of variables, evaluation scheme, and more.
  - advanced programming in yacas. describes some of the programming
    tricks used in the current packages.
  - reference. lists all functions, categorized by category.
</pre>
<li> introduction:
<pre>
  - About yacas being a symbolic manipulation engine,
    and explain why that is great (does a lot of work you would otherwise
    have to do by hand.) 
  - What it is not: numerical calculation engine, and graph plotter.
    since these can be done with other packages. Yacas solves one problem
    and attempts to do it well: symbolic manipulation.
</pre>

<li> document the source code.
<li> document the algorithms used.
<li> mention the use of lists for passing multiple arguments.
<li> mention the trick Flatten(lst,"List")

<li> document:
<pre>
  - Flatten
  - new Length: also working on strings and arrays.
  - StringMid, SetStringMid
  - Min and Max now also working on lists.
  - OpLeftPrecedence, OpRightPrecedence
  - PrettyForm, EvalFormula
  - html commands.
  - FakeDb... functions.
  - MapArgs, Substitute
  - Functionality of IsFreeOf wrt. to var being a list.
  - functionality of Gcd({list})
  - FindFunction
  - Vi: edit will try to edit a file, or if the argument passed is a
    function, it will try to edit the file the function is defined in.
    It will try to do so by invoking vi.
    It finds the function by scanning the *.def files that have been
    reported to the system.
    To be really useful, you need to go to the directory containing
    the original files, to edit the original files.
  - PatternMatches, PatternCreate
  - RuleBaseDefined, RuleBaseArgList
  - the #, <-- and _ operators
  - MakeVector
  - IsNegativeNumber, IsPositiveNumber, IsNotZero, IsNonZeroInteger
  
</pre>
</UL>

<H2>Engine internal improvements</H2>

These are nice to haves in the engine.

<UL>
  <li> An environment object. Within(environment)body should then
     evaluate something within the environment. Together with
     Apply this would allow for packages.
  <li> engine-side apply for speed.
  <li> engine-side subst for speed.
<li> Karatsuba multiplication
<li> faster Pi() calculation
<li>  allow substituting the standard print after eval with a custom one.
<li>  LispCleanupStack:
<pre>
  - LocalLispString
  - LocalLispPtr
</pre>
<li>  Clean up c++ code a little.
<pre>
  - Remove ALL TODO's
  - javadoc-documentation.
  - try changing all the 'math' code to use x and y in stead of aLeft/aRight.
</pre>
<li>  I should have garbage collection on lispstrings in the hashtable!!!
<li>  maybe optimize anumbers here and there?
<pre>
  - avoid copy-constructors as much as possible
  - Swap in stead of copy for the array growers, is a lot faster than
    copying and then deleting the original.
</pre>
<li> generate html pages from the source code.
<pre>
  - modify the parser to allow this.
</pre>
<li> server:
<pre>
  - use getpid for stopping.
  - pass exec id to yacas.
  - externalize execpid
</pre>
<li> allow access to the rules database from within yacas, for showing
  the rules to the user.
<li> infixprinter should perhaps insert a space once in a while, if token
  types are the same left and right (ascii or oper)
<li> Nobrainer: clean up server code.
<li> optimize string concatenation.
<li> proper sending of strings to server... goes wrong with DBaseSend
<li> Try to find all the places that can use the CArrayGrower with the
  iArrayOwnedExternally set.
<li> it seems I can still optimize InternalEval
<li> Finish arb. math stuff. (ASin, Acos, ATan)
</UL>


<H2>Math nice to have</H2>
<ul>

<li> Clean up TrigSimpCombine and Simplify in such a way as to make the
      code reusable for other simplifications.
<li> some more integrals:
<pre>
  - deal with integrals Trig(f)*rest, like Sin(x)*Exp(x)
</pre>
<li> QSort
<li> BinarySearch (array!)
<li> FourierTransform?
<li> LaplaceTransform?
<li> Singular Value Decomposition.

<li> solve taking more than one expression, and solving for more than
  one variable.
<li> LatexForm, CForm, FortranForm
<li> Sylvester matrices.
<li> Resultants
<li> Lagrange interpolant
<li> improve simplification
<li> some DE algos.
<li> Neater code in the scripts (simplify, trigsimp, etc)
<li> have a default RuleBase("Printable",{expression}), which returns
     the same if no printable exists.
     Rule("Printable",1,0,Type(expression) = "+" And NrArgs(expression)=1)...;
</ul>


</BODY>
</HTML>
