Release of version 1.0.53 (July 14th, 2002)

• 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)

Release of version 1.0.52 (May 23rd, 2002)

• 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)

Release of version 1.0.51 (April 20th, 2002)

• 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)

Release of version 1.0.50 (March 12th, 2002)

• 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)

Release of version 1.0.49 (February 23rd, 2002)

• 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.

Release of version 1.0.48 (Dec 2001)

• 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

Release of version 1.0.47 (May 20th 2001)

• 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/

Release of version 1.0.46 (April 10th 2001)

• 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) in stead of f(2+3).

Release of version 1.0.45 (Februari 22nd 2001)

• 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/

Release of version 1.0.44 (December 30th 2000)

• 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

Release of version 1.0.43 (November 18th 2000)

• 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.

Release of version 1.0.42 (November 12th 2000)

• 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;

Release of version 1.0.41 (September 8th 2000)

• 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.

Release of version 1.0.40 (August 21st 2000)

• 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.

Release of version 1.0.39 (august 10th 2000)

• 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.

Release of version 1.0.38 (July 9th 2000)

• 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.

Release of version 1.0.37 (June 4th 2000)

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

Release of version 1.0.36 (June 4th 2000)

• 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

Release of version 1.0.35 (May 16 2000)

• Made improvements to the tensor package.
• started on the unixtools addons. Vi and GnuPlot.
• Implemented LessThan and GreaterThan that do a lexical compare in stead 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:=%; in stead of having to type a:= %;
• Print Bodied with correct precedence.
• Implement "quit" (together with, "Exit()")
• Implement Version() to return 1.0.34

Release of version 1.0.34 (May 4 2000)

• 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.

Release of version 1.0.33 (April 30 2000)

• 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.

Release of version 1.0.32 (April 25 2000)

• 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

Release of version 1.0.31 (April 9th 2000)

• 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.

Release of version 1.0.30 (March 5 2000)

• 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.

Release of version 1.0.29 (27 Februari 2000)

• 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.

Release of version 1.0.28 (10 Februari 2000)

• 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.

Release of version 1.0.27 (16 Januari 2000)

• 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(...)

Release of version 1.0.26 (12 Januari 2000)

• 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.

Release of version 1.0.25 (26 December 1999)

• 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.

Release of version 1.0.24 (25 December 1999)

• 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(...)

Release of version 1.0.23 (19 December 1999)

• 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

Release of version 1.0.22 (13 December 1999)

• 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', in stead of when 'make install' is invoked.

Release of version 1.0.21 (11 December 1999)

• 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.

Release of version 1.0.20 (5 December 1999)

• 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.

Release of version 1.0.19 (29 November 1999)

• Improved windows version.

Release of version 1.0.18 (28 November 1999)

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

Release of version 1.0.17 (27 November 1999)

• 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.

Release of version 1.0.16 (22 November 1999)

• 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.

Release of version 1.0.15 (20 November 1999)

• 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

Release of version 1.0.14 (12 November 1999)

• %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).

Release of version 1.0.13 (12 November 1999)

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

Release of version 1.0.12rev1 (11 November 1999)

• 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.

Release of version 1.0.12 (7 November 1999)

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

Release of version 1.0.11

• 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.

Release of version 1.0.10

• 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).

Release of version 1.0.9

DOCUMENTATION

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

ENGINE

• additional debug code: count number of defined functions: built-ins, RuleBases.
• binarysearch in some places, in stead 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

MATH

• 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

Release of version 1.0.8

• 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.

Release of version 1.0.7

Release of version 1.0.6

Release of version 1.0.5

Release of version 1.0.4

Release of version 1.0.3

Release of version 1.0.2

Release of version 1.0.1

Release of version 1.0 (initial release).

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