- Big improvements to Proteus (AP).
- Implemented FactorialSimplify (AP).
- Added pcre as a plugin (including the source code). This is the Perl-compliant regular expressions library (AP).
- Added the filescanner plugin (AP).

- Updated the Windows binary build sequence: there is now a "makewin.bat" batch file in the root directory which builds the entire binary release in the winrel\ directory.
- A better Solve() function. (JN)
- More intelligent parsing: combined operators like ==- and :=- and such are now handled dynamically in the infix parser. (AP)
- changed evaluation calling sequence for functions at kernel level, so that arguments have to be evaluated *before* they are passed to the function (AP).
- improved documentation on kernel-level functions (SW)
- automatic documentation for plugins (SW,JN)
- automatic extraction of stubs for plugins, better GSL support (SW)
- support for 2D and 3D plotting with GMT (SW)
- some small changes to plugin structure to make it compile on a MacOSX again (AP).
- Beginnings of a compiler in inprogress/compiletest.ys (AP)
- Added TrapError and GetCoreError, to be able to handle errors in a custom way (AP).
- Added the OMParse function, which can parse OpenMath expressions and convert them to a Yacas expression (AP).
- Nested backquotes are not expanded any more (bug reported by Serge) (AP).
- Documented XML support (AP).
- Implemented and documented the read-eval-print loop which now runs from the scripts (AP).
- Added ToStdout, for use with debugger (which works again) (AP).
- Various bug fixes: Listify and UnList coredumping if the argument passed was not proper, xml tokenizer not general enough (AP).
- various bug fixes from the bugs.txt document (AP)
- no need to look up string in hash table any more before creating a LispAtom with it (AP)
- reduced the number of times conversions were made between BigNumber and LispString (AP)
- automatic generation of corefunctions.ys (AP)
- initial usable compiler that converts scripts to C++ (AP)
- Implemented and deployed binary factoring algorithm (AP)
- removed Berlekamp function from core, is now replaced with binary factoring algorithm (AP)

- New build option --with-numlib=... instead of --enable-gmp (JN)
- New GetTime() core function to replace Time() (AP,SW)
- Fixed bug: Sqrt(4) not simplifying to 2 the first time it was typed. (AP)
- Daniel fixed a bug: EPOC version now runs again on a Psion PDA!
- Fixed bug: relating to the Sqrt(4) bug. Yacas will now always load a script file if it is associated to a function that is about to be evaluated (AP).
- Changed LispRead back to its old behaviour, and added LispReadListed
- small tweak in yacasapi: function IsPromptShown has been moved back to yacasmain.cpp, where it belongs. (AP)
- Created initial version of embeddable library, libcyacas.a (AP)
- Initial support for a Windows DLL with the scripts inside it (AP)
- Added initial files for Python binding supplied by Gary Bishop (AP)
- BUGFIX: Simplify((a^2+b^2)/(2*a)) never terminating (AP)
- Added files with place holders for distribution functions, supplied by Andrei Zorine (current version does nothing but check for correctness of input values). (AP)
- Added the function ReadCmdLineString which now would allow one to write a custom read-eval-print loop. (AP).
- BUGFIX: 0*{a,b,c} returned 0 instead of {0,0,0} (AP)
- Added "Dimensions" function and "IsSquareMatrix" function, and improved "IsMatrix" function using "Dimensions". Code supplied by Dirk Reusch. (AP)
- Added function PlatformOS() which returns the platform type. (AP)
- New library functions for platform-specific work: MakeDir etc. (SW)
- Supported plotting under Windows with gnuplot (wgnupl32.exe) (SW)
- Added {JacobiSymbol} to the number theory section (SW)
- Added {IsSmallPrime}, a table look-up of small prime numbers (SW)
- Added a small "glossary" section to refman, with explanations of terms, users can now type e.g. ?arity or ?rules (SW)
- Added some facilities for literate programming (SW)
- Added GPL-related blurb to Yacas startup screen and to docs (SW)
- Initial changes to avoid rebuilding the whole HTML manual (SW)
- Improved Trace, with test code, supplied by Dirk Reusch. (AP)
- Initial implementation of LispNumber, a first-citizen implementation of numbers. (AP)
- Made a custom evaluator: one can place hooks that get called back during evaluation. An interactive command line debugger and little profiler have already been implemented with it (AP)
- Added what is initial libtool support (AP/JN)
- changed command line functionality: if you type a substring, the up and down arrow will browse through history using the string before the cursor as a prefix filter.(AP)
- Initial version of the new numerics class encapsulating a numeric library. New numerics supports precision tracking. (AP,SW)
- Larger history by default: 1024 lines. I think no one who uses Yacas will mind a 50Kb history file in their directory, and the original default of 50 seemed too small. (AP)
- Added outer product, with docs and test code, written by Dirk Reusch (AP)
- plugin compilation, initial libtoolized version (builds static libraries?) (AP)
- Added a Gnu Scientific Library plugin, yacas_gsl (AP)
- Added Java console applet that can connect to a server (AP)
- Changed socket server code to single-threaded server, and added support for sessions. Multiple sessions can be maintained, but only one request at a time can be processed. (AP)
- Robustified the server code, and the Java applet, added output porting to the console, various additions to the applet to finalize it (AP)
- re-added the server-side code in Yacas: the flag '--enable-server'
can now be passed to ./configure, after which you can pass the
flag '--server
' on the command line to yacas, after which it is a server. You can telnet to it, type a string, and return back a result. (AP) - Added initial support for macro expansion. (AP)
- Finished macros, with support for listed (variable-length) arguments, and implemented a function {Macro} which does the same as {Function}, but for macros. (AP)
- Added "IsScalar" and "IsVector" w/ docs and test code (dr)
- Changed "IsMatrix" and "IsSquareMatrix" slightly and updated/ added docs and test code (dr)
- Added new function "Dot" as a replacement for "InProduct" and assigned the "."-Operator to it. It works for vectors and matrices, is documented and there is test code.
- Added new function "MatrixPower" w/ docs and test code (dr)
- Added some trigonometric and hyperbolic function rules (e.g. Sin(ArcCos(x))=Sqrt(1-x^2),...) (dr)
- Numerics now support mantissa notation by default. One can now type numbers like 1.2e-3 and Yacas will understand. (AP)
- Added new function "NthRoot" w/ docs and test code. It calculates/ simplifies nth roots of positive integers. (dr)
- Added documentation hyperlink feature to plaintext docs formatter. (SW)
- Added surface plotting Plot3DS() and tests for the plot.rep suite. (SW)
- Added rule for "Abs(Undefined)". (dr)
- Added rules for "IsNotZero(x_IsInfinity)" and "Sqrt(-Infinity)". (dr)
- Added some argument checks for arithmetic operations on lists. (dr)
- Added some number theory functions contributed by Pablo De Napoli. (SW)
- Optimized CatalanConstNum and added more algorithms and docs (SW)
- New linear algebra functions: Diagonal, IsDiagonal, IsUpperTriangular, IsLowerTriangular, ToeplitzMatrix, Sparsity, Cholesky, RandomIntegerMatrix and docs (Jonathan Leto)
- Determinants+EigenValues of arbitrarily sized Triangular/Diagonal matrices are now very fast. (Jonathan Leto)
- ZeroMatrix now also takes only one parameter, to make a square matrix. (Jonathan Leto)
- Improved GaussianFactors and added algorithm docs (Pablo De Napoli)
- {MatrixSolve} solves A*x=b using Gaussian Elimination and backward substitution. (Jonathan Leto)
- {Determinant} can now do arbitrarily sized determinants of full matrices relatively quickly, using Gaussian Elimination (Jonathan Leto)
- {OdeSolve} can now solve any 2nd Order Linear Constant Coeffecient Homogeneous ODE (Jonathan Leto)
- Started ref chapter on differential equations (Jonathan Leto)
- Started ref chapter and algo chapter on {LaplaceTransform} and added initial code (Jonathan Leto)
- BUGFIX: BesselJ(n,x) and BesselI(n,x) were not properly returning unevaluated (Jonathan Leto)

- improved presentation of Web page (AP)
- IsError() in CYacas (AP)
- version info for windowsish platforms: Unix version dumping a version.h that can possibly be used by a windows version. (AP)
- Added statistics.rep/ directory, along with the files that Andrei has sent so far, edited a little (AP)
- Added direct application of pure functions: [pure:={{a,b},a+b} ; ` @pure(2,3);] returns 5 (AP)
- Added documentation on the direct application of pure functions and on back-quoting, in coding.book.txt (AP)
- Pretty-printing FullForm(...) (AP)
- fixes for the EPOC version, which should now compile again. (AP)
- Made a fix in Makefile.am, the depend target had mysteriously disappeared (AP)
- Added a 'common lisp' tokenizer, to facilitate transition to compiled Yacas (AP)
- added scopestack.ys in lists.rep/: support for a scope stack like the internal interpreter uses (AP)
- Added initial version of documentation of the core language implementation, as it is hopefully going to be in the future (AP)
- Added new code in statistics.rep/ and probability.rep/, from Andrei Zorine, and also added documentation on statistics in the ref.book manual (AP)
- Split the links section from the main information section on the web site, and started a more extensive list of links, to free documentation and articles, and other math packages in general. (AP)
- Reorganization of the makefile scripts: fixed make distcheck, make test, make installcheck, test script log file, now can build outside source tree (Jitse)
- BUGFIX: sums.rep/code.ys.def still referred to {Sum}, should be {Add} now. Same for statistics.ys and regression.ys (AP)
- split the long "essays" book into essays and algorithms ("Algo") (SW)
- added new architecture for random numbers: {Rng}, {RngCreate} etc. (SW)
- added new core functions: {MathLibrary}, {IsPromptShown} (SW)
- added Euler's constant {gamma} to "cached constants", fixed N() to evaluate N(gamma) (SW)
- new algorithm docs for orthogonal polynomials, gamma constant, gamma function, error function, continued fractions; renamed "staggered factorials" to "double factorials" in the docs, as that seems to be the accepted terminology (SW)
- {PartitionsP} function added, with algorithm docs. (Jonathan Leto)
- New Functions: {Eulerian},{PolyLog},{Sinc},{DirichletEta},{DirichletLambda}, {DirichletBeta},{Digamma} for positive integers,{Euler}, {StirlingNumber1},{StirlingNumber2},{BellNumber}, Fibonacci polynomials (Jonathan Leto)
- New constants: {GoldenRatio},{Catalan} (Jonathan Leto)
- BUGFIX: n^(-m) now stays symbolic (Jonathan Leto)
- new standalone script {ytxt2tex} to generate TeX docs outside of the Yacas tree, documentation (SW, Jitse)

- Wester test for BesselJ(2,1+I) now passes. (Jonathan Leto)
- New functions: MultiplyNum, NewtonNum, SumTaylorNum, optimized for numerical evaluation; new LnNum algorithm for much faster N(Ln) (SW)
- New global stack functions: GlobalPush, GlobalPop (SW)
- New linear algebra functions: {HilbertMatrix},{HilbertInverseMatrix}, {FrobeniusNorm},{PNorm},{Norm},{OrthogonalBasis},{OrthonormalBasis}, (Jonathan Leto)
- speeded up IntNthRoot for large integers by using FP arithmetic (SW)
- added new function LambertW, documented (SW)
- documented the Rabin-Miller algorithm (Christian Obrecht, SW)
- New functions: {IsGaussianInteger},{IsGaussianPrime},{IsCoprime}, {Repunit},{HarmonicNumber},{Divisors},{DivisorsSum},{ProperDivisors}, {ProperDivisorsSum},{FermatNumber},{Moebius},{IsPerfect}, {Totient},{IsQuadraticResidue},{LegendreSymbol}, {IsTwinPrime},{IsIrregularPrime},{IsAmicablePair},{DigitalRoot}, {Subfactorial},{IsComposite},{IsSquareFree}, {IsCarmichaelNumber},{RootsOfUnity} (Jonathan Leto)
- added new option {yrange=...} to Plot2D to specify range of ordinate (SW)
- BUGFIX: PrettyForm now works correctly on lists.
- Ayal: Update of the files that belong to the epoc distro.
- Ayal: Added Sturm sequences, Finding real roots, finding number of real roots, documentation on this, and test code for Sturm.
- Newton iteration can now also accept minimum and maximum values, so it halts when trial values fall outside of these bounds, and the routine returns Fail (AP).
- Added more documentation to the coding book: explanation of the evaluation scheme (AP).
- {Gcd} now takes Gaussian Integers. (Jonathan Leto)
- Added {IsCFormable}, {AssocDelete}; started a new global error reporting scheme: {Assert}, {IsError}, {GetError} etc. Prettyprinters ({TeXForm}, {PrettyForm}, {Print}) report errors. New repository {io.rep} for command-line interaction stuff (help, prettyprinters, errors, ...). Moved {formula.rep} there too. (SW)
- Cleaned up {yacasinit.ys} and {standard.ys}; moved {print.ys} to {io.rep}; made {packages.ys} automatically remade on {make}/{make test}; {yacasinit.ys} now uses {packages.ys} to load all {.def} files; cleaned up some old {.def} files that were copies of {.ys} files. (SW)
- Cleaned up and reorganized the Emacs yacas-notebook code (Jay Belanger)
- Speed up of OrthoP (Legendre), OrthoL, OrthoH, OrthoT, OrthoU in case of symbolic argument (SW)
- General architecture for cached numerical constants {CachedConstant}. (SW)
- TeX documentation is now automatically indexed; new semantic of *A label to add index entries; new labels: *FOOT, *EVAL; updates to docs (SW)
- {Lcm} and {IsCoprime} now can take lists as arguments. (Jonathan Leto)
- added GNU Free Documentation License to docs (SW)
- speed up of (a+b*I)^n and Erf(); Erf(x) works for large x (SW)
- first implementation of symbolic/implicit summation (Ayal and Jonathan Leto)
- added more documentation on evaluation scheme in Yacas (AP)

- Implemented a fast recursive factorial algorithm in scripts; added new functions n!! ("staggered factorial") and a *** b ("partial factorial"), significant speedup of Bin(); tests added; factorials of half-integer arguments now use fast staggered factorials; all documented (SW)
- Removed HTML files from tar.gz to save 30% space -- they are regenerated anyway, and users can download documentation separately if they can't make it (note: generating HTML or PS/PDF docs currently requires Perl) (SW)
- Ayal: Out> now not shown any more if PrettyPrinter is used.
- Ayal: Fixed bug: TrigSimpCombine(Exp(A*X))
- Ayal: added a specification of how I think {Solve} should work in the future, to new.chapt.txt.
- Ayal: added "Where" and "AddTo" operators, and documented their use.
- Ayal: refactored the integration code into cleaner and faster and also more correct code, based on some bug reports. Also added MatchLinear (which can perhaps be used in more places?)
- Ayal: threaded integration (integration on lists)
- Ayal: Swapped the arguments to IsFreeOf and CanBeUni, because then it can be used for patterns as x_IsFreeOf(y) which makes more sense.
- Ayal: Changed IsHermitean to IsHermitian
- Ayal: fixed bug: Taylor series around a singularity, terminates immediately
- Ayal: fixed the {numerics.yts} failure: it was actually a failure by the program to simplify expressions containing {Pi}.
- Ayal: improved multivariates, by using a better sparse representation: recursive sparse tree. Also added a driver structure to allow changing representation later.
- Ayal: implementation of sparse trees: a recursive sparse representation that can be useful for polynomials and matrices/vectors.
- Ayal: when a rule is being defined for a new function which is mentioned in a .def file, the corresponding script file is immediately loaded. This is used to make sure that <-- patterns do not hide library definitions.
- Ayal: fixed bug where redeclaring a function could cause segfaults.
- Ayal: functions with variable number of arguments implemented (RuleBaseListed).
- Added convenient Function() and := formats for declaring functions with variable number of arguments. See ?Function, ?:= (SW)
- Ayal: Initial implementation of compressed archive filesystem for the script library (--archive option)
- Documentation updates: added experimental scripts {book2ys.*} for automatic extraction of Yacas code from documentation; added comment (*REM) label and trailing punctuation to displayed equations; documented Newton and Halley's method, AGM sequence, Taylor summation in essays (SW)
- Implemented adaptive 2D plotting {Plot2D} in {plots.rep} and multiple backends architecture (so far only gnuplot or plotutils but easy to add support for more) - replaces {GnuPlot()} (SW)
- Removed {GnuPlot} altogether -- people should use {Plot2D} since it's much better. See ?Plot2D (SW)
- Improved integer factorization algorithm: {Factor(500!)} now works, avoids infinite loop in {PollardRhoFactorize}; added factorization tests; the list of prime factors is now sorted (SW)
- New fast algorithm for {IsPrimePower}/{GetPrimePower}; added new functions: fast {IntLog} to replace slow {CountBits}, and {IntNthRoot} to avoid floating-point computations for roots, documented algorithms (SW)
- Added some tests for {Deriv} (Jonathan Leto)
- Added an essay chapter on Wester benchmarks, with automatic test code extraction; currently 39 tests pass (SW)
- Added Linear Algebra functions: {IsSymmetric}, {IsSkewSymmetric}, {IsOrthogonal}, {IsIdempotent}, {VandermondeMatrix}, {JacobianMatrix}, {WronskianMatrix},{HessianMatrix} (Jonathan Leto)
- Fix for integrating {Abs(x)}, removed arbitrary constant in {Integrate}, {Simplify} now works on {if}/{then}/{else}, fix for taking derivatives D(x) Ln(x)^a when a does not depend on x; speedup of {OrthoT}, {OrthoU} (SW)
- Added rules for {ArcSinh}, {ArcCosh}, {ArcTanh} for numerics on real and complex numbers, added numerical tests (SW)
- Added ExpandFrac(), fixed ExpandBrackets(), added new (better) random number generators (SW)
- Apply() and @ can now work on function atoms as well as on function names (SW)
- Fixed all known bugs dealing with {Infinity} and {I}, including {Limit} bugs. (Jonathan Leto)
- Added preliminary versions of {BesselJ}, {BesselI}, {Erf}, {Erfc}, {FresnelSin}, {FresnelCos} (Jonathan Leto)
- Ayal: made floating point not propagating in expressions like 1/1.2
- fixed 'mkhomepage' and 'make distcheck' to work (SW)

- Started essay chapter on numerical algorithms used in Yacas (SW)
- Fixed bug in the definition of IsEven() and IsOdd() (SW)
- Fixed GnuPlot() to plot a more broad set of functions (SW)
- Added arbitrary-precision and analytic implementations of Gamma function, Zeta function and Bernoulli numbers and polynomials (SW)
- Improved layout of TeX documentation (use smaller monospaced font) (SW)
- Added various arbitrary-precision implementations of Pi() in examples/pi.ys (SW)
- small bug fix: In> Integrate(x) x^x Out> x^(x+1)/(x+1)+C39;
- speeded up calculation of MathPi() by factor of 3 (SW)
- added a new package repository "specfunc" with special functions and documented them in a separate chapter of the reference manual (SW)
- bug fixed: exact factorials of negative half-integers were not given (SW)
- introduced new "<>" (\sim) and "<=/>>" (\approx) infix operators for cosmetic purposes (used in the manual)
- New functions ContFracList, ContFracEval, GuessRational, NearRational to find optimal rational approximations to numbers (SW)
- added section in the manual with a full listing of all core functions (generated automagically from yacasapi.cpp) (SW)
- {yacasdebug} now can be built together with non-debug {yacas} (renamed all *.o files to *-d.o) (SW)
- Ayal: added email addresses to AUTHORS
- Ayal: Removed Windows-style new lines from various files
- Ayal: made make clean remove all generated binaries, including the yacasdebug ones
- Ayal: Added Pari-GP to the list of available CAS-ish systems.
- Ayal: yacaslogo.gif didn't get installed.
- Ayal: changed Verify to get left arg unevaluated, so it shows a correct error.
- Ayal: Fixed KnownFailure in numerics so it is passed in a Verify(...)
- Ayal: postfix operators can now be applied after each other without braces, eg "3! !"
- Ayal: Code to assert a help browser called the ":=" operator, causing scripts to get loaded at startup.
- LispString objects now maintained with smart pointers in more places (work in progress).
- moved short descriptions of books ("blurb") into books themselves out of the build scripts (SW)
- fixed documentation building scripts so that individual (non-framed) html files can now be built (SW)
- added a paper describing Yacas (in essays book) and a short conference paper (docs/paper1.tex, docs/llncs.cls)
- implemented fast sorting ({HeapSort}) for lists and generic arrays (SW)
- fixed Swap() to work on generic arrays as well (SW)
- fixed Postfix() to accept precedence argument (SW)

- Added initial version of a compiler to convert Yacas script code to c++
- Initial version of code to make writing documentation a lot easier.
- Small fix to InverseTaylor which could return wrong results when taking the inverse of a function at x0 != 0
- Small bugfixes to CForm and TeXForm.
- Small bug fix: In> Integrate(x,0,1)1-x^a; Out> 1-1/(a+1)+0^(a+1)/(a+1); In> Simplify(%); never halted
- Small speed improvements in arithmetic operations
- Bug fix: Div(x,y)*y+Rem(x,y) did not always evaluate to x, when either x or y was negative.
- Bug fix: Mod(x,y) is now undefined if y is less than zero.
- added txt2yacasdoc.pl - converts plain text to Yacas doc files
- Started an "essays" book with essays on using Yacas
- Added essays on: Yacas maintenance howto, formatting documentation, writing plugins
- Added part to installation: yacas header files are now also installed in /usr/local/share/yacas/include for use by the outside world (e.g. to compile plugins).
- Added --patchload option in the Yacas exe, to use for generating html pages for the web site.
- Changed ./mkhomepage to generate the full web site, including download files for the manual in html, ps and pdf format. The site is generated in homepage/
- Small bug fix in proteus: no crash when it can't find the hints file
- Small bug fix: -{...} with the variable x in the list would do strange things
- Initial version of profiler in the Yacas debugger: show all functions called with the number of times they are called, and sorted by call count.
- Added the function DllUnload to unload plugins.
- Added DllEnumerate, which returns a list of loaded DLLs/plugins.
- Added MakeFunctionPlugin() to dynamically generate plugins (Unix only) (SW)
- Added GetYacasPID() to get a session ID (Unix only) (SW)
- Added a manual chapter on platform-specific add-ons, documented GnuPlot
- Floats obtained from a system call now get mapped to 24 decimals precision iso. the default 6. (platmath.cpp)
- Added the '--init [file]' and '--rootdir [path]' options.
- Initial version of LaTeX exporter for Yacas documentation; optional target "make texdocs" will prepare all Postscript and PDF versions (SW)
- ShowPS() will display an expression in a Postscript viewer (Unix only) (SW)
- Fixed Op{,Right,Left}Precedence() for prefix/postfix/bodied operators (SW)
- Fixed broken Windows version, was due to command line support trying to use WinNT-native command line.
- All documentation is now maintained in plain text format and exported to HTML. All five documentation books are hyperlinked and installed. (SW)
- Fixed the ArcSin, ArcCos, ArcTan functions to work correctly with multiple-precision numbers (when using internal math). (SW)
- Added tests/numerics.yts to test multiple-precision math. (SW)
- 30% speedup of all numerical calculations by caching previously found multiple-precision value of Pi. (SW)
- Added utility functions IsNumericList(), NFunction(), PrintList() (SW)
- Documented HoldArgNr, RuleBaseArgList, Op{Left,Right}Precedence
- made a yacasdebug executable (built with makefile.debug) which also does memory heap checking.
- Added some more sections to the manual: section on the yacas debugger, the test suite, and documented various Yacas commands.

- small improvement to Arg(...) working on real numbers.
- improved 'make test', no need to install before test any more.
- VarList can now accept a second argument, a filter predicate.
- Pattern matcher now allows extended prototypes, like PP(list_Contains("a")) <-- ... etcetera.
- c-style tokenizer using CTokenizer() (DefaultTokenizer() switches back to the default tokenizer).
- Great speed-up of function Assoc.
- Christian Obrecht implemented the Rabin-Miller primality testing algorithm, which greatly improves the speed of IsPrime.
- Orthogonal polynomials OrthoP, OrthoP,OrthoG,OrthoH,OrthoL, OrthoT,OrthoU implemented by Serge Winitzki.
- various speedups, and a new memory manager, optimized for allocating many small blocks (which is the case in Yacas).
- Changed the directory structure for the script files
- Greatly improved Simplify function.
- Added CurrentFile, CurrentLine functions
- Implemented backquote mechanism: `(...) will substitute every @a with the evaluation of a (and if a is a function the function name is replaced). The end result is evaluated. see substitute.cpp for more details

- initial texmacs support.
- Jitse Niesen greatly improved the parts of the manual on variables and on input/output.
- Bug fix in localrules (didn't work on more complex input, because it didn't check the leading function type!)
- Bug fix : loading of files on Windows was broken. The Windows client didn't handle Unix-style end-of-lines too well.
- Renamed TryRetract to Retract (Suggested by Jitse).
- Put NewLine and Space in the scripts as opposed to in the Yacas kernel (Suggested by Jitse).
- Jitse added one-liner descriptions for functions in the documentation.
- latex form in texmacs.
- Greatly improved CanProve, thanks to Vladimir.
- Initial version of Berlekamp factoring.
- changed all the scripts so they have the extension .ys.
- proteusdebugger: an initial version of a debugger for yacas.
- Change to configure script to support compiling under cygwin, with plugin support.
- Bug fix to multiplying complex numbers with lists.
- Made Content and PrimitivePart respond more nicely to polynomials with rational coefficients.
- Small improvement to the debugger: it now also steps to non-expandable lines when you use the step buttons.
- numbers with a minus sign now parsed into negative numbers, as opposed to a function -(number)
- configurable simplification of inequalities in the logic code.
- Split out the tests into many test scripts in directory tests/

- Bug fix: N(Sin(a)) returning 0 (also a problem with Cos). The problem was due to the system trying to do a SinMap, where Pi becomes a number, and the converting to a univariate polynomial in Pi screws up.
- better support for mapping numeric arguments of Cos back to the 0 to Pi range.
- made rules that are always true a little faster.
- fixed bug with Gcd when passing floating point numbers. Reported by Fredrik Noring.
- Small change to proteus (Mark).
- Added example "MinimumSpanningTree".
- Bug fix: interpreter crashed if a function refers to another function which gets redefined.
- Bug fix: Limit(x,Infinity) going wrong on -Infinity/Infinity.
- added Integrate(var)(function) which returns the antiderivative of a function. Suggested by Christian Obrecht.
- Fixed "gnuplot" (broken due to the changed functionality of N(..) ).
- Fixed bug: CanProve(P Or (Not P And Not Q)) returned the wrong answer. Reported by Vladimir Livshits.
- Fixed bug: Cos(0) wasn't evaluating to 0 any more.
- improvements to documentation.
- Derivatives now better threaded.
- fixed compiler warnings: anumber.cpp under Windows compilation (reported by Vladimir), Proteus warnings under Debian (Reported by Gopal).
- removed -g option for compilation. Made executable seriously smaller.
- Much improved Limit, thanks to Christian Obrecht.
- Small improvements to Proteus.
- pretty printing of vectors and matrices.
- Limits can now deal with direction (limit from Left or Right).
- PSolve for 3rd degree fixed by Robert.
- Added operators /: and /:: .
- Incorporated the changes for complex numbers Christian sent in. Arg now implemented correctly.
- better numeric Ln and ArcTan.
- functions that are not defined yet are now returned with their arguments evaluated. Eg f(2+3) returns f(5) instead of f(2+3).

- Fixed bug: Floor or Ceil working on 0.5 would result in an infinite loop.
- Started work on solving differential equations (scripts/odesolver).
- Some bug fixes thanks to Robert V Schipper.
- Some bug fixes on limits involving infinity, due to Mark Arrasmith.
- Bug fix: Decimal didn't work correctly on negative numbers. Reported by Gopal Narayanan (Debian Yacas package maintainer).
- Fix sent in by Gopal Narayanan so Yacas works with libgmp3.
- Added Proteus, the user interface for Yacas using the fltk widget set, to the distribution, in directory proteus/

- Unfenced the if and else operators.
- Implemented first installment of RadSimp
- Yacas can now do 39 of the Wester benchmark calculations (up from 25).
- Updated Psion organizer version (EPOC32).
- Added derivatives and antiderivatives of Sign,Abs and if .. .. else .. constructs.
- fixed two bugs that caused Div(x+1,x) to not work immediately after startup.
- Integrating (a*x)^(fraction) not working, but (a*x)^(integer) did.
- improved some complex number functionality, Sin/Cos calculations.
- gcd, div, mod fix for rational numbers.
- Continued fraction expansion of polynomials, DivPoly which does an efficient division of polynomials, returning a polynomial.
- small cleanup of the code
- added functions: Pslq, Floor, Ceil, Round, IsHermitean, IsUnitary

- Added the YacasNotebook directory with the emacs shell to the repository.
- We have support for BeOS! Thanks to Eugenia Loli.
- Serious bugfix: the ^ operator wasn't working like it should. It was mapped to BitXor, and its precedence was wrong.

- Allowed CForm to accept if (predicate) body; and if (predicate) body else other; These routines need to be written still, however, for them to also work in Yacas itself.
- cleaned up some code.
- Speedup of 40% of general Yacas execution.
- Some improvements to the logic theorem prover so it can handle (a>b)-type epressions.
- added support for annotating expressions, with GetExtraInfo and SetExtraInfo.
- Initial checkin into sourceforge CVS. Thanks to Vladimir Livshits!
- Fixed some windows compilation problems. ElfDll being explicitly mentioned in mathcommands3.cc, and explicitly including elfdll.h.
- added initial versions for the c-like &, | % and ^ operators, and if (...) ... else ... . This will probably make it possible in the future to write code that is a lot more readable than If(..., ..., ...). The else clause binds to the last if, just like in c. So this means you can now enter expressions like: if(3 < 3) a else if (3 > 3) b else c;

- made expressions like a[2][3] return unevaluated if a is not a matrix (just like a[1] in case a is not a vector).
- GnuPlot can now plot multiple functions (pass a list of functions on to GnuPlot to achieve this).
- For some reason PrettyForm didn't evaluate its argument any more. This has been changed back, so PrettyForm(%) works again.

- made some changes to make it compile on IRIX again. Thanks to Daniel Richard G.
- Added the Sign function.
- improved Solve, Sqrt in order for EigenVectors to work better.
- separate section: configuring yacas through .yacasrc: HistorySize, Help, PrettyPrinter,DefaultDirectory,
- Apart now works correctly on rational numbers
- verbose mode: V(expression) can now show internal results that might be useful to the user. Solve uses this.
- We can now run Yacas from within emacs! Thanks to Jay Belanger. See the file yacas.el for more information.

- added support for dealing with structs in the plugin system. Also, the stub generator now automatically generates documentation on the interface it is generating.
- started on opengl/glut plugin
- the Windows version now also supports plugins! Thanks go to James Gilbertson.
- started on forth interpreter plugin. This will allow on-the-fly compilation to forth code that can immediately be executed.
- Mod(2,0) gave the wrong error.
- ^c now cancels the current calculation (if calculating), or quits yacas if currently on the command line.
- enable automatically deleting CArrayGrower : CDeletingArrayGrower
- added tensors experimental to inprogress/, and moved norm there too
- BUGFIX: plugin support for integers didn't allow returning negative integers.
- install .so files in plugins/ dir, and be able to load from there.
- factoring polynomials has been fixed. Factor((x^2+1)*(x^2+4)) will now return a correct factorization.
- Implemented HistorySize(depth), which specifies the number of lines that should be stored in the ~/.yacas_history file.
- fixed partial fraction expansion! It turned out to be a bug in the function Monic, which didn't return the correct result if the lowest order term was non-constant. Monic(x^3+x^2), Apart(1/(x^2+1)), Integrate(x,a,b)1/(x^2) now thus work. This was found with Apart((x^3+4*x^2-x-2)/(x^4-x^2),x)
- better bracketing of expressions containing minus signs.
- changed #YB# and #YE# to <? and ?> for better cooperation with html.

- intro.html generated again.
- Precision(n) generates an error if n isn't a positive integer.
- A:=B:=1 now works as required (A and B get assigned 1)
- prefix operators can now be defined with a precedence. This is used with for instance "-". -x^2 is now treated as -(x^2) and not as (-x)^2
- The "Not" command is now treated as a prefix operator.
- The And, Not and Or operators now return unevaluated if they encounter an argument that is neither True nor False.
- Implemented a TraceStack, which shows the call stack just before the limit is reached. This has to be documented still!
- changed the operators in the logic prover from ~, |, etc. to And, Or and Not.
- new target in the make file in the src/ directory: 'depend'. make depend builds a file depend.dep using the -MM flag of gcc.
- changed the system so when you type '??' it calls Help(), and if you type ?f it calls Help(f). Help() and Help(f) are defined in yacasinit, and can be overridden in ~/.yacasrc
- Implemented TraceStack(expression), which shows the top of the stack, just before an error occurred.
- Improved error reporting: for internal functions the function generating the error is now also shown.
- implemented PatchLoad, which does a php-style load of a file. The contents of the file are read in and printed to screen, except everything between #YB# and #YE#, which gets evaluated. So print statements can be put there to put generic content.
- Implemented PatchString (which does the same as PatchLoad, but for strings).
- moved manicon.html to the distro.
- Initial release of a plugin interface.
- implemented DllLoad and SetHelpBrowser.
- documented PatchLoad, PatchString, SetHelpBrowser, TraceStack, and the plugin structure (preliminary), which can be found in the programmers reference.

- Speedup in manual generation.
- fix for enumerations in the manual
- Fix for compilation under egcs 2.95.2

- Greatly improved the coding.book. And some improvements in intro.book too. Note these are not finished versions yet! Just great improvements.
- Fixed the bug where sometimes the files in the addons/ directory weren't loaded.
- the history file now is ~/.yacas_history
- Yacas now tries to load ~/.yacasrc
- fixed small bug : cos*tan = sin
- new texform 0.4 with more functions and vector and matrix support.
- Initial version of yacas_client. It allows to run persistent Yacas sessions locally or via remote shell (rsh/ssh) from another program.
- New example in the introduction manual.
- Added an advanced example on how to create a non-commutative algebra.
- Added new flags: p for plain command line (no readline functionality), and c for not showing the prompts. So 'yacas -pc' will be a minimal console interaction application with no fancy in- and output. added flag -t for roll-through command line.
- Added EigenVectors and IsConstant (described in the manual).
- small changes to the reference manual: indices at the top, and some expanded descriptions for certain functions.
- Moved IsBoolean from texform to predicates
- implemented UnFlatten
- Initial version of c_form
- support for numbers of form 1E-3 etc. when using gmp. This will be supported in the built-in arbitrary precision math module soon.
- Read() from standard input now works again.
- Implemented TruncRadian(r) which calculates r mod 2*Pi, with arbitrary precision. This is then used in the trigonometric functions to speed up calculation. So, for instance, Sin(1000000) can be calculated quickly now, even without gmp.
- GarbageCollect(), which removes unused text strings from internal storage. garbage collection on lispstrings in the hashtable.
- Implemented LazyGlobal. This allows for lazy evaluation of a variable it is bound to (evaluation the first time it is called).
- % now re-evaluates the previous result.
- Usage of imaginary unit "I" will now invoke full "complex" package functionality.
- more strict requirements on parsing of numbers. They cannot be of the form 1.0.2 any more.
- Version() now returns a string.
- the symbol ' is now a text symbol, so you can write things like 'a' and x' .
- A small propositional logic theorem prover was built. it can be used by invoking CanProve

- Made improvements to the tensor package.
- started on the unixtools addons. Vi and GnuPlot.
- Implemented LessThan and GreaterThan that do a lexical compare instead of just comparing numbers. You can now compare any type of atomic.
- fixed c++ wrapper to gmp.
- Serge Winitzki fixed some bugs with complex arithmetic.
- Some more improvements to the introduction manual by Serge Winitzky.
- changed lexical analyzer so % is a separate token. You can now type a:=%; instead of having to type a:= %;
- Print Bodied with correct precedence.
- Implement "quit" (together with, "Exit()")
- Implement Version() to return 1.0.34

- Implemented ExpandBrackets
- Added a -f command line flag that inputs an expression from the command line, prints the result and exits.
- Serge Winitzki greatly enhanced the introduction manual!
- Some bugfixes to the complex arithmetic code.
- changed the [[ ]] way of accessing arrays into [ ].
- ?function didn't work on functions explained in the programmers reference.
- Changed the licence to GNU GPL.

- Made an ApplyPure that works with string operators.
- Implemented PrettyPrinter. So now you can have Yacas automatically print results in the desired form. Try it with PrettyPrinter("PrettyForm"). It can be reset with PrettyPrinter()
- Implemented Bodied("op",precedence), so now bodied operators can have a precedence too.
- An example reference "print" implementation in script code.
- Implemented Lcm(a,b) (Least common multiple) of two numbers.
- some small bug fixes
- Implemented Coef where the 'order' argument can be a list. This then returns a list of coefficients.
- BigOh: drops last terms from a polynom.
- ReversePoly: inverts a polynomial.
- replaced InverseTaylor with a better version.
- changed the '=' to '==' for Solve. This in order to assure the equals sign will not be automatically evaluated.
- Implemented Eliminate, SuchThat, WithValue
- Solve can now solve systems of 'simple' equations, eg. sets of equations where for each variable to solve for there is at least one equation where the variable occurs only once.
- Removed Lambda, in favour of the {{},} pure functions, since they are ten times faster. Juan: hope you don't mind? ;-)
- Some test code for Simplify, written by Serge Winitzki.

- The history now keeps track of the last unmodified line, so you can enter through a previous list of commands.
- Pressing escape twice now clears the line.
- Initial installment of a tensor package.
- Bugfix: sometimes 0/n returned a random number!
- Bugfix: relating to the above 0/n bug. MathDivide(0.00001,10) sometimes returned a random result. So did some of the other numeric calculations. The mistake was with converting the number from internal format to ascii (probably broken after it had been optimized). It was with a SetNrItems on a number that initially had less digits than the one I set it to. So the added items contained garbage.
- Greatly improved Simplify.
- the command line now accepts multiple lines that terminate with \.
- 3/2*2 is now interpreted as 3.
- typing restart on the command line restarts yacas.
- Changed all the (Is)InFix/PreFix/PostFix to (Is)Infix/Prefix/Postfix
- Started on scripts/examples/benchmark. This file contains some of the calculations specified in the Wester benchmark.
- Infinity wasn't handled every where (arithmetic)
- Implemented ContFrac, which makes a continued fraction expansion of a number.
- Implemented Decimal. Decimal calculates an infinite decimal representation of a number.
- Implemented LagrangeInterpolant, a way to create a polynomial that goes through certain points.
- Implemented Select, which can select certain elements from a list based on a predicate test function.
- Half-integer factorials (sent in by Serge Winitzki)
- TeXForm version 0.2 (initial release), sent in by Serge Winitzki.
- Improved the documentation.
- The web site was changed, thanks to Doreen Pinkus.
- Fixed the segfault following an error on the command line.
- Documented LagrangeInterpolant, PAdicExpand, LocalSymbols, PrettyForm, RandomIntegerVector, RandomPoly, Monic, LeadingCoef, Select, MakeVector, Decimal, ContFrac, Abs

- Added "Until" which repeats a statement until a predicate becomes true. The difference with While is that the statement is evaluated at least once, as opposed to While where the body statement is evaluated zero or more times.
- Univariate polynom building extended a little to deal properly with division by constants.
- implemented PAdicExpand PAdicExpandInternal that do a p-adic expansion, for integers and univariate polynomials.
- Added GetPrimeFactors.
- Implemented RandomIntegerVector, RandomPoly.
- LeadingCoef for univariate polynomials
- fixed bug in Gcd for polynomials.
- Allow {x,y}:={1,2}, which sets x to 1 and y to 2.
- You can now call f(x):=Eval(g), where g is evaluated before it is assigned to f(x). This makes it easy to define a function that is a taylor series of some other function, etc.
- Monic(poly): return poly/LeadingCoef(poly), which essentially makes the leading coefficient 1.
- Added Rem.
- Implemented an initial version of factoring polynoms! Factors(n) should factorize n, which can be an integer or polynom. It returns a list with sublists(factor,power). Use FW(Factors(n)) to show a nice human-readable form of the factorization. Try FW(Factors(1233)) as an example. Note that factoring polynomials can sometimes become slow, when fractions grow exponentially inbetween calculations.
- speedup of n!.
- Roots(polynom) calculates the roots of a polynomial.
- implemented EigenValues(matrix) .
- Apart, Together, GcdReduce
- integrating functions of the form 1/(a*x+b)
- integrating rational functions (very preliminary)
- integrating Sin(f(x))*Cos(g(x))-like forms
- integrating expressions of the form Ln(a*x)
- support for n_IsNumber < Infinity etc.
- fixed bug in pretty-printing formulas
- some more speedups.
- extended the documentation.
- some more optimizations. Queens(8) now takes 10 seconds just like Hugs. This just means Hugs isn't very efficient, since more optimizations are possible.
- Speed-up of applying pure functions.

- Dan McMahill made a NetBSD distribution for Yacas. It can be found at ftp://ftp.netbsd.org/pub/NetBSD/packages/pkgsrc/math/yacas/README.html
- changed the infix printer so that expressions like "a And b" and "a+ -b" are printed as such (with spaces).
- removed IsVector in favor of IsList, which is MUCH faster.
- optimized the code here and there. Queens(8) now takes 15 seconds, where it used to take 35 on my machine.
- Replaced "Table" with the implementation Juan Pablo Romero supplied.
- Added two command line options: -v and -d. -v returns the version number, and -d the directory the scripts are stored in.
- Added the $(scriptdir)addons/ directory as suggested by Juan Pablo Romero. If you copy your files over there, the .def files will automatically be loaded at startup. You will see the line 'Adding package[...]' on screen.
- fixed parsing bug for numbers ending with a dot (2.). Reported by Juan Romero.
- Added rules for <,> operations on rationals. You can now request 1<= 2/3 .
- fixed bug: l:={t,t^2,t^3}; D(t)l; the Deriv rule didn't do lists! Reported by Juan Romero.
- Subst has become an internal function (implemented in the engine).
- implemented LocalSymbols as suggested by Juan Romero. Try LocalSymbols(a,b)[a+b;]
- Implemented TemplateFunction and HoldArgNr, so that the parameters to a function are also local symbols. As an example, see the definition of Table in the file "lists". The LocalSymbols will thus be done during loading, and not during execution, so there is no runtime overhead in using TemplateFunction.
- Apply now evaluates both of its arguments. op:="+"; Apply(op,{2,3}); should now return 5; You can now remove all Apply("Apply",{oper,args}) constructs in your code, in favour of Apply(oper,args);
- Added "Lambda" as suggested by Juan Romero.

- added a directory colorcode with code to htmlize the scripts. it also color-highlights the code. Try it out by typing './colorcode' in that directory, and then 'netscape scriptsmain.html'
- Pattern matching code optimized a little.
- SylvesterMatrix, code supplied by James Gilbertson.
- MatrixRow, MatrixColumn, and GenMatrix supplied by James Gilbertson.
- changed Intersection and Difference, so they handle lists with multiple identical elements correctly.
- Fixed the D(x)x+y bug reported by Fred Bacon.
- Fixed the Gcd(x,x) bug reported by Scott.
- added Factorize({list}). Factorize(1 .. 4) should now return the same as 4! for instance.
- Added Content and PrimitivePart to the univariate polynomial code. See the manual for an explanation of these functions.

- Improved Windows client code (using the command line code). Code kindly contributed by James Gilbertson.
- KARATSUBA multiplication??? Again thanks to James Gilbertson. Seems to almost work ;-)
- Added Pi, which evaluates to itself, unless N() is used.
- Patterns defined with no arguments could crash, if there is a postpredicate. This was actually a problem with user-defined functions with no arguments. It is a miracle that Yacas worked at all.
- Added support for accurate results to Sin((1/2)*Pi) etc. Only whole and half Pi are supported currently.
- Added a new make target, 'make test', which runs the test script.
- Added an example, scripts/examples/findsum. See the file for more details.
- the command line now supports command line completion. When you type in a few letters, and press tab, yacas will try to auto-complete by searching the history.
- Added another example, queens, in the examples directory. This queens implementation took 35 seconds on my machine to do Queens(8), where hugs (a Haskell interpreter) takes 10 seconds.
- added the fltk-based user interface code back into the distribution. It still needs some serious work.

- You can now define simplification rules using pattern matching.
- small compilation problems with the newest gcc (Fixed by Fred Bacon).
- more numeric: Ln(2), Sin(2) and Sqrt(2) should only eval if N(...)

- added a small lisp interpreter to triage. triage is now ready to be used as a graphing engine.
- many improvements to speed up the engine. It should now be almost three times as fast. The most time is currently spent in the predicate clauses of the rules (deciding which rule applies).
- Length will now also return a length of a string and array.
- Implemented StringMid and SetStringMid, which can manipulate strings.
- Min and Max now also working on lists.
- Gcd now working on list.
- Gcd, Div and Mod will now try to find out if an expression is a polynomial.
- Implemented OpLeftPrecedence, OpRightPrecedence.
- PrettyForm, EvalFormula. These allow nice rendering of formulas in ascii form.
- IsFreeOf will now also accept a list of variables.
- Speed improvements.
- made readline.cpp platform-independent. It is now in commandline.cc and unixcommandline.cc
- enhanced simplification of rationals and complex numbers.

- added links to other relevant free software.
- implemented LispRead, which reads expressions in lisp syntax.
- implemented the Example() command, which generates a new example each time you call it. This solves the problem (I hope) of confronting a new user with a prompt and no indication as to what can be typed in. Just keep typing Example(), and all sorts of examples pop up.
- Implemented TraceRule. This allows you to selectively trace single functions. It shows what the arguments evaluate to, and then what the function evaluates to. Try it out with TraceRule(x+y)2+3*5+4
- TrigSimp has now been changed to TrigSimpCombine, and is now part of the regular distribution. Also, there was still a small bug in TrigSimp.
- Added a section on debugging in the manual.

- implemented TraceExp.
- improved substitution rules for simple arithmetic.
- IsFreeOf can now handle extended expressions: IsFreeOf(Cos(a),Cos(a)) will now return False.
- A new module: "inprogress/trigsimp". This file defines a function TrigSimp that changes Cos(...)*Sin(...) expressions into Cos(...)+Sin(...)

- changed the format for argument passing to Taylor and inversetaylor. It is now "Taylor(var,at,degree) function" and "InverseTaylor(var,degree) function"
- Subst implemented. Subst(x,y)x+x should return y+y.
- Introduced the concept of a 'generic object'. Next to atoms and lists, there can now be objects Yacas can deal with.
- implemented the first generic object: an array class. This greatly speeds up random access to large lists (if treated as an array). Array acces is O(1) whereas list access is O(n).
- updated the documentation to reflect the most recent additions: Assoc, AssocIndices, Drop, Take, Partition, LeftPrecedence, RightPrecedence, ToString, Secure, FindFile, Subst, IsGeneric, GenericTypeName, ArrayCreate, ArraySize, ArrayGet, ArraySet, ArrayCreateFromList, ListFromArray

- enabled logging through a dedicated singlethreaded server. see launchserver for details.
- Added makefile code to autogenerate the manual. Code supplied by Juan Pablo Romero. So 'make install' will now also build the online manuals.
- Added a very preliminary interface to MySQL. This is done by invoking the default mysql client, passing in a file for stdin, and then reading the result and casting it into a list that Yacas can read. tools/mysqlstubs does this. You don't have to have mysql installed to build Yacas, which is a nice thing.
- FindFile, which scans the default directories for a file.
- made a tools directory, /usr/local/share/yacas/tools. Yacas can launch executables from there using SystemCall and FindFile. This directory should contain some loose exes to connect to other programs. For now the http servers and the mysql stubs are there. In the future such things as a stubs for superficie and for gnuplot should also be there.
- The documentation is now built when you type 'make', instead of when 'make install' is invoked.

- Removed warnings during compilation
- Server returns a slightly better page on error.
- Implemented a maximum time the server will take for a calculation (default 30 secs)
- Implemented a configuration file scheme for the server.
- fixed printing bug, where a-(b-c) was printed as a-b-c.
- Implemented a 'Secure' keyword. This disallows reading from and writing to files, as well as system calls, from Yacas. Useful when used within the server.
- Added "Examples" button functionality to the forms.

- Improved error reporting due to James Gilbertson.
- a Windows executable is now on the net, winyacas.zip, due to James Gilbertson.
- ?keyword will now give you help on that keyword. Try it with '?Apply' or so.
- Slight improvements to the server code.

- Improved windows version.

- Improved server code
- implemented a simple database
- improved error reporting. Errors now show the file and line the error occurred.

- removed the const from LispString (some compilers fell over it)
- improved the server to also serve html pages, and allow for password authentication.
- Fixed online manual building. You can now type './mkmanual', and then when in yacas, type '??', and help should pop up again.

- The : operator now also accepts strings. "a" : "b" should now return "ab"
- The manual is now completely generated using Yacas as a document processing language, much like LaTeX.

- Drop, Take, Partition incorporated in the distribution (as supplied by Juan Pablo Romero).
- Assoc lists are now implemented.
- Fixes to make yacas work on a Dec Alpha.
- improvements to the autoconf/automake scripts

- %d numbering in server input/output
- DestructiveReplace, Replace
- change CanBeUni to support f(x)/const constructions. Expand(Taylor(Sin(a*x),x,0,3)) will now work correctly.
- Expand a little on integration.
- Integrate standard analytic functions like Sin, Cos, Exp.
- partial integration: first step could be integrating polynomial*function.

- Make a LispString derived class that can use a const string, copied, and thus not freed.
- files IN the executable.
- allow loading from exe.
- a mechanism to put scripts in the executable (preliminary).

- moved to autoconf/automake scripts.
- many many many changes to clean up the source distribution, thanks to Daniel Richard G.

- Changes to allow compilation under Sun/SGI.
- Improved the www server. Check cgiserver02.
- added FromString command.
- slight change to license. It should now at least be compatible with GPL licenses.

- There is now a mini www server in the server/ directory! Read the readme file for its usage.

- Added code to support Windows, supplied by James Gilbertson
- Added fix to support GMP again. Supplied by Igor Khavkine.
- Added Sum({list}) and Average({list}). Examples: Sum({1,2,3}) evaluates to 6, and Average({1,2,3}) evaluates to 2.

- Fixed bug in BubbleSort
- Added 'Diverge', 'Curl' and 'FillList', and threaded derivatives as supplied by Igor Khavkine. Example: D({x,y,z})Sin(x*y).

- IsInFix, IsPreFix, IsPostFix, OpPrecedence, GetPrecision
- BitAnd, BitOr, BitXor
- functional operators :, .., @, /@
- Find, Simplify, Conjugate, Rationalize

- additional debug code: count number of defined functions: built-ins, RuleBases.
- binarysearch in some places, instead of linear search.
- split mathenvironment into that plus commands.cpp/h
- Add support for access to some engine information:
- GetPrecision()
- IsInFix, IsPreFix, IsPostFix, OpPrecedence.

- BitAnd, BitOr, BitXor

- Added the functional operators, .., :, @ and /@, to the standard loaded functions.
- implemented list[[{index}]]. So now you can do list[[2 .. 4]], which will return a list with the elements 2, 3 and 4 of the original list.
- Change syntax for Limit: Limit(var,value) function

- Access to help from the console version, by typing ??. This uses lynx.
- Experimented a little with a calculator approach. See fltkcalc for the results.
- Home page redesigned.

The language specification has been finalized, so future releases should be backward-compatible.

This distribution contains a small library with mathematical algorithms.