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.