Changes made, most recent ones first:

-----------------------------------------------------------------------------

New in 0.9.2:

Changed the behavior of 'hilbertSeries', 'hilbertPolynomial', 'poincare',
'euler', and 'genera' when applied to an ideal, so that the result returned
is that for the corresponding quotient ring.

-----------------------------------------------------------------------------

New in 0.9.1:

Updated versions of files from Amelia Taylor : normal.m2 and minPres.m2, for
computing integral closures.

Linking with gmp version 4.0.

-----------------------------------------------------------------------------

New in 0.9:

Compile-time option --enable-shared removed.

The function currentDirectory() now returns a directory path with an
extra / at the end.

The function 'factor' now returns factors of polynomials in the same order
every time.  As a result 'decompose' will be more deterministic, too.  This
was accomplished simply by setting the random number seed used by
Singular-Factory to a constant every time.

The function 'unique' has been rewritten to be more deterministic and a bit
slower: the list returned has elements in the order as first encountered in
the list submitted.

New function 'truncateOutput' can be used truncate output lines that are too
long.  This is useful if long lines get displayed too slowly, such as in
emacs, sigh.

New function 'setRandomSeed' can be used to set the seed (starting point) for
the random number generator from an integer or a string.

Added new html items TOC and SECTION to enable a web page to be divided into
sections, together with a menu that provides internal links to each of them.

Changed the HTML items H1, H2, H3, H4, H5, H6, to HEADER1, HEADER2, ...  That
frees up some short names for users!

The four libraries (gc, singular-factory, singular-libfac, and gmp) are
no longer included.  Instructions are given in the top-level README for
downloading them and compiling them.

Macaulay 2 is now licensed under the terms of the GNU General Public
License.

routines for computing global Ext of coherent sheaves donated by Greg Smith
installed: 
	Ext^ZZ(CoherentSheaf,SumOfTwists)
	Ext^ZZ(SheafOfRings,SumOfTwists)
	Ext^ZZ(SheafOfRings,CoherentSheaf)
	Ext^ZZ(CoherentSheaf,SheafOfRings)
	Ext^ZZ(SheafOfRings,SheafOfRings)

LLL in package LLL.m2 now returns a matrix, rather than a "sparse matrix".

The documentation in the file gbdoc.m2 was being omitted when assembling the
documentation.  That's been fixed.

Changed code for 'dim M' where M is a module so that the dimension of
the zero module is -1 instead of -infinity : this might affect only the
developers, as a new routine for 'codim M' was installed Oct 2, 2000.

Made 'char R' work when R is a fraction field.

Horizontal join of two nets now does a better job than before of producing
empty lines -- formerly it produced many blank lines of width equal to the
width of the left-hand net.  As a consequence, there will be more output
lines that are completely empty, without superfluous spaces.

-----------------------------------------------------------------------------

New in 0.8.99:

'currentFile' changed to 'currentFileName'

WARNING: The functions 'separate' and 'lines' which separate strings into
pieces, now take the two arguments in the reverse order.

WARNING: The degrees rings (used for return values from 'hilbertSeries' and
'poincare') now have a new monomial order : RevLex.  This way, polynomials
are displayed with the powers of t in increasing order, which is the usual
way for a Hilbert series to be displayed.  Similarly, in a RevLex polynomial
ring with inverses and nonzero degrees length, division and remainder now
works, at least on polynomials involving just one of the variables.  The
division algorithm is one that makes k[t,t^-1] a Euclidean domain.

'monomialCurve' has been renamed to 'monomialCurveIdeal'

Oops, found a long standing bug : when a quotient module M/N was constructed,
where M and N are both quotient modules of the same free module F, the
quotient returned was F, rather than F/F.  Fixed.

WARNING: Syntax for computing sheaf cohomology has been changed.  Now HH^i(F)
gives the single vector space, as expected.  To get the graded module
whose n-th component is HH^i(F(n)) write HH^i(F(*)).  You will get an error
message if that module is not finitely generated.  To ask for the graded
submodule where just those components with n>=d are required, write
HH^i(F(>=d)).  For n>d, write HH^i(F(>d)).  Warning: as before, you may get
more components than you asked for; you could use 'truncate' to get the exact
answer.

more methods are working for coherent sheaves and varieties: dual, ^**, etc.

new operator L^**n for tensor powers

Fixed two bugs in computing global sections of a coherent sheaf: -- it was
ignoring the degree option, and in some cases, it would give a missing method
error message.

Fixed a bug which prevented 'matrix' from accepting a list of vectors 
from a subquotient module.

Added a method 'prune F' that prunes a coherent sheaf by computing the graded
module which in degree n is the global sections H^0(F(n)).

'sheaf(M,X)' where M is a module and X is a variety, has been replaced by
'sheaf(X,M)'

'input' now will stop reading the file after an error occurs.

The parsing precedence of the postfix operator ~ (as in F~) is now much
higher.  There is a new postfix operator (*) available.

'Ext(M,N)' now caches the result for future reference

'betti f', where 'f' is a matrix of nonzero degree, is now interpreted
slightly differently.  Formerly, the degres of the source of f were
adjusted so that f would have degree 0.  Now the degree of f is simply
ignored.  This brings it into conformance with the behavior of 'betti C'
where C is a chain complex whose differentials, although usually of 
degree 0, may have nonzero degrees, which are nevertheless ignored.

I _ {i,j,k,...}, where I is an ideal, is now interpreted as
(module I) _ {i,j,k,...}.  Recall that M_{i,j,k,...}, where M is a module,
gives the map to M from a free module determined by the generators with
indices i,j,k...

'degrees M', where M is a nonfree module, now gives the degrees of
the generators, not the degrees of the basis elements of the ambient
free module.  And 'degrees I' where I is an ideal, now gives the degrees
of the generators (this is a new method).

When creating a ring map with 'map' you may now specify a function for
transforming the degrees of basis elements of free modules with the DegreeMap
option.  The default function is the identity function, but when the two
rings have different degree lengths, a function must be provided that
transforms the lengths of the degree vectors appropriately, or else the
default function which maps every degree to {0,...,0} will be provided.

If f is a ring map f : R --> S and M is an M-module, then we've restricted
the use of 'f M' to the case where M is explicitly a submodule of a free
module R^n, and it returns the corresponding submodule of S^n.  In the
case where M is a quotient module or a subquotient module, what one usually
wants is the tensor product, and now you may write 'f ** M' to obtain that.

Division and remainder (/ and %) in polynomial rings with one variable where
the variable has an inverse (such as R = QQ[t,Inverses=>true]) have been
repaired so they work as they ought to in this Euclidean domain.  Similarly
for R = ZZ[t,Inverses=>true] when the denominator is monic.

The 'transpose' or  'dual' of a chain complex C now inserts the right sign 
in the differential maps.  Same for Hom(C,M).  Same for 'Hom(f,M)' and 
'dual f' where f : C --> D is a map of chain complexes.

The operation of 'path' with 'load' has changed slightly -- no matter what
the path is, we first look in the directory containing the file in which the
call to 'load' is.  The makes it easy to load a set of related files stored
in a directory - the first one can load the others without knowing the name
of the directory, and without the directory being on the path.

'path' changed (!) -- we now try to load a file by simply concatenating
each member of 'path' with the requested file name.  That means you may
have to end each directory name on the path with your directory separator
character (which is '/' under unix).  If you want compatibility between
old and new versions of M2, just add both strings to your path, one with
and one without the separator.

new function 'isConstant' for telling whether a polynomial is constant

'factor' for polynomials changed so the last constant factor is now only given
if it is not equal to 1.

Assignment can now be done in parallel with a statement like
	(a,b,c) = (4,5,6)
If the right hand side has too few elements, then the trailing symbols
on the left side are given the value 'null'.
If the right hand side has too many elements, then the last symbol on
the left hand side is given as value a sequence containing the
trailing elements of the right hand side.
If the right hand side is not a sequence, then 'a' gets the value, and
'b' and 'c' get null.

'decompose' now works over polynomial rings over QQ, but not very well.

'decompose' now works over quotient rings.  A bug which caused it to
crash when given the zero ideal has been fixed.  A bug which caused it
to give the empty list when given an ideal with a zero generator has been
fixed.

'stats' has been renamed to 'summary'

an important memory leak was found and repaired -- rings and monoids were
never getting freed!  This should make a vast improvement for those who
create many rings.

'heap' has been renamed to 'engineHeap'

g[a,b,c] is a new synonym for substitute(r,matrix {toList v})

'sub' is a new abbreviation for 'substitute'.

x_R will produce the element of R named x, if x is a symbol, or an indexed
variable, or even a generator of some other ring.

'presentation' of a quotient ring will now give the original generators of
the ideal, rather than the generators of a Groebner basis of the ideal.

'gcd' will now accept more than two arguments.

The total Ext function H = Ext(M,N) formerly stored its adjustment function
(for adjusting the bidegrees to make the first component positive) in 
H.adjust.  This has been superceded by a general method for creating
rings together with adjustment functions.  The new method involves
creating a polynomial ring with the options Adjust and Repair, whose values
are the adjustment function and its inverse, respectively.  All functions
that pass degrees between the user and the engine now take this into account.

The procedure for compiling is different now, as we use "configure".
Try "make".  We don't yet have a "make install" target.

Warning: things of class Matrix and Ideal are now immutable.  If you want
to cache information about a matrix or ideal I, you may use the new cache
table I.cache.  That cache table is of type "CacheTable", a new type
of mutable hash table.  Cache tables always have hash code 0, and equality
of two cache tables is determined by comparing only the parents and the classes,
not the contents (key-value pairs).

The multi-degrees used in total Ext modules computed by "Ext" are slightly
different now - the homological degree is now the first component instead of
the second.

polynomials now behave as expected with respect to hashing and strict
equality (===), so they can be used as keys in hash tables, and work
with "set", "tally", and "unique".

f_d now gives the part of the polynomial f of total degree d.  And
  f_{a,b,c} gives the part of multi-degree {a,b,c}.
WARNING: f_1 no longer gives the constant term of a polynomial;
  use f_0 instead.

a bug with printing GF(9)[x] has been fixed.

finite prime fields k now have their order stored in k.order as well as
in k.char, for compatibility with Galois fields.

fixed Control-D under unix so the end functions get run.

changed 'exit' so the end functions get run only if the return code is zero.

changed 'tmpname' to 'temporaryFileName', and changed what it does, slightly.

changed 'TeX' command to 'showTex', for ease of typing

New keyword 'break' which for ceasing execution of a loop.

New keyword 'return' for return a value from a function at any point
within its body.

The function 'flip' was returning an incorrect matrix, the transpose of
the correct one.  This has been fixed.

new function 'toField' can be used to declare that a ring is a field, after
which polynomial rings over it will support groebner basis computattions.
See also 'getNonUnit' and 'getZeroDivisor'.

removed the class 'Field', since many rings are not recognized as fields at
the time they are created.  Now we'll use a flag stored under the key isField
to remember whether a ring is a field.

removed product rings R*S.

new keyword 'return' -- use it for returning from functions

new keywords 'for', 'when' and 'to', and a new control structure:
	for i from a to b when c list x do y
This repeatedly evaluates x and y, letting i run over a..b, as long as
c remains true, accumulating the values of x into a list to return.

new keyword 'list' and new control structure:
	while p list x
which evaluates x repeatedly as long as p remains true, returning a list of the
values of x encountered, and
	while p list x do z
which evaluates x and z repeatedly as long as p remains true, returning a list of 
the values of x encountered

documentation items:
	HEADLINE is changed to Headline
	USAGE is changed to Usage
	Synopsis is introduced

Fixed a design bug in computing GB's,syzygies,kernels: if the target free
module was a Schreyer order free module (as is returned by
res(...,Strategy=>2)), then the Groebner basis was incorrectly computed
sometimes, if the ring was an exterior algebra or a quotient polynomial ring.

Substitution in skew commutative algebras now works correctly.

'tex' is being upgraded to output code compatible with Latex 2e with the package
amsmath loaded.  (It used to produce plain tex.)

HEADLINE usage has changed from 'HEADLINE x' to 'HEADLINE => x' in documenation.

Source files for Macaulay 2 code are now interpreted as text files, in the
sense that RETURN-NEWLINE and RETURN character sequences are automatically
converted to NEWLINE.  Thus, the behavior of your program should not depend
on whether the newline characters have been replaced by the analogues used
under MSDOS or MACOS.

The parser now checks for instances where a function and its arguments are on
separate lines, and prints out a message, "missing semicolon before this token?".
It does the same any time the "adjacency" operator is applied to a pair of tokens on
separate lines.

The 'M2' script has been changed so that if the dumpdata file isn't there,
the system will start up by reading setup.m2.  On my machine, reading the
source code in setup.m2 takes 1.9 seconds, and starting up with loaddata/dumpdata
takes 0.3 seconds.  Machines are a lot faster now!

-----------------------------------------------------------------------------
New in 0.8.58:

The elements in a Groebner basis are now sorted so that Groebner bases
are unique.  But since they are sorted, the order of elements may be 
different from what you were getting before!

'Algorithm' changed to 'Strategy'

'gcdDegree' and 'lcmDegree' removed

'submodule' removed

-----------------------------------------------------------------------------
New in 0.8.56:

singularLocus has been changed so that the ring returned is a quotient ring
  of the ambient ring, instead of a quotient ring of the quotient ring given
  to it.
-----------------------------------------------------------------------------
New in 0.8.56:

Operation of html item 'SHIELD' changed - it now is used to protect a whole
MENU rather than its items.
-----------------------------------------------------------------------------
New in 0.8.55:

Fixed a memory management bug in Groebner basis computations that caused memory
usage to grow without bound.

Fixed a bug in front-end rational number arithmetic where denominator could
be zero after dividing an integer by a rational number.

New function 'override' designed for internal use in collecting optional 
arguments for funtions that use them.

New built-in operator '##' for uncurrying functions.  f##(a,b) becomes ((f a) b),
and so on.

In 'new A' we are now enforcing the rule that A should be a Type.
In 'new A of B' we are now also enforcing the rule that A should be
a Type of Type.

'stack' and 'horizontalJoin' will now silently accept 'null' an argument

'locate' now will return 'null' instead of giving an error for a compiled function
or symbol

New class VisibleList.  List, Sequence, and Array are now types of VisibleList.
Functions fold, accumulate, and methods List / Function, Function \ List, are
extended to work with VisibleLists.

New function HEADLINE -- use this as the first entry in documentation to
give a capsule summary (1/2 line long).

new function 'sameFunctionBody', tells whether two functions are perhaps different
closures of the same function body.

'OptionsRegistry' removed, and 'options' now returns 'null' instead of an empty
OptionTable if function has no options.

'options' applied to a symbol now does nothing.  Use 'help' to see what functions 
a symbol is an option for.

'browse' has been changed so it also displays the values local variables had
when a function was created.  This can be a useful debugging tool.  Unfortunately,
the names of the local variables are not available, but the values appear in
the same sequence as the declarations of the variables.

'processArgs' has been removed, and a new operator '==>' added to replace
using 'o @ f' where o is an OptionTable or List and f is a Function for
processing optional arguments to functions.  Its parsing precendence is as
low as the other arrows and assignment statements, and available for use by
the user (but methods have to be installed with 'installMethod').  Previous
uses of '@' have to be changed.

'document' has been reworked:
	You should use
		document { symbol X, ... }
	only if you want to document the symbol X and its use, rather than
	its value.  If the value of X knows its name, just use
		document { X, ... }
	Otherwise, use
		document { "X", ... }

'help' now returns the documentation as a Net instead of printing it out.

'doc' changed to 'documentation'

New function: 'briefDocumentation'.  This is the function that prints one line
of documentation after something appears as output on the screen.

'RETURNS' has been replaced as a method for documenting the type of thing
returned by a function.  See 'typicalValues'.

'quote' has been renamed 'symbol', and things stored under the key 'symbol'
before are now stored under 'Symbol'.  Warning: if you have written a function
that uses a variable called 'symbol', this function will now give an unusual
syntax error.

'ScriptedFunction' has been merged into 'ScriptedFunctor'.

Changed the operator '=>' so methods for it cannot be installed by the user.

Fixed a bug in 'stack' which incorrectly converted lines with tab characters in
them, inserting too many spaces and truncating the rest of the line, affecting
other functions such as 'code'.

The parsing precedence of => is now a bit lower: lower than 'of' and 'from', and
the same as other assignments and arrows (:= = <- ->).

The message issued when a file is loaded is not sent to 'stderr' insted of 'stdout'.

x==y will now return the result of strict equality testing with x===y if no
method is installed for mathematical equality.

'describe' now returns an Expression, to which one may apply 'net' if a 2-dimensional
display is desired, or 'toString' if a 1-dimensional display is desired.
-----------------------------------------------------------------------------
New in 0.8.54:

Fixed a bug where openDatabaseOut would fail the second time it was used
on a database file.

New function : 'connectionCount', returns the number of connections accepted
so far by a listener

Fixed a bug in opening output pipes.  This affected online display of documentation
in a terminal window.

'string' and 'name' phased out in favor of 'toString' and 'toExternalString',
both of which accomodate methods better.

'getDocumentationTag' removed, replaced by 'toString'

-----------------------------------------------------------------------------
New in 0.8.53:

Comparison of monomials using '>' in rings with nonstandard monomial orderings 
now works.

Various bugs have been fixed and improvements made in the Weyl Algebra code.
This work continues.

-----------------------------------------------------------------------------

New in 0.8.51:

'#f' can now be used to give the length of a file.

'basis' modified so it returns a matrix whose source and target are *both*
over the same ring.  As a consequence, more correct information about degrees
is available from 'pushforward'

New in 0.8.50:

'engineStack' now returns a net which you can print, rather than printing it
for you.

New in 0.8.49:

Fixed another bug in 'betti'.

'subquotient', 'coker', and 'image' now recast the matrices which provide the
generators and relations so they have degree 0, if the result is a
homogeneous matrix.

New in 0.8.48:

Fixed a bug in 'betti' which caused it to crash for certain resolutions
with negative degrees

New in 0.8.47:

A bug in the engine which prevented certain data associated with computation
of resolutions from begin freed has been fixed.  One memory leak might still
remain.

'wait' will now take a list of files and wait for one of them to have
input ready.  (At least this works under unix, with the 'select' system
call.)

New commands 'echoOn' and 'echoOff' to set echoing on or off for a file.
On the command line, with no arguments, the standard file 'stdio' is assumed
as the argument.

prompts for input now go to the output side of the input file, if the file is
an input output file, otherwise to stdout

some file names changed, to avoid gratuitous use of filename extensions:
	cache/Macaulay2.doc --> cache/Macaulay2-doc
	cache/Macaulay2-XXXX.data --> cache/Macaulay2-XXXX-data

'openFiles()' now returns a list of all the open files, even the files open
only for input.

'code' now returns a net containing the source code, rather than printing it
out.

All types of internet connection service are now possible.  See 'openInOut' and
'openListener'.

'stdin' and 'stdout' replaced by 'stdio'

'verticalJoin' changed to 'stack'.

The documentation has been improved, especially the section on language and
programming overview.

'Unquote' removed.

Warning: the way 'apply' works for hash tables (including Sets and Tallys) 
has been changed.

Warning: 'applyKeys' has been changed so that if the function being applied
returns 'null', then it gets used as a key.  Use 'applyPairs' instead if you
were depending on this behavior.

Warning: the way 'accumulate' works has been changed.  It no longer includes
the initial value in the list, and there are some new versions of it.
And 'fold' has been changed.  It now operates the reverse way!

Code such as 'ascii 65' now works, and gives "A".

  A basic change has been made to the way 'processArgs' and functions and
methods with optional arguments are written (cf. options, Options). Formerly the
function was written with a parameter list (args,opts) where args was always
a sequence containing the non-optional arguments, and opts was a hash table
containing the values of the optional arguments, indexed by name.  Now, the
function will have the form (opts -> args -> (...)).  This will allow the
user to code the function body in various other way, too, e.g., (opts -> (x)
-> (...)) or (opts -> (x,y) -> (...)), to allow quicker process of the
sequence of arguments.  Another change is that now 'args' will be the single
argument when there is just one, rather than a sequence of length one
containing it.
  There is also a new use of the operator @ which allows optional argument values
to be attached to functions.  This makes it unnecessary for the user to use
processArgs.

The method for applying a symbol to a thing has been removed.

function 'seq' changed to 'singleton'

'tex' works for nets now

new function 'isUnit'

new global flag compactMatrixForm which governs whether matrices are displayed
in compact Macaulay form or in 2-d Macaulay2 form.

String is now a subclass of Net - we intend every method applicable to nets
to also work for strings, even though the internal representation of strings
is different.
-----------------------------------------------------------------------------
New in 0.8.46:

clearAll now also clears all the user's variables.  The old behavior is
provided by clearOutput.

Matrices whose source ring and target ring are different can now be used in
tensor products.  Such matrices are produced by 'basis'.

'peek' no longer takes a second argument.  Use 'peek2' instead.

'betti' now returns a Net as its value, and does not print it
by default.  In a program, you may print it a line like
	<< betti C << endl;
The reason for this change is to make it easier to send the output
from 'betti' to a file, or to incorporate it into a larger display.

'evaluate' and 'expand' have been eliminated in favor of 'value', into
which all three functions have been merged.

generatorsExpressions - a new key in monoids and polynomial rings used to
	hold expressions for the generators used in printing the generators

Unquote - new type of expression.

Caching of tensor products done now.  Caching of direct sums was installed in
an earlier version.
-----------------------------------------------------------------------------
New in 0.8.45:

the default changeMatrix for forceGB is now the identity.
-----------------------------------------------------------------------------
New in 0.8.44:

Fixed a bug noticed by Irena Swanson: when a polynomial ring is created
with ordering Elimination 1, and the first variable x has degree d larger
than 1, then x^d appeared in place of x as the first generator of the ring.
-----------------------------------------------------------------------------
New in 0.8.43:

'prune' now works for chain complexes

speed improvements for tensor products of chain complexes

kernel, cokernel, image, coimage, now work for maps of chain complexes

wedgeProduct now works for non-free modules

C_[i] and C^[i] now work for chain complexes possibly with indices, to give
	projection and inclusion maps for summands

map(ChainComplex,ChainComplex)    	   map(C,D)
map(ChainComplex,ChainComplex,Function)    map(C,D,f)
	These are new ways to construct a map between chain complexes.  The function
	f is used to provide the component maps.

directSum for chain complexes implemented

'tensorAssociativity' map for modules and chain complexes

map(M,N,1) if cover M == cover N will now give the map induced by sending the i-th
	generator of N to the i-th generator of M
-----------------------------------------------------------------------------
New in 0.8.42:

The variable 'hypertex' has been removed.

'Held' renamed to 'Holder'

'net String' now does not put quotes around the string, and
'net Net' does not put a box around the net.  This changes
the appearance of displayed objects containing strings, but you
can still use 'peek' to see the quotes around the strings.

'HeldString' removed in favor of 'Held'

type 'HtmlList' renamed to 'MarkUpList'

type 'ListHead' renamed to 'MarkUpType'

SEEALSO now takes a list of items instead of a sequence of items

graphIdeal now returns an ideal instead of a matrix

Formerly once could specify that a hash table assigned to the variable X 
should print as "X" by executing
	X.name = quote X
The new way is to use
	X.name = "X"
The symbol X can also be stored, as before, with
	X.symbol = quote X

A symbol x with a value will now print as "quote x" rather than as "x".
But a symbol x "held" inside an Expression will continue to print as "x".

'syms' has been changed to 'generatorSymbols'

-----------------------------------------------------------------------------
New in 0.8.41:

Fixed a serious bug.  When computing syzygies of a matrix after the Poincare
polynomial of its cokernel had already been computed (this is done
automatically by 'degree'), the computation could stop prematurely.  This can
cause incorrect results.

Fixed a problem in 'kernel' of a ring map which attached incorrect degrees
to the generators.  The change was to 'ideal Matrix' so that now it always
ignores the degrees attached to the incoming matrix.

new function 'inducedMap'

functoriality for Hom and Ext

'fromPrune' gone, but see 'pruningMap'

-----------------------------------------------------------------------------
New in 0.8.40:

Minimal, an option to gb for internal use only, has been changed to 
StopWithMinimalGenerators.

GeneratorLimit has been changed to BasisElementLimit

Bug fixed in code for projective resolutions of inohomogeneous modules.  This
includes modules over inhomgeneous rings.  Previous results may have been
wrong, so should be rerun.  We don't actually have any examples of wrong
results, though - the old code seems to go into an infinite loop instead.

-----------------------------------------------------------------------------
New in 0.8.39:

There is a new convention about automatic assignment of generators of rings
to global variables.  The old convention was that this happened automatically
when the polynomial ring was created.  The new convention is that it happens
when the ring is itself assigned to a global variable.

Groebner bases now print out the matrix of generators when displayed,
whereas before, they 

new type : AbstractSet

-----------------------------------------------------------------------------
New in 0.8.38:

A bug in the arithmetic of skew-commutative rings has been fixed.

-----------------------------------------------------------------------------
New in 0.8.37:

new routine 'terms' for getting a list of terms of a polynomial
WeylAlgebra
'unlist' changed to 'toSequence'
'elements' changed to 'toList'

-----------------------------------------------------------------------------
New in 0.8.36:

In emacs, you may use now M-f10 to move back to the previous expression
bracketed with <<< >>>.

-----------------------------------------------------------------------------
New in 0.8.32:

bug fixed in 'select(ZZ,HashTable,Function)' - it didn't stop after the
specified number of entries were selected

new type : GradedModule, with ++, **, etc, for them

new notation:
	f^{2,3,4} : rows 2,3,4 of a matrix f
	M^{2,3,4} : projection of a free module M onto free module
		spanned by basis vectors 2,3,4
    direct sums:
	M=V++W : M.components saves the list of summands
	M_[0] : inclusion V --> M
	M_[1] : inclusion W --> M
	M^[0] : projection M --> V
	M^[1] : projection M --> W
	M = directSum(V,W,X)
	M_[0,2] :  inclusion V++X --> M
	M^[0,2] : projection V++X --> M
    direct sums for homomorphisms and chain complexes, too:
	h = f ++ g : h.components gives the list of components
	f_[0,2] : compose f:M->N with inclusion
	g^[0,2] : compose g:L->M with projection

'incomparable', a new symbol that can be returned by "x ? y", the comparison
operator

'<=' and '>=' have been modified to behave correctly if "x ? y" might return
'incomparable'.
-----------------------------------------------------------------------------
New in 0.8.24:

the use of 'promote(I,R)' has been replaced by 'I*R', when I is an ideal and
R is a ring.

'ClassArgument' option to 'method' removed
-----------------------------------------------------------------------------
New in 0.8.21:

'basename' has been changed to 'baseName'

'on' changed to accept a function instead of a symbol

'content', a new routine for content of polynomials and matrices

'size', a new routine for measuring the size of objects.  It replaces
	the use of 'length' to get the number of terms in a polynomial.

'leadTermMatrix' changed to 'leadTerm'

'subset' changed to 'isSubset'

Our emacs mode for Macaulay 2 has been improved.  There is a new demo mode
which will start up Macaulay 2 in a new frame that has a larger font, and
there are function keys that can be used to obtain and execute lines of demo
code from buffers that are not

-----------------------------------------------------------------------------
New in 0.8.19:

'm2.init' is no longer loaded automatically - the init file is init.m2
'hilbertSeries' now pulls out factors of 1-$T from the numerator
'pushforward' changed to 'pushForward'
'pushforward1' changed to 'pushForward1'
'listForm', a new function which converts a polynomial to a form in which
     a polynomial is represented by lists of pairs (m,c), where m is
     a list of exponents for the variables in the ring, and c is the
     coefficient.
'listForm' and 'standardForm' also apply now to monomials
'exponents', a new function that tells what the exponents are in a monomial
     or polynomial

-----------------------------------------------------------------------------
New in 0.8.14:

A fix to 'decompose' provided by John Dalbec has been applied.  The problem
first appear when I incorporated the reordering routine of Messollen's 
incorrectly.

fixed 'html' - the html pages had extra braces and parentheses floating about.
-----------------------------------------------------------------------------
New in 0.8.12:

'decompose' has been sped up by incorporating a call to a new routine of
Michael Messollen which picks a good ordering for the variables in the ideal.
-----------------------------------------------------------------------------
New in 0.8.11:

'tex' works on the documentation now, and now the default for 
'document' is to create and use the EXAMPLE files if they exist.

'substitute' now works for ideals, and now
		substitute(f, x=>y)
	works (before a list of substitutions was required)

'res I' works for I an ideal, converting it to a module first.

'exponents' removed
-----------------------------------------------------------------------------
New in 0.8.10:

'stringlen' removed

'prune' now works for maps.

'CurrentDirectory' changed to 'currentDirectory'

a new function 'input' which loads a file, echoes the input, prints the
values of expressions, and increments the line numbers.

'lines' has been generalized slightly - its default action is to break the
string apart at the correct sequence of bytes that terminates a newline
in the current operating system, and its second argument which specifies
the newline sequence can be up to two bytes long.

a new variable, 'newline', has been introduced - its value is a string 
containing the sequence of bytes that terminates a line in the current
operating system.

'find' has been removed, for its use of a selector function which returns
'null'/'not-null' is confusing when compared with 'select'.

'select' now takes an optional first argument 'n' which specifies that
selection should stop after n elements of the list satisfy the criterion.

A new operator \ has been introduced.  It replaces @ as the operator that
applies a function to each element of a list.
	f \ g \ x  has the same effect as  x / g / f,
since \ is right-associative and / is left associative.
-----------------------------------------------------------------------------
New in 0.8.9:

The character ' is regarded as alphabetic, so symbols such as x' may be used

A alternate method for entering strings without attaching any special
meaning to " or \ has been introduced.  The new string delimiter is ///.
-----------------------------------------------------------------------------
New in 0.8.6:

'pruneAndMap' removed in favor of 'prune' and 'fromPrune'.

'exteriorPower' now works for modules.
-----------------------------------------------------------------------------
New in 0.8.5:

'exit' typed by itself on a command line will now exit the program, as it
	was supposed to do.
-----------------------------------------------------------------------------
New in 0.8.3:

R^1/I works now when I is an Ideal of the Ring R, to give the corresponding
quotient module

Tor^0 and Ext^0 fixed.  It gave 0 when the first module was free.

the name of the personal initialization file has been changed from 'M2.init'
to 'init.m2', in accordance with the documentation

new function 'isQuotientOf' for telling whether one ring is a quotient of another

length of a resolution works
-----------------------------------------------------------------------------
New in 0.8.1:

Fixed a bug in 'coefficients' such that if a garbage collection occured at a
certain time, a "bad handle" error message might appear.
-----------------------------------------------------------------------------
New in 0.8:

'minors(0,f)' fixed 

'singular' renamed to 'singularLocus', and changed so it takes a quotient
ring and returns a quotient ring of that.

'trim' will now take a quotient ring of a polynomial ring, and return one
where the defining ideal has been replaced by one minimally generated.

'map' now can take a integer second argument which provides the rank of the
source module only, allowing the degrees to be filled in.  The third argument
can be a doubly nested list of ring elements, or a function to provide them.

'minors' and 'pfaffians' now return ideals.

'symmetric' renamed to 'symmetricPower'
'exterior' renamed to 'exteriorPower'

function of 'partitions2' subsumed by 'partitions'

'subsets' and 'member' apply to Sets now.

'stack' renamed to 'engineStack'

the name of the personal initialization file has been changed from 'M2.init'
to 'init.m2'.

a new documentation item called 'SHIELD' which can be wrapped around TO links
	in menus to prevent the item referred to from being incorporated into
	the book at that point.

'increasing' and 'decreasing' removed

'saturation' change to 'saturate'

'division' changed to 'quotient'  (ideal-quotient)

new functions: isIsomorphism, isInjective, isSurjective, isWellDefined

'time' changed to 'timing'
'showTime' changed to 'time'

'IrreducibleCharacteristicSeries' changed to irreducibleCharacteristicSeries,
and now it takes an ideal instead of a matrix.

'decompose' now takes an Ideal and returns a list of Ideals.

'hilbertFunction' added

'im' changed to imaginaryPart
're' changed to realPart
'conj' changed to conjugate

The meaning of "matrix" for a map between subquotient modules has been
changed in a fundamental way.  Now the matrix describes how to transform
generators of the source into linear combinations of generators of the
target.  Previously the matrix was given in terms of the ambient free
module.

'eliminate' renamed to 'selectInSubring'

'cover M' new routine to give the free module of which M is a quotient

'super M' new routine to give the module of which M is a sumodule
'super f' composes f with the inclusion of target f into super target f

'modtensor' removed

'ambient f' -- routine for ambient matrix of a map, removed

'hilbertPolynomial' now takes an option "Projective" which specifies whether to
	write the answer in terms of binomial coefficient polynomials.

'kernel' of a ring map now returns an ideal instead of a module

'res' now works for modules over skew commutative rings

'subst' changed to 'substitute'
'symm' changed to 'symmetric'
'elim' changed to 'eliminate'
'ann' and 'annihilator' are synonyms
'generateSymm' eliminated
'generateSkew' eliminated
'genericSymm' changed to 'genericSymmetricMatrix'
'genericSkew' changed to 'genericSkewMatrix'
Arguments of both changed so that a variable is taken, rather than its
index in the list of variables.

'presentation R' now gives a presentation matrix for a quotient ring of 
a quotient ring over the original polynomial ring.

'Ideal' type introduced, to distinguish ideals from modules.
	I*J defined
	I^n defined
	dim I means dim R/I
	codim I means codim R^1/I

precedence of ^ and _ are now equal, and parsing is still left associative, so
	now both x_3^4 and R^3_1 work.

'homogenize' works for modules now.

'trim M' -- a new function which replaces generators and relations of M by
	minimal sets

Module maps (matrices) can now have source and target modules over different
rings, and 'basis' returns such maps.

new operations:
	Module ** Ring -- tensor product
	Matrix ** Ring -- tensor product

'H' renamed to 'HH' (think of blackboard boldface)
'Q' renmaed to 'QQ'
'd' renamed to 'dd' (as in C.d, differential of chain complex)
'Z' renamed to 'ZZ'
'Real' renamed to 'RR'
'Complex' renamed to 'CC', 'use Complex' eliminated, 
	'I' and 'ImaginaryI' renamed to 'ii'

'resolution' and 'res' are now synonyms
'gens' and 'generators' are now synonyms
'ker' and 'kernel' are now synonyms
'coker' and 'cokernel' are now synonyms

'..' will now work with (0,0)..(1,3) to yield 
	((0, 0), (0, 1), (0, 2), (0, 3), (1, 0), (1, 1), (1, 2), (1, 3))

'same' now tests equality with === instead of ==

'matrix' has been rearranged so that it mostly takes a doubly-nested list
and produces a map between free modules.  Its functionality where source and
target modules are explicitly provided is taken over by 'map'.

'matrix' has 'Degree' as an optional argument now, to set the degree of the map.

'ndegrees' changed to 'degreeLength'

'clearAll' -- new function for clearing values of output line variables, o1, o2, ...

'monideal' changed to 'monomialIdeal'

'matrix m', where m is a MonomialIdeal, has been replaced by 'generators m'

Matrices now have a degree associated with them, which can be obtained with
'degree f'.  The function 'degrees' has been disabled for matrices.

new function 'flagSymbol' -- can be used to flag each use of symbol by
printing an error message.

'coefficient' removed
'Polynomial' removed
'GBtrace' renamed 'gbTrace'

install(f,X,Y,g) must be replaced by f(X,Y):=g now
install(f,X,Y,Z,g) must be replaced by f(X,Y,Z):=g now

'merge' will now merge only two hash tables.  And the type of the result
will be the same as the arguments only if both arguments agree.

'scan' now can take two lists and a function, and apply the function to
the elements two at a time, as does 'map'

careful: 'list x' now gives the contents of an hash table x, rather than {x},
and if x is not a sequence, list, or hash table, then it gives an error
message.

Those instance of 'matrix' where the first two arguments are the target and
source modules of the map can now also be done with 'map'.

The sort sequence for strings and symbols has been changed to agree with
tradition, so that "a" < "b" now.

'list' removed.  For objects, use the new function 'pairs' to get a list
	of key/value pairs.  For lists and sequences, use 'elements' to
	get a list of type 'List'.
'page' removed (see experiments/repeat.m2)
'subring' and 'subring0' removed in favor of 'ker', which now works for ring maps
'iterates' removed (see experiments/iterates.m2)
'repeat' removed (see experiments/repeat.m2)
'Euler' replaced by 'euler'
'gbWithChange' removed, use 'gb' with 'ChangeMatrix=>true'
'assignto' replaced by 'assign'
'numvars' replaced by 'numgens'
'numterms' changed to 'length'
'padto' changed to 'pad'
'outstring' changed to 'printString'
'getlines' changed to 'getLines'
'deepsplice' changed to 'deepSplice'
'minposition' changed to 'minPosition'
'maxposition' changed to 'maxPosition'
'foldright' and 'foldleft' removed (but see experiments/fold2.m2)
'mergepairs' changed to 'mergePairs'
'rmergepairs' removed
'combinepairs' removed
'rcombinepairs' removed
'maps' removed
'CollectGarbage' changed to 'collectGarbage'
'ringMap' replaced by 'map'
'mappairstolist' removed.  Replace mappairstolist(x,f) by apply(list x,f).
'map' replaced by 'apply'
'mapPairs' replaced by 'applyPairs'
'mapKeys' replaced by 'applyKeys'
'maptable' replaced by 'applyTable'
'Create' removed
'subquot' changed to 'subquotient'
'sat' changed to 'saturation'
'makenew' removed
'contents' replaced by 'list'
'makeObject' replaced by 'hashTable'
'Object' replaced by 'HashTable'
'HashTable' and 'MutableObject replaced by 'MutableHashTable'
'apply' removed
'restart' changed to 'addStartFunction'
'listvars' changed to 'listUserSymbols'
'varlist' changed to 'userSymbols'
'argv' changed to commandLine
'args' eliminated
'reset' changed to 'restart'
'symboltable' changed to 'symbolTable'
'openfiles' changed to 'openFiles'
'isborel' changed to 'isBorel'
'ishomogeneous' changed to 'isHomogeneous'
'vec' changed to 'vector'
'leadTerms' changed to 'leadTermMatrix'
'kbasis' changed to 'basis'
'errordepth' changed to 'errorDepth'

new function 'trace', for matrices

M2.el is a gnu emacs file which provides a comvenient way to run Macaulay 2
in an emacs buffer.  One thing it provides is the ability to send lines or
regions of text from another buffer at the press of a function key.

a new function 'backtrace' which provides information about the steps in the
computation that led to an error.

'randomMatrix' is much faster (by a factor of 50), and has been replaced by 'random'

the command 'ls' has been eliminated

new function, 'wait', waits for a child process to finish

'tolist' has been eliminated

'.' is slightly different - now x.a is the same as x#(global a) instead,
	whereas before it was the same as x_(global a).  This will make it
	faster, because '_' can looks for methods installed by the user, but
	'#' is the raw hash table access operation

MAJOR CHANGE: '__' has been renamed to '#', '__?' has been renamed to '#?',
	and '_?' has been eliminated

'length' has been renamed to '#' so we can use use 'length' for mathematical
	concepts

'!' has been replaced by 'not' for logical negation.  '!' is retained as
	postfix operator for factorial.

Handling of interrupts and out of memory errors is better - it now returns
	to top level instead of exiting the program.  Also, null pointers
	are no longer allowed to be returned to the C++ code, so some
	former crashes are now prevented.

f/g now gives an element of the fraction field

new function 'coefficientRing'.  Also 'ambient' now applies to rings to get
the ring of which the ring presented is a quotient ring.

'map' now can take two lists and function of two variables

A new synonym for install(f,X,x->...) is provided:  f X := x -> ...
This looks better than X_f := x -> ... .  Notice that Y X := (y,x) -> ... is
distinguished from this by types: Y is an Object and f is a Function or
a Symbol.

new test functions: isModule, isIdeal, isSubmodule, isQuotientModule,
	isPolynomialRing, isAffineRing, isField, isQuotientRing, isRing.

new functions 'lift' and 'promote' for dealing with ring maps and base rings

new function 'ultimate' which yields the ultimate value for iteration
of a function

'absorb' is gone.  Use x->null instead!

Schur rings (representation rings of general linear groups) available -- 
see 'SchurRing'

OrderedMonoidRing has been renamed PolynomialRing

new option ClassArgument to 'method' which interprets one of the arguments
	to the method as a class itself.

general monoid rings and group rings removed

a new type of engine ring called 'FractionField', made with 'frac'.

graphIdeal and tensor have a new option 'VariableBaseName' to be used when
generating new variables

'ideal': new function for making ideals from lists of ring elements

'randomint' is gone, use 'random' instead

'mapkeys' is now 'mapKeys', and 'mappairs' is now 'mapPairs'

'scankeys' is now 'scanKeys', and 'scanpairs' is now 'scanPairs'

'map' is now a method, so that 'mapset' is replaced by 'map', and 'map' applies
to tallies.  Same for 'scan'.

a 'Set' is now implemented as a hash table where the values are all 1, and
a 'Set' is now a type of 'Tally', so that cartesian product and union are defined.

'randomElement' has been replaced by 'random'

'GlobalReleaseMethod' is 'GlobalReleaseHook'

'GlobalAssignMethod' is 'GlobalAssignHook'

'power' is gone

'divide' is gone

'tostring' is 'string'

'erase' - a new function for removing global symbols from the symbol table

'&&' and '||' have been replace by 'and' and 'or'.  Moreover the latter
operators open a new scope for the right hand side.  The parsing precendence
of '&&' and '||' is now higher than that of comparison operators like == .

New function: 'alarm', which can be used to interrupt a computation after a
certain time and try and and alternate approach.

Two new syntactic keywords : 'global' and 'local', like 'quote', except
'global' obtains a global symbol (old or new) and 'local' obtains a local
symbol, local to the same enclosing function or file

'ref' and 'val' are gone

There is a new function, 'remove', for removing entries from hash tables.  The
old way, ' x#a = null ', will now allow storing 'null' as a value in the hash table.

'objtake' and 'objdrop' are gone.

'seeScopes' is gone.

The functions 'spaces' and 'dashes' are gone.

Certain functions such as 'resolution' and 'mingens' now take only modules and not matrices
as arguments.  This change is meant to avoid any confusion about whether a matrix
is used as an abbreviation for its image or its cokernel!  So now you must write
'resolution cokernel m' or 'resolution image m' to clarify your meaning.

There is a new method called 'Print' which can be used to override the way
the top level interpreter prints a result.  The other methods have been rearranged, and
more of the top level interpreter is written in the interpreter itself.  Take a look
at the first few lines of init.m2.

'time' has been changed so that it returns a list of type 'Time' from which
the elapsed time can be extracted by a program.  The old behavior is provided
by a new function, 'showTime'.

Two dimensional printing works well with '<<' now.

The BeforePrint method is no longer used by the interpreter to print
results.

New commands 'quit', and now 'exit' without an argument will quit, too.

Changed 'expr' to 'expression'.

Two dimensional printing of polynomials has been sped up by about a factor of 5.

'box, 'display, 'HBox', 'VBox', 'FractionBox', 'MatrixBox, 'PMatrixBox' 
	have been eliminated in favor of 'net'

'intersect' now may be given more than two arguments.  This is accomplished
by defining it to be an associative method, which is done with:
	method(quote intersect, Associative => true)

'betweenNames' has been removed.  Use concat(between(s,name@v)) instead.

f@v is an operator that maps the function f over the elements of the list v

The functions 'demark' and 'betweenNames' have had the order of their
arguments reversed.

The function 'map' has been heavily optimized, especially for calling
interpreted functions, speeding it up by a factor of 3 or so.

The degrees of a module are now computed only when needed.  This means that
you must use 'degrees M' instead of 'M.degrees'.

Functions 'set', 'tally', and 'new Object from List' have been made very
fast.  So has the replicator function, 5:x, and a named function 'replicate'
ahs been provided that does the same thing.

Concatenation of strings is now done with concat() or with the binary
operator "|", rather than "+".  There is a new sort of 2-dimensional string
called an net.  Nets and strings can be concatenated horizontally with "|", 
vertically with "||", and raised with "^".

The new function 'width', applied to stdout, can be used to determine the
current width of the terminal window, i.e., the number of columns, as
reported by the tty device driver.

The variable 'gc' is gone.

The symbols Less, Greater, and Equal have been replaced by quote "<", quote
">", and quote "==".

The symbol 'o' (which gives the value of the previous expression) has been
replaced by 'oo'.

The symbol 'null' has been changed into something of class 'Nothing'.

The class 'Indeterminate' is gone, and all symbols now carry with them
information about what frame their values are stored in.  This changes
slightly the behavior of x.a when a is a local variable, for the key will be
different with each invocation of the function containing a.

We've put 'true' and 'false' into a new class called 'Boolean'.

The operators _^ and _^? have been eliminated in favor of 'lookup'.

Symbols like PlusMethod have been abandoned in favor of symbols like quote "+"
for constructing keys under which to store methods.

The functions of 'spy' have been merge into 'peek'.

There is a new function called 'browse' which allows the user to browse large
hash tables and lists.

We now type x_0 .. x_10 instead of x_(0 .. 10); moreover, the subscript i
in x_i can be any expression.
-----------------------------------------------------------------------------
New in 0.3.2:

Polynomial rings over Z are available.
There is a function 'isprime' which can be used to tell whether an
	integer is a probable prime.
A personal initialization file named M2.init is loaded when the program
	starts.
An ideal I in a ring R is a submodule of R^1.  The quotient ring R/I
	is now available.  If I is generated by ring elements (f,g,h)
	the notation R/(f,g,h) is also available.  If I is generated
	by one element f then R/f will suffice.
If M is a module and (m,n,p) are elements of M, then M/(m,n,p) provides
	the quotient module.
Substition for variable in a polynomial, which used to be writen as
	f[v], is now implemented in terms of a new function 'subst'.
	Now you write subst(f,v).  Type 'help subst' for details.
Multiplication must now be indicated explicitly by * instead of implicitly
	by adjacency, i.e., you must now type 2*x instead of 2x.
The parsing precedence has been changed so that the operators * / % //
	are of lower precedence than adjacency.  Thus
	f x * g y will now parse as (f x)*(g y) instead of (f ((x*g) y)) and
	f(x,y)/2 will now parse as (f (x,y))/2 instead of f ((x,y) / 2).
The parsing precedence has been changed so that brackets [ ] have lower
	parsing precedence than the operators * / % // .  Thus
	Z/5[x,y,z] will parse as (Z/5)[x,y,z].  Notice that { } and ( )
	have the same precedence as adjacency, which is higher than /, so that
	Z/5(x,y,z) will parse as Z/(5[x,y,z]).
-----------------------------------------------------------------------------
New in 0.3.1:

'identity M' has been replace by 'id_M', and 'id' has been replace by 'identity'
All functions for creating methods have been redone and combined into a single
	function called 'method'.
New function 'code' for retrieving the source code from compiled functions.
'degrees' now does something for modules - returns degrees of target and source
	in a list.
'generators' replaced by 'generators'
RememberMethod replaced by MakeMethod.  It is now the responsibility of the
	called method to cache previously computed values if it wants to.
	The advantage of MakeMethod is that it stores the method under
	a key other than the name of the method, which is then free to be
	used for caching values.
	To install a method, installMakeMethod is used.  Also:
	makeVariables, makeNumvars, makeDim, makeCoker, makeImage, makeKernel,
	makeGenerators, makeVars, makePrune have all been removed.
ColumnDegrees and RowDegrees have been eliminated.  Use 'degrees source f'
	and 'degrees target f' instead.  They weren't right anyway for 
	multi-degrees!
'errorDepth' introduced as a mechanism for suppressing error messages from
	pre-interpreted code.
'table' now yields the transpose of what it gave before, to agree with the
	way 'matrix' works.
unit element is now stored in R#1 instead of R.One; One is gone;
	but remember that R_1 gives the second variable of R, so use
	1_R to get the unit element
zero element is now stored in R#0 instead of R.Zero; Zero is gone
hashTable changed to HashTable
mutableObject changed to MutableObject
mutableList changed to MutableList
'inverse x' removed in favor of x^-1
_ @ . have been reorganized:
	_^ and # handle the raw access of elements of lists, sequences,
		databases, strings, and hash tables.  The only difference between
		them is that for hash tables, _^ looks in the ancestors, too.
	@? removed
	@ now is just an operator with methods available for the user
	_ is also just an operator with methods, but many meanings have been
		installed:
		    HashTable _ Thing := (X,s) -> X # s
		    List _ Thing := (X,s) -> X # s
		    String _ Z := (s,i) -> substr(s,i,1)
		    Module _ Z := (M,i) -> ...
	_? is also just an operator with methods, but many meanings have been
		installed:
		    HashTable _? Thing := (X,s) -> X #? s
		    List _? Thing := (X,s) -> X #? s
		    String _? Z := (s,i) -> s #? i
		    Module _? Z := (M,i) -> ...
	_* has been removed in favor of a new function, 'unlist'
'iszero' removed in favor of i->i==0
the notion of equality F==G now involves comparing the degrees of the generators
writing to a closed file now gives an error message
a warning is issued now when a local variable declaration shields another
	with the same name
'one R' and 'zero R' removed in favor of 0_R and 1_R.  3_R also works.
added an option, Compute, to resolution and gb which specifies whether to compute
	at all
changed hashTable to HashTable
new function 'ringMap' for making ring homomorphisms.  Taking the kernel
	of one gives an ideal, and replaces 'subring'.
new class EngineRing for general purpose interface to rings in the engine
new 'reset' command to reset the system to its initial state
:, %, and // works now for ring elements when appropriate
new algorithms installed for gb and resolution which are very fast.
new optional arguments for gb and resolution which control the depth of calculation.
'new Object from {x=>a, y=>b}' is a concise way to make new hash tables with
	specified contents.
"deepsplice" : new function which splices deeply
subgenerators renamed to generators
f[x=>a, y=>b] can be used to substitute for variables in a Polynomial
x.s now takes s to be a symbol in the local scope, if there is one
x_a = null now removes the entry in the hash table x for the key a
"shield" : a new function which shields code from interrupts
newvars is gone: instead, just type x_(0..6), for example
now x==y will fail if x and y are in differenct classes, and there
	is no method installed for comparison
resolutions are now MUCH faster
new functions : subqring, calc
new key in a Matrix : thisgb
_ now has higher parsing precedence than ^
resolution and gb have various options for halting the computation
-----------------------------------------------------------------------------
New in  0.2.2:

'name' of a matrix now yields a string which yields the same matrix when
	read back in.  'describe' will display that string without the
	quotation marks.
syntax for 'random' changed
'BasicType' removed; now a basic type is simply one whose parent is Thing
removed classes IntegerNumber, RealNumber, RationalNumber
