
Regina - A Normal Surface Theory Calculator

    This file gives a detailed list of changes between releases,
    including all changes to the C++/Python API.

    For just the key highlights, see the (far more readable) file
    HIGHLIGHTS.txt.

Version 6.0.1  [ 12 February, 2021 ]

    PYTHON:
        - Fixed an issue where the Triangulation3 constructor could become
          unusable in the graphical user interface.  This issue did not
          affect command-line users (e.g., regina-python users).

Version 6.0  [ 11 January, 2021 ]

    GENERAL:
        - Lots more polish and cleaning up of unfinished business from 5.96,
          which was just a prerelease for this version 6.0.
        - Removed the Christy knot/link complements from the example files,
          though it remains in the census lookup databases.  Also renamed it
          from the old "hyperbolic knot/link complements" to better reflect
          the ad-hoc nature of its contents.
    ENGINE:
        Class AbelianGroup:
            - New routine isFree() to quickly test for the free abelian
              group of the given rank.
        Class Triangulation<3>:
            - New routines isTxI() and knowsTxI() to test whether the
              manifold is the product of the torus with an interval.
              Thanks to Robert C. Haraway, III.
            - New routine minimiseBoundary() / minimizeBoundary() to
              ensure that each real boundary component uses the fewest
              posible triangles.
            - Routine hasSplittingSurface() is now fast (small polynomial
              time), works even for triangulations with more than one
              connected component; thanks to Robert C. Haraway III.
              This routine is now also explicitly marked as const.
            - As a consequence, routine knowsSplittingSurface() is no longer
              relevant, and so is now deprecated.
            - Routines twoOneMove(), simplifyToLocalMinimum() and
              intelligentSimplify() now preserve orientation, if the
              triangulation was oriented to begin with.
            - Routine barycentricSubdivision() already preserved orientation,
              but this is now a formal promise of the API.
            - Changed the preconditions for closeBook() to something
              logically equivalent but simpler to explain and test.
        Class Triangulation<4>:
            - Routines simplifyToLocalMinimum() and intelligentSimplify()
              preserve orientation; in fact this was true before, but it
              is now a documented part of the API.
    PYTHON:
        - Fixed a deadlock that occurred with Python 3 on some systems when
          starting new python consoles in the GUI.
    USER INTERFACES:
        - The Jones polynomial is now displayed as a polynomial in t
          where possible (as opposed to a polynomial in sqrt{t}).
        - Removed all use of the deprecated drillEdge(); in particular,
          this means the GUI will now refuse to drill between two boundary
          components where at least one of these boundaries is real.
    DOCUMENTATION:
        - Brough the user handbook up to date for this release, in
          particular with a new chapter on knots and links.

Version 5.96  [ 24 December, 2020 ]

    GENERAL:
        - Now requires C++14 (not C++11).
        - Now supports Python 3 (and continues support for Python 2).
        - For Python 2, there is now a minimum requirement of Python >= 2.6.
        - Now builds under gcc7 and gcc8.
        - Updated the bundled copy of Normaliz to version 3.7.2 (17 Apr 2019).
        - Now requires Boost in header form only, and only at build time:
          Regina no longer links against any of Boost's shared libraries.
        - Now uses pybind11 instead of Boost.Python to create python bindings.
        - Removed the cmake option USE_BOOST_INT128, since the boost 128-bit
          integer detection does not know more than the cmake tests can provide.
        - Now requires CMake version >= 3.12.
    ENGINE:
        Class AbelianGroup:
            - Added assignment operator.
        Class BitManipulator, GenericBitManipulator:
            - BitManipulator has a new routine nextPermutation() to
              iterate through bitmasks with a fixed number of true bits.
            - BitManipulator no longer takes a size template parameter;
              instead size is always taken to be sizeof(T).
            - The internal structure of BitManipulator has changed; in
              particular, the old GenericBitManipulator no longer exists.
        Class BoundaryComponent<3>:
            - Routine eulerChar() now requires no invalid vertices on the
              boundary component as a precondition.  This is to avoid having
              to define what Regina actually computes in such a scenario,
              which is well-defined but not topologically meaningful.
        Class CensusDB:
            - Added copy and move constructors and assignment operators.
        Class CensusHits, CensusHitIterator:
            - Routine CensusHits::first() now returns a const pointer.
            - You can now iterate over a CensusHits object using C++11
              range-based for loops, thanks to the new CensusHitIterator
              class.  In Python, CensusHits is now an iterable object.
        Class Cyclotomic:
            - New constructor that takes a C++11 initialiser list.
            - Added move constructor and assignment operator.
            - Added inverse().
            - Added operators +, *, -, / in several variants.
        Class DegreeLessThan, DegreeGreaterThan:
            - Added copy constructors.
        Class DiscSetSurface:
            - Now supports C++11 range-based for loops to iterate over all
              normal discs.  In particular, there are new begin() and end()
              functions.
            - In Python, DiscSetSurface is now an iterable object.
        Class DiscSpecIterator:
            - Updated to fit the standard C++ forward iterator concept.
              In particular, increment operators now have return values.
            - Now specialises std::iterator_traits for this iterator type.
        Class EnumConstraints:
            - Now just a typedef for std::vector<std::set<unsigned long>>,
              instead of being a derived class with no extra functionality.
        Class FacePair:
            - Added an output stream operator.
            - Replaced naive ++/-- operators with pairs of proper pre/post
              increment/decrement operators, to match usual ++/-- behaviour.
        Class FacetSpec:
            - Added output stream operators.
            - Preincrement and predecrement operators now return a reference
              instead of a clone, to match usual ++/-- behaviour.
        Class FileInfo:
            - Added copy constructor and assignment operator.
        Class GraphLoop, GraphPair, GraphTriple:
            - New copy constructors and assignment operators.
        Class GroupPresentation:
            - New Python-only sage() routine that converts a Regina
              group presentation to a mathematical object native to Sage.
        Class Handlebody:
            - New assignment operator.
        Class Integer, LargeInteger:
            - Fixed a bug in nativeValue() when converting negative numbers
              from large (GMP) representation to 128-bit integers.
              A thorough code audit shows this bug should have been harmless:
              Regina never created the conditions for the bug in its own code,
              and the routine has never been available to python users.
        Class Isomorphism<dim>:
            - Added (fast) move constructors and move assignment operators,
              and a (slow) copy assignment operator.
            - The random() function is now thread-safe, and takes an optional
              argument to enforce orientation-preserving isomorphisms only.
            - Static routines random() and identity() now return an
              Isomorphism, not a std::unique_ptr<Isomorphism>.  Now that
              Isomorphism has a move constructor and assignment operator,
              this should not be inducing unwanted deep copies.
        Class IsReginaInteger:
            - New type trait to identify Regina's own integer types.
        Class Laurent:
            - New constructor that takes a C++11 initialiser list.
            - Added move constructor and assignment operator.
            - Added operators +, *, -, / in several variants.
        Class Laurent2:
            - New constructor that takes a C++11 initialiser list.
            - Added move constructor and assignment operator.
            - Added operators +, *, -, / in several variants.
            - New constuctor that shifts a given polynomial by x^e y^e.
        Class LensSpace:
            - New assignment operator.
        Class LightweightSequence:
            - New copy constructor and assignment operator for deep copies.
            - Added move constructors and move assignment operators.
            - Constructor by size is now marked as explicit.
            - The inner type SubsequenceCompareFirstPtr's constructor now
              references (instead of cloning) the C-style array that is passed,
              and the caller is responsible for keeping that array alive
              while the SubsequenceCompareFirstPtr object is in use.
              This is a backward-incompatible change in behaviour.
        Class Link, Crossing, StrandRef, Tangle:
            - New classes to support knots and links, plus other additional
              classes and methods to interface with the Boost Graph Library.
        Class Manifold:
            - All manifold subclasses now have copy constructors and
              assignment operators.
            - Added some protected default constructors and operators so
              that base classes can use default implementations.
        Class MarkedAbelianGroup:
            - New routine isZ().
        Class MarkedVector:
            - Added a move constructor and move assignment.
        Class Matrix, MatrixRing, MatrixIntDomain:
            - These classes have now been merged into a single Matrix class.
              There is a new template argument to indicate whether the ring
              functions should be made available, and the integral domain
              functions are available only for Regina's own integer classes.
              The old class names MatrixRing and MatrixIntDomain are still
              available as deprecated typedefs.
            - Added (fast) move constructors and move assignment operators,
              and a (slow) copy assignment operator.
            - New static routine identity().
            - New typedef Coefficient representing the type of each entry.
            - The multiplication operator and the multiplyAs() routines now
              return a Matrix, not a std::unique_ptr<Matrix>.  Now that
              Matrix has a move constructor and assignment operator, this
              should not be inducing unwanted deep copies.
            - The routine multiplyAs is now deprecated (since there is no
              longer a Matrix class hierarchy), and it ignores its template
              arguments (instead always returning a matrix of the same class).
              You should just call the multiplication operator instead.
            - The constants zero and one are now deprecated.  Just use 0 and 1
              instead.
        Class mem_istream, mem_streambuf:
            - New classes to support input streams that read from memory.
        Class NormalHypersurfaces:
            - New routine sort() to sort hypersurfaces by arbitrary criteria.
            - The postconditions for enumerate() and makeMatchingEquations()
              now allow Regina to return null in certain coordinate systems,
              though there are not yet any coordinate systems where this can
              happen.
        Class NormalSurfaces:
            - New routine sort() to sort surfaces by arbitrary criteria.
            - The postconditions for enumerate() and makeMatchingEquations()
              now allow Regina to return null in certain coordinate systems.
              Currently NS_QUAD_CLOSED and NS_AN_QUAD_OCT_CLOSED are the only
              coordinate systems where this can happen.
        Class NormalSurface:
            - New routine countBoundaries(), thanks to Alex He.
            - Explicitly added preconditions to isOrientable(),
              isConnected() and isTwoSided() that the surface must be embedded.
              These preconditions were always required by the code, but
              were previously omitted from the API documentation.
        Class NSVectorQuadClosed:
            - New normal surface coordinate class to implement NS_QUAD_CLOSED.
        Class NSVectorQuadOctClosed:
            - New normal surface coordinate class to implement
              NS_AN_QUAD_OCT_CLOSED (thanks to Nathan Dunfield).
        Class Packet, PacketChildren, ChildIterator, SubtreeIterator:
            - Supports iterating over packets using range-based for loops:
                + Packet has new routines begin() and end() for iterating
                  through the entire subtree rooted at a given packet.
                  In Python, Packet is now an iterable object.
                + Packet has new routines children() and descendants() for
                  iterating through immediate children and strict
                  descendants respectively of a given packet.
                + New lightweight classes PacketChildren, PacketDescendants,
                  ChildIterator and SubtreeIterator to support this iteration.
                + For Python only, Packet has an additional new member function
                  subtree() that also returns an iterable object.
            - In python, tags() now returns a python set (not a python list).
        Class PacketListener, PacketShell:
            - Several backward incompatible changes to PacketListener, to make
              it difficult for listeners to call unsafe functions on packets
              that are already in the process of being destroyed:
                + PacketListener::packetToBeDestroyed() now takes a PacketShell,
                  not a full Packet*.  This severely limits the Packet member
                  functions that can be called.
                + PacketListener::childToBeRemoved() and childWasRemoved()
                  no longer take a third boolean argument (inParentDestructor).
                  Instead, when these are called from the parent destructor,
                  the first argument (representing the parent) will be null.
                  Likewise, when they are called from the child destructor,
                  the second argument (representing the child) will be null.
            - This class is now available for overriding in python!
            - PacketListener is now explicitly non-copyable, since copying the
              set of packets being listened to is not a lightweight operatation.
        Class Perm<n>:
            - The rand() function now takes an optional argument to enforce
              even permutations only.
            - The rand() function is now thread-safe out of the box, and also
              offers an alternate variant where you can pass your own
              uniform random bit generator.
        Class Polynomial:
            - New constructor that takes a C++11 initialiser list.
            - Added move constructor and assignment operator.
            - Added negate().
            - Added operators +, *, -, / in several variants.
            - Fixed a bug when using /= to divide a lower-degree polynomial by
              a higher-degree polynomial.  This should set the LHS to zero;
              instead it did nothing if LHS was a constant, and crashed if LHS
              had positive degree.  The bad code path was unreachable in
              Regina's own code, so users would only have experienced the bug
              if they were using Regina's Polynomial class in their own code.
        Class PosOrder:
            - Added copy constructor.
        Class Property:
            - Added a copy constructor, though (like the assignment operator)
              this cannot be used with the StoreManagedPtr storage policy.
            - The assignment operator now returns a non-const reference
              (not a const reference).
        Class RandomEngine:
            - New class for threadsafe random number generation.
        Class SafePointeeBase:
            - Added hasSafePtr() to test whether safe pointers are being used.
        Class SatBlockSpec:
            - Added copy constructor and assignment operator.
        Class SFSpace:
            - Assignment operator now returns a reference (not void).
        Class SimpleSurfaceBundle:
            - New assignment operator.
        Class Simplex<dim>:
            - New convenience routine edge(i,j) that returns the edge
              between two given vertices.
        Class SnapPeaCensusManifold:
            - New assignment operator.
        Class SnapPeaTriangulation:
            - Fixed a problem (present in Regina 5.0 and 5.1) in which SnapPea
              would sometimes retriangulate unexpectedly during the
              SnapPeaTriangulation(const Triangulation<3>&) constructor.
        Class SurfaceFilterProperties:
            - In python, eulerChars() now returns a python set (not a python
              list).
        Class TorusBundle:
            - New assignment operator.
        Class TreeDecomposition:
            - New copy constructor.
            - New constructor that takes a Link.
            - New routines writePACE(), pace() and fromPACE() to work with
              the PACE text format.
            - New reroot() routines to hang the tree from different roots.
            - New linear-time routine bag() for slow random access to bags.
            - Routine makeNice() now takes optional hints on the preferred
              nice tree structure.
        Class Triangulation<dim>:
            - Now implements the Boost Graph Library (BGL) interface.  The dual
              graph of a triangulation can be accessed seamlessly through the
              BGL by using the triangulation itself as the graph data structure.
            - New routine reflect().
            - New pachner() routines to support Pachner moves of all types
              in all dimensions.  In dimensions 2-4, the old names
              (e.g., oneFourMove(), threeThreeMove(), etc.) are deprecated,
              and simply call these new routines.
            - For oriented triangulations, all Pachner moves now preserve the
              orientation.
            - Relaxed the preconditions for connectedSumWith().
            - Now preserves computed properties of the underlying manifold
              when the manifold is retriangulated.
            - Routine intelligentSimplify() is now thread-safe in the
              way that it uses random number generation.
        Class Triangulation<4>:
            - New routines retriangulate() and simplifyExhaustive().
            - Now supports 2-0 moves on vertices of degree two (in addition to
              the pre-existing 2-0 moves on edges and triangles).
            - New deprecated routine fiveOneMove(), added for completeness.
              Use the new pachner() routines instead.
            - Routine intelligentSimplify() is now thread-safe in the
              way that it uses random number generation.
        Class Triangulation<3>:
            - New routine pinchEdge() to collapse an edge, which can be
              performed on any internal edge, but which adds two tetrahedra.
            - Added an optional argument to drillEdge() that inhibits
              simplification.
            - Deprecated drillEdge(), since in all cases that matter,
              pinchEdge() performs the same topological operation with
              vastly fewer tetrahedra.
            - New routine fillTorus() to fill 2-triangle torus boundary
              components.
            - New Python constructor that accepts a snappy.Manifold or a
              SnapPy.Triangulation (thanks to Matthias Goerner).
            - New routines longitude() and meridianLongitude() to deduce
              boundary curves for knot complements.
            - New deprecated routine fourOneMove(), added for completeness.
              Use the new pachner() routines instead.
            - When retriangulation() or simplifyExhaustive() is given a
              negative height, it now puts no limit on the number of
              additional tetrahedra (instead of doing nothing).
              This is a backward-incompatible change in behaviour.
        Class Triangulation<2>:
            - New deprecated routines threeOneMove() and twoTwoMove(),
              added for completeness.  Use the new pachner() routines instead.
        Enum Algorithm, TuraevViroAlg:
            - Renamed TuraevViroAlg to the more general Algorithm enum type.
              The old type name TuraevViroAlg and constants TV_... are now
              deprecated but kept for backward compatibility.
            - The deprecated constants (TV_...) have been removed from the
              enumeration type, and are now declared as standalone
              compile-time constants of type Algorithm.
        Enum NormalCoords:
            - Added NS_QUAD_CLOSED and NS_AN_QUAD_OCT_CLOSED for quad and
              quad-oct coordinates that restrict to closed surfaces only.
        Enum PacketType:
            - The deprecated values (PACKET_TRIANGULATION, etc.) have been
              removed from the enumeration type, and are now declared as
              standalone compile-time constants of type PacketType.
        Routine binomSmall():
            - Moved to maths/binom.h.
        Routine binomMedium():
            - New linear-time routine to compute (n choose k) for n <= 29.
        Routine gcdWithCoeffs():
            - The python version now takes (a, b) and returns (gcd, u, v).
        Routine politeThreads():
            - New routine to help user interfaces choose an appropriate
              level of parallelisation.
        Routine utf8ValidTo():
            - New routine to validate UTF-8 strings.
        Headers engine.h, output.h:
            - Moved into the core/ subdirectory, to help avoid naming conflicts
              with other software packages.  The original headers have
              been kept but are now deprecated.
        Header packetlistener.h:
            - Deprecated; please include packet.h instead.
    PYTHON:
        - Now "from regina import *" does not clobber the global open().
          Thanks to Matthias Goerner.
        - Packets no longer "expire" when they are deleted by the calculation
          engine.  They are merely orphaned in the packet tree, and will remain
          in existence for as long as python holds a reference to them.
        - Now constructs regina's arbitrary-precision Integer and LargeInteger
          objects correctly when given a python arbitrary-precision long as an
          argument.  Previously, when the argument was outside the usual
          32/64-bit native C++ long integer range, the automatic conversion
          went via floating-point arithmetic, resulting in a loss of precision.
    USER INTERFACES:
        - The iPad python environment is much more pleasant to work with.
        - Python tab completion in all user interfaces is more natural and now
          supports unicode.
    UTILITIES:
        retriangulate:
            - New utility that exhaustively retriangulates a given manifold.
        tricensus-mpi, tricensus-mpi-status:
            - Officially retired; these have now been removed from Regina.
    TEST SUITE:
        - The test suite executable now takes optional arguments that,
          if present, indicate a subset of tests to perform.

Version 5.1  [ 19 December, 2016 ]

    GENERAL:
        - Now supports knots and links.
        - Removed all code that was deprecated in or before version 5.0.
        - Renamed all types NFoo to Foo, and renamed the headers accordingly.
          The old types and headers are deprecated but kept for backward
          compatibility.  There are some exceptions:
            + NAngleStructureList becomes AngleStructures.
            + NEnumConstraintList becomes EnumConstraints.
            + NExampleSnapPeaTriangulation becomes ExampleSnapPea.
            + NNormalHypersurfaceList becomes NormalHypersurfaces.
            + NNormalHypersurfaceVectorMirrored is removed entirely (see below).
            + NNormalHypersurfaceVectorStandard becomes HSVectorStandard.
            + NNormalSurfaceList becomes NormalSurfaces.
            + NNormalSurfaceVector{Standard,...} becomes NSVector{Standard,...}.
            + NSurfaceSubset is removed entirely (see below).
            + For triangulation-related classes and headers:
              - All vertex/edge/face/etc, component, boundary component and
                isomorphism headers are included automatically by the new
                headers triangulation/{dim2.h, dim3.h, dim4.h, generic.h}.
                These are now the preferred headers for accessing
                triangulations, faces, etc. in dimensions {2, 3, 4, >= 5}.  For
                instance, triangulation/nvertex.h becomes triangulation/dim3.h,
                dim2/dim2component.h becomes triangulation/dim2.h, and
                generic/face.h becomes triangulation/generic.h.
              - All facet pairing headers are included automatically by the
                new headers triangulation/facetpairing3.h (for dimension 3)
                and triangulation/facetpairing.h (for all other dimensions).
              - All gluing permutations headers are replaced by the new header
                census/gluingperms.h, and all gluing permutation search headers
                are replaced by census/gluingpermsearcher{2,3,4}.h.
              - All typedefs of the form Dim2Foo, NFoo and Dim4Foo are now
                deprecated, in favour of the templated class names Foo<2,3,4>.
                For instance, Dim2Triangulation becomes Triangulation<2>,
                NVertex becomes Vertex<3>, and Dim4Isomorphism becomes
                Isomorphism<4>.
              - As a special cases:
                * Dim2TriangleEdge, NTetFace and Dim4PentFacet become
                  FacetSpec<2,3,4>;
                * Dim2EdgePairing, NFacePairing and Dim4FacetPairing become
                  FacetPairing<2,3,4>;
                * Dim2ExampleTriangulation, NExampleTriangulation and
                  Dim4ExampleTriangulation become Example<2,3,4>.
            + maths/nperm{2,3,4,5}.h are all replaced by maths/perm.h.
            + maths/nmatrixint.h is now merged into maths/matrix.h.
            + subcomplex/nlayeredsurfacebundle.h has been renamed to
              subcomplex/layeredtorusbundle.h.
            + surfaces/sf{combination,properties}.h are both merged into
              surfaces/surfacefilter.h.
            + utilities/nbooleans.h becomes utilities/boolset.h.
            + Some internal classes do not have backward compatible headers or
              typedefs.  None of these internal classes are exposed to Python,
              and typical C++ users would have no reason to use them either.
    ENGINE:
        Namespace regina::syntax:
            - New suite of classes for managing syntax highlighting.
              These classes should be considered internal - they only appear
              in the engine so they can be used by both the Qt and iOS GUIs.
            - Thanks to these new classes, Regina no longer builds against
              source-highlight.
        Class AbelianGroup, MarkedAbelianGroup, HomMarkedAbelianGroup:
            - Now works with type Integer, not LargeInteger.
        Class BoundaryComponent<dim>:
            - A new generic template for boundary components, which generalises
              the old standalone Dim2BoundaryComponent, NBoundaryComponent and
              Dim4BoundaryComponent classes.
            - New routines size() and facet() to query top-dimensional faces.
            - New routine countRidges(), to help with higher dimensions
              where (dim-2)-faces are not actually stored.
            - New routines facets() and faces(), plus aliases vertices(),
              edges(), etc. where relevant.
            - New routine isReal() for dimensions dim = 3,4.
            - New routine build() for dimensions other than 4 (this was
              already present for dimension 4).
            - New routine isOrientable() for dimensions other than 3 (this was
              already present for dimension 3).
            - New routine triangulation() to access the enclosing triangulation.
        Class Component<dim>:
            - New routine boundaryComponents() in all dimensions, and new
              routines countBoundaryComponents() and boundaryComponent() in
              higher dimensions (these were already present for dimensions 2-4).
        Class Crossing, CrossingStrand:
            - Supporting classes for the new Link packet class.
        Class Cyclotomic:
            - This class is now thread-safe.  (Previously it was not, because
              it worked with a global cache of cyclotomic polynomials.)
        Class Example<dim>:
            - A new generic template for generating example triangulations,
              which generalises the old standalone Dim2ExampleTriangulation,
              NExampleTriangulation and Dim4ExampleTriangulation classes.
            - New routines sphere(), simplicialSphere(), sphereBundle(),
              twistedSphereBundle(), ball(), ballBundle() and
              twistedBallBundle() for dimensions that did not have them.
            - New routines singleCone() and doubleCone() for dimensions >= 3
              that did not have them.
        Class Face<dim, subdim>:
            - The template parameters are expanded to include the case
              Face<dim, dim>, which now implements the old class Simplex<dim>.
              Simplex<dim> remains as a templated type alias, and is still
              the preferred way to refer to this class.
            - For higher-dimensional triangulations (dim >= 5), faces now
              support isBoundary(), boundaryComponent(), and for
              codimension-1-faces only, inMaximalForest().
            - Fixed inMaximalForest(), which was broken in dimension >= 8.
        Class GluingPermSearcher<2,3,4>:
            - A new generic class that replaces the old Dim2GluingPermSearcher,
              NGluingPermSearcher and Dim4GluingPermSearcher.  For now this
              class remains undefined for higher dimensions.
        Class HomologicalData:
            - Now works with type Integer instead of LargeInteger for all
              member functions except for torsionSigmaVector().
        Class Laurent, Laurent2:
            - New classes for Laurent polynomials in one and two variables.
        Class Link:
            - New packet class for knots and links in the 3-sphere.
        Class MarkedVector:
            - New routine refill() for bulk replacements.
        Class MatrixInt:
            - Now stores elements of type Integer, not LargeInteger.  If
              you need support for infinity, you can always use the class
              MatrixIntDomain<LargeInteger> instead.
            - This is now a typedef, not a class in its own right.
        Class MatrixIntDomain:
            - New generalisation of MatrixInt for working in other
              integral domains.
        Class NormalSurface:
            - New routines systemAllowsAlmostNormal(), systemAllowsSpun() and
              systemAllowsOriented().
        Class NormalSurfaces, NormalHypersurfaces:
            - For the inner VectorIterator class, the dereference
              operator * now returns a Ray&, not a pointer to a
              NNormal{Surface,Hypersurface}Vector.
        Class NormalSurfaceVector, NormalHypersurfaceVector:
            - No longer inherits from Ray, and therefore many of the old
              vector functions are no longer available.  (It was dangerous
              to call these in the past, since "mirrored" vector classes
              were not meant to be modified after their first query.)
            - New member function coords() to access the underlying Ray
              (but with const access only).
            - New const access functions size() and operator [], to replace
              functions that were lost by not inheriting from Ray.
            - New non-const operations setElement(), += and scaleDown(), which
              act correctly in all coordinate systems (unlike the old versions
              of these functions that were inherited from Ray).
            - Function rawVector() now returns a Ray&, not a pointer to a
              NNormal{Surface,Hypersurface}Vector.
            - Now derives from boost::noncopyable, so the default copy
              constructor is gone.  Instead, individual vector subclasses now
              have a copy constructor that takes a member of that same subclass.
        Class NormalHypersurfaceVectorMirrored:
            - Removed, since this is never used (at present).
        Class NormalSurfaceVectorMirrored:
            - The real work has now moved to a static makeMirror() function,
              which subclasses must also implement.
            - Now behaves correctly when the vector is changed, even after
              the mirror has been created.
            - Removed the copy constructor.
        Class Packet:
            - writeXMLFile() is now available in python (using std::cout only).
        Class Perm<n>:
            - New method clear() to reset a suffix of the permutation
              to the identity map.
        Class Primes:
            - This class is now thread-safe.  (Previously it was not, because
              it worked with a global cache of pre-computed primes.)
        Class ProgressTracker, ProgressTrackerOpen:
            - Routine newStage() now accepts C++-style strings as well as
              C-style strings.
        Class Property:
            - New routine swap() for fast swapping of data.
        Class PropertyBase:
            - Removed, since it provided no enhancements to Property.
        Class Primes:
            - Now works with type Integer, not LargeInteger.
        Class SafePtr:
            - New default constructor, bool conversion and routine reset().
            - Disabled the default copy assignment operator.
        Class Script:
            - New routine addVariableName(), which changes the name if
              necessary to ensure that the variable can indeed be added.
        Class Simplex<dim>:
            - This is now implemented as the specialisation Face<dim, dim>.
              The preferred way to refer to this class is still Simplex<dim>,
              which is now a templated type alias.
            - Fixed facetInMaximalForest(), which was broken in dimension >= 8.
        Class SurfaceSubset:
            - Removed entirely.  This class has been unused for several years,
              and was just a trivial wrapper for iterating through a surface
              list with a filter.
        Class Triangulation<dim>:
            - New routines boundaryComponents(), countBoundaryComponents()
              and boundaryComponent() for higher-dimensional triangulations
              (these were already present for dimensions 2-4).
            - New routine eulerCharTri() for all dimensions (this was already
              present for dimensions 3 and 4).
            - New routines fundamentalGroup(), simplifiedFundamentalGroup(),
              homology() and homologyH1() for all dimensions (these were
              already present for dimensions 3 and 4).  These routines do not
              require the triangulation to be valid (i.e., the old validity
              restrictions in dimension 4 have been lifted).
            - New two-argument copy constructor that allows you to clone
              a triangulation without cloning its computed properties.
            - Routine barycentricSubdivision() is now available in dimension 2,
              uses a consistent generic implementation for all of Regina's
              standard dimensions, and now comes with guarantees about the
              labelling and ordering of sub-simplices.
            - Routine swapContents() now swaps skeletal data and computed
              properties also, instead of just deleting them.
            - New compile-time constant Triangulation<dim>::dimension.
        Class Triangulation<3>:
            - Routine retriangulate() now allows its action argument to
              change the triangulation that is passed to it.
            - Routine turaevViro() now takes a progress tracker, and
              allows cancellation.
        Typedef UseDim2GluingPerms, UseGluingPerms, UseDim4GluingPerms:
            - Renamed to GluingPermSearcher<2,3,4>::Use.  The old names are
              kept but deprecated.
        Enum PacketType:
            - Renamed PACKET_NORMALSURFACELIST to PACKET_NORMALSURFACES,
              PACKET_NORMALHYPERSURFACELIST to PACKET_NORMALHYPERSURFACES,
              and PACKET_ANGLESTRUCTURELIST to PACKET_ANGLESTRUCTURES.
              The old names are kept but deprecated.
            - Deprecated the old names PACKET_DIM2TRIANGULATION,
              PACKET_TRIANGULATION and PACKET_DIM4TRIANGULATION.
              Instead use the newer names PACKET_TRIANGULATION{2,3,4}.
        Routine faceOppositeEdge():
            - New routine for optimised face number calculations.
        Routine preImageOfLattice(), torsionAutInverse():
            - Now works with type Integer instead of LargeInteger.
        Routine isZero, isNonZero, isPositive, isNegative, isNonPositive,
                isNonNegative:
            - Deprecated, with no replacements.  This is because the methods
              here for managing round-off error were quite brutal.
        Routine valueOf():
            - The bool version now accepts "1" and "0".
        Routine xmlString():
            - New routine for converting between libxml and C++ strings.
        Global array quadDefn[][]:
            - Added to nnormalsurface.h, with the same contents as the old
              (and now removed) array vertexSplitDefn[][].
        Macro REGINA_NORMAL_SURFACE_FLAVOUR, REGINA_NORMAL_HYPERSURFACE_FLAVOUR:
            - Now takes a third argument, representing the parent vector class.
        Header triangulation/forward.h:
            - New header that is now the preferred method of forward-declaring
              Regina's triangulation-related classes and type aliases.
    PYTHON:
        - Removed Regina's ancient "python libraries" facility, since Python
          itself offers better and more standardised ways of doing this.  The
          file ~/.regina-libs is now ignored, and you can happily delete it.
    USER INTERFACES:
        - The desktop interface has (at last) gained a "Window" menu.
        - The iPad interface now gives access to Python, offers syntax
          highlighting for script packets, and offers a range of parameterised
          3-manifold constructions similar to those in the desktop interface.
        - Turaev-Viro calculations now show progress, and can be cancelled.
        - The default label for new normal surface packets now includes the
          coordinate system that was used to enumerate them.
        - In the triangulation composition tab on the desktop, isomorphism
          signatures are now selectable, and dehydration strings have been
          removed.  You can still access dehydration strings through python.
        - Several other minor enhancements and updates.
    UTILITIES:
        - All MPI-enabled utilities are now deprecated. These will
          be removed in some upcoming version of Regina.

Version 5.0  [ 26 September, 2016 ]

    GENERAL:
        - Now supports triangulations of all dimensions 2,...,15.
          Dimension 4 (like dimensions 3 and 2) has rich functionality;
          dimensions 5,...,15 have more basic support.
        - Now uses aspects of C++11, which your compiler will need to support.
        - Merged sources for the iPad version into the main source tree.
        - Updated the bundled copy of Normaliz to version 3.0.0 (28 Sep 2015).
        - Switched from std::auto_ptr to std::unique_ptr throughout the API.
        - Many routines of the form getFoo() have been renamed to foo(),
          with the old names deprecated but kept for backward compatibility.
          Likewise, many routines getNumberOfFoo() have been renamed to
          countFoo().  There are too many of these changes to mention, and
          so these are not listed individually below.
        - Much of the triangulation-related code is now dimension-agnostic.
          The new namespaces regina::detail and regina::alias contain
          implementation details that should not concern the end user.
    BACKWARD COMPATIBILITY:
        - Several routines have been removed, which may break your old code.
          See http://regina.sourceforge.net/regina4to5.html for details,
          as well as suggested replacements.
    ENGINE:
        All:
            - Removed ShareableObject from the class hierarchy.  All classes
              that used to inherit from ShareableObject now inherit (directly
              or indirectly) from the Output<> template instead.  As a result,
              many such classes no longer contain any virtual functions.
        Namespace regina::boost, regina::stl:
            - Removed these namespaces and all their members.  To fix
              code that used regina::boost, just use plain boost instead.
        Class Component, ComponentBase:
            - Component<dim> is now a generic class that replaces the old
              Dim2Component, NComponent and so on.  ComponentBase<dim> is a
              base class with functionality common to all dimensions,
              whereas Component<dim> is specialised for dimensions 2, 3 and 4.
            - The old class names Dim2Component and NComponent have
              been kept as typedefs for convenience.
        Class CompressionBuffer, CompressionStream, DecompressionBuffer,
                DecompressionStream, ZBuffer:
            - Removed entirely.  Regina now uses boost::iostreams instead.
        Class DegreeLessThan, DegreeGreaterThan:
            - New template-based helper classes for sorting subfaces of
              a triangulation by degree.
        Class Dim2BoundaryComponent, Dim2Component, Dim2Edge, Dim2Vertex
            - New dimension-agnostic routines countFaces<subdim>() and
              face<subdim>().
        Class Dim2Component:
            - New routine getNumberOfBoundaryFacets(), which is identical to
              the dimension-specific getNumberOfBoundaryEdges().
            - New routine hasBoundaryFacets() and alias hasBoundaryEdges().
            - New routine isValid().
            - New dimension-agnostic routines countFaces<subdim>(),
              faces<subdim>() and face<subdim>().
            - Routine getNumberOfSimplices() has been renamed to size().
              The old names is retained but deprecated.
        Class Dim2Edge, Dim2EdgeEmbedding:
            - Now just typedefs for the new classes Face<2, 1> and
              FaceEmbedding<2, 1>, which have the same functionality as
              the old Dim2Edge and Dim2EdgeEmbedding respectively.
            - New routine inMaximalForest() for working with the dual
              1-skeleton.
            - Added begin(), end(), front() and back() to Dim2Edge.  In
              particular, this class now supports C++11 range-based for loops.
            - Added getEmbeddings() to Dim2Edge for Python (but not C++).
            - Changed the ordering[] array to a static ordering() function.
            - New faceNumber() function as an "inverse" for ordering().
            - New containsVertex() function for testing which vertices
              belong to which edges.
            - New trivial routines isValid() and isLinkOrientable(), for
              consistency with faces in higher dimensions.
            - Removed the old routine getNumberOfEmbeddings(), and replaced
              it with the new (and equivalent) routine getDegree().
        Class Dim2Isomorphism:
            - Now just a typedef for the new class Isomorphism<2>, which has
              the same functionality as the old Dim2Isomorphism.
            - New static routine identity().
            - Routine getSourceSimplices() is deprecated, and has been
              replaced with the easier-to-type size().
            - Routines findAllIsomorphisms() and findAllSubcomplexesIn() now
              take an arbitrary output iterator, instead of the user passing a
              std::list to fill with results.
        Class Dim2Triangle:
            - Now just a typedef for the new class Simplex<2>, which has
              the same functionality as the old Dim2Triangle.
            - New routine facetInMaximalForest(), for examining a
              precomputed maximal forest in the dual 1-skeleton.
            - New dimension-agnostic face<subdim>() and faceMapping<subdim>()
              template functions.
            - You can now safely call unjoin() on a boundary edge.
            - Routine joinTo() has been renamed to join().  The old name
              joinTo() has been kept but is now deprecated.
        Class Dim2Triangulation:
            - Now just a typedef for the new class Triangulation<2>, which has
              the same functionality as the old Dim2Triangulation.
            - New dimension-agnostic face<subdim>() and faces<subdim>()
              template functions.
            - New dimension-agnostic function hasBoundaryFacets().
            - Reconstruction from isomorphism signatures now allows
              leading and/or trailing whitespace.
            - Routine getNumberOfSimplices() has been renamed to size().
              The old name is deprecated but kept for backward compatibility.
            - New dimension-agnostic routine countBoundaryFacets().
            - New routines isOriented(), orient(), makeDoubleCover(),
              finiteToIdeal() and splitIntoComponents(), inherited from the
              generic TriangulationBase<dim> template.
            - New routine fVector().
            - Routines getVertices() and getEdges() no longer return a
              reference to a std::vector.  Instead they return a FaceList
              structure, which also supports C++11 range-based for loops and
              operator [] (amongst other things).
            - Routines simplexIndex(), vertexIndex(), edgeIndex(),
              triangleIndex(), componentIndex() and boundaryComponentIndex()
              are all deprecated.  Just call Dim2Vertex::index() and so on
              instead.
        Class Dim2Vertex, Dim2VertexEmbedding:
            - Now just typedefs for the new classes Face<2, 0> and
              FaceEmbedding<2, 0>, which have the same functionality as
              the old Dim2Vertex and Dim2VertexEmbedding respectively.
            - Added begin(), end(), front() and back() to Dim2Vertex.  In
              particular, this class now supports C++11 range-based for loops.
            - New routines ordering(), faceNumber() and containsVertex(), for
              consistency with higher-dimensional faces.
            - New trivial routines isValid() and isLinkOrientable(), for
              consistency with faces in higher dimensions.
            - Removed getEmbeddings() for C++, but kept it for Python.
            - Removed the old routine getNumberOfEmbeddings().  Just use
              the equivalent routine getDegree() instead.
        Class Dim4GluingPerms, Dim4GluingPermSearcher:
            - New classes for building a census of 4-manifold triangulations.
        Class Dim4Triangulation, Dim4BoundaryComponent, Dim4Component,
                Dim4Vertex, Dim4Edge, Dim4Triangle, Dim4Tetrahedron,
                Dim4Pentachoron, Dim4Isomorphism, Dim4ExampleTriangulation,
                NXMLDim4TriangulationReader:
            - New suite of classes to support 4-dimensional triangulations.
            - Note that some member functions of these new classes are
              deprecated already (these are for consistency with older
              deprecated functions for 3-manifolds).
        Class DimTraits:
            - Removed entirely.  For the typedefs that it used to provide
              (e.g., Triangulation, Simplex, FacetPairing, etc.), just use
              Triangulation<dim>, Simplex<dim>, FacetPairing<dim>, and so on.
        Class Face, FaceEmbedding, FaceBase, FaceEmbeddingBase, FaceStorage,
                FaceValidity, FaceOrientability:
            - Face<dim, subdim> is now a generic class that replaces the
              old face classes Dim2Vertex, Dim2Edge, NVertex, NEdge, NTriangle.
              FaceBase<...>, FaceStorage<...>, FaceValidity<...> and
              FaceOrientability<...> are base classes with functionality
              common to all dimensions, whereas Face<dim, subdim> is
              specialised for dimensions dim = 2, 3 and 4.
            - Likewise, FaceEmbedding<dim, subdim> is a generic class
              that replaces Dim2VertexEmbedding, ..., NTriangleEmbedding.
              Again, FaceEmbeddingBase<dim, subdim> is a base class with
              common functionality, and FaceEmbedding<dim, subdim> is
              specialised for dimensions dim = 2, 3 and 4.
            - The old class names (Dim2Vertex, ..., NTriangle and
              Dim2VertexEmbedding, ..., NTriangleEmbedding) have been kept
              as typedefs for convenience.
        Class FaceNumbering, FaceNumberingImpl, FaceNumberingAPI:
            - FaceNumbering<dim, subdim> is a new class that offers various
              ways to query the numbering scheme for subdim-faces in a
              dim-dimensional simplex.  FaceNumberingImpl<...> is a base
              class that provides the implementation, and FaceNumberingAPI<...>
              is a base class used to help with documentation.
            - FaceNumbering<dim, subdim> is a base class of Face<dim, subdim>,
              so end users can access its routines directly from Face<...>.
        Class FacetPairing, FacetPairingBase:
            - FacetPairing<dim> is now a generic class that replaces the old
              Dim2EdgePairing, NFacePairing and so on.  FacetPairingBase<dim>
              is a base class with functionality common to all dimensions
              (replacing NGenericFacetPairing<dim>), and FacetPairing<dim>
              is specialised for dimension 3.
            - The old class names Dim2EdgePairing and NFacePairing have
              been kept as typedefs for convenience.
        Class HasReturnType:
            - New class to detect at compile time whether the type
              T::ReturnType exists.
        Class IntOfMinSize:
            - Gives access to native integer types of a given minimum size.
        Class Isomorphism, IsomorphismBase:
            - Isomorphism<dim> is now a generic class that replaces the old
              Dim2Isomorphism, NIsomorphism and so on.  IsomorphismBase<dim>
              is a base class with functionality common to all dimensions,
              whereas Isomorphism<dim> is specialised for dimensions 2, 3 and 4.
            - The old class names Dim2Isomorphism and NIsomorphism have
              been kept as typedefs for convenience.
        Class LightweightSequence:
            - New lightweight class for storing an array of objects.
        Class NAbelianGroup:
            - Now supports unicode output via utf8().
        Class NAngleStructureList:
            - Renamed getNumberOfStructures() to size().  The old name is
              deprecated, but has been kept for backward compatibility.
            - Now uses C++11 std::thread internally instead of the old NThread.
        Class NBoundaryComponent:
            - New dimension-agnostic routines countFaces<subdim>() and
              face<subdim>().
            - Removed 2-face members getFace() and getNumberOfFaces(), both of
              which were deprecated.  Instead use the names that replace
              "face" with "triangle".
        Class NComponent:
            - New routine getNumberOfBoundaryFacets(), which is identical to
              the dimension-specific getNumberOfBoundaryTriangles().
            - New routine hasBoundaryFacets() and alias hasBoundaryTriangles().
            - New routine isValid().
            - New dimension-agnostic routines countFaces<subdim>(),
              faces<subdim>() and face<subdim>().
            - New routines vertices(), edges(), triangles() and tetrahedra().
            - Routines getNumberOfSimplices() has been renamed to size().
              The old name is retained but deprecated.
            - Removed 2-face members getFace(), getNumberOfFaces() and
              hasBoundaryFaces(), all of which were deprecated.  Instead use
              the names that replace "face" with "triangle".
        Class NContainer:
            - New constructor that takes a packet label.
        Class NCyclotomic:
            - New class for exact arithmetic in cyclotomic fields.
        Class NDiscSpec:
            - Added != operator to complement the existing == operator.
        Class NDiscSpecIterator:
            - Added == and != comparison operators.
        Class NEdge, NEdgeEmbedding:
            - Now just typedefs for the new classes Face<3, 1> and
              FaceEmbedding<3, 1>, which have the same functionality as
              the old NEdge and NEdgeEmbedding respectively.
            - Added begin(), end(), front() and back() to NEdge.  In
              particular, this class now supports C++11 range-based for loops.
            - Changed the ordering[] array to a static ordering() function.
              Importantly, this function no longer guarantees that the
              resulting permutation will be even.
            - New faceNumber() function as an "inverse" for ordering().
            - New containsVertex() function for testing which vertices
              belong to which edges.
            - New trivial routine isLinkOrientable(), for consistency with
              faces in higher dimensions.
            - Removed getEmbeddings() for C++, but kept it for Python.
            - Removed the old routine getNumberOfEmbeddings().  Just use
              the equivalent routine getDegree() instead.
        Struct NewFunction, NewFunction1:
            - NewFunction1 is deprecated in favour of the new and more
              flexible NewFunction, which allows arbitrary arguments and
              has less overhead.
        Class NExampleSnapPeaTriangulation:
            - New class for building ready-made SnapPea examples.
        Class NExampleTriangulation:
            - New parameterised routines lens() and lst().
              The old hard-coded lens8_3() and lst3_4_7() are now deprecated.
            - Renamed figureEightKnotComplement(), trefoilKnotComplement()
              and whiteheadLinkComplement() to figureEight(), trefoil()
              and whiteheadLink() respectively.  The old names are kept
              but deprecated.
        Struct NFacetSpec:
            - Renamed to FacetSpec.  The old NFacetSpec<dim> is deprecated
              but has been kept as a type alias for backward compatibility.
            - Added != operators to complement the existing == operators.
        Class NGenericFacetPairing, NFacePairing, Dim2EdgePairing:
            - The template base class NGenericFacetPairing<dim> has been
              renamed FacetPairingBase<dim>, and its header has moved to
              generic/facetpairing.h.
            - No longer derives from NThread.  The old public run() routine
              is now private (and has been renamed and redesigned).
            - Now derives from ShortOutput.
            - Routines dotHeader() and writeDotHeader() no longer set an
              explicit background colour.
            - Routine findAllPairings() now always runs in the current thread,
              and no longer takes the final optional newThread argument.
            - Removed the Perm typedef.  Juse use NPerm<dim+1> instead.
            - Removed the Triangulation typedef.  Just use Triangulation<dim>.
            - Dimension-specific headers dim2edgepairing.h and nfacepairing.h
              have moved from census/ into the dimension-specific directories
              dim2/ and triangulation/ respectively.
        Class NGenericGluingPerms:
            - Removed the FacetPairing typedef.  Just use FacetPairing<dim>.
        Class NGenericGluingPermSearcher:
            - Removed the Perm typedef.  Juse use NPerm<dim+1> instead.
            - Removed the Triangulation typedef.  Just use Triangulation<dim>.
        Class NGenericIsomorphism:
            - Removed entirely.  Just use Isomorphism<dim> instead.
        Class NGenericTriangulation, NTriangulation, Dim2Triangulation:
            - Removed the NGenericTriangulation class entirely.  This class
              has been merged into the new generic TriangulationBase.
            - Removed the Perm typedef.  Juse use NPerm<dim+1> instead.
            - Removed the Triangulation typedef.  Just use Triangulation<dim>.
        Class NGlobalDirs:
            - The directory containing the machine-encoded census data is now
              independent of home().  It can be queried through the new census()
              routine, and set through an optional third argument to setDirs().
            - The homeDir argument to setDirs() may now be the empty string,
              which signals that the directory should not be changed.
        Class NGraphLoop, NGraphPair, NGraphTriple:
            - In python, the constructors now clone their NSFSpace arguments
              (as opposed to claiming ownership of them).
        Class NGroupExpression, NGroupExpressionTerm:
            - Added != operators to complement the existing == operators.
            - Added optional utf8 argument to NGroupExpression::writeText()
              to replace gen^exp notation with unicode subscript characters.
        Class NGroupPresentation:
            - Routine recogniseGroup() now takes an optional moreUtf8
              argument for prettier printing.
            - In python, addRelation() now clones its argument (as
              opposed to claiming ownership of it).
        Class NHandlebody, NLensSpace:
            - Added != operator to complement the existing == operator.
        Class NInteger, NLargeInteger:
            - Added a floating-point constructor (which truncates).
        Class NIsomorphism:
            - Now just a typedef for the new class Isomorphism<3>, which has
              the same functionality as the old NIsomorphism.
            - New static routine identity().
            - Routine getSourceSimplices() is deprecated, and has been
              replaced with the easier-to-type size().
        Class NIsomorphismDirect:
            - Removed this class, which has been deprecated for some time now.
        Class NLayeredSolidTorus:
            - Renamed getNumberOfTetrahedra() to size().  The old name
              is deprecated but kept for backward compatibility.
        Class NManifold:
            - Renamed first homology routine getHomologyH1() to homology().  In
              addition, homology() has a new alias homologyH1().  The old names
              are kept but deprecated.
        Class NMarkedAbelianGroup:
            - Now supports unicode output via utf8().
            - Added != operator to complement the existing == operator.
        Class NMatrix:
            - The destructor and writeMatrix() are no longer virtual.
            - Now derives from Output, and provides str(), utf8() and detail()
              output routines.
        Class NMutex:
            - Deprecated; just use std::mutex and related classes instead.
        Class NNormalHypersurface, NNormalHypersurfaceList,
                HyperCoords, HyperList, HyperListFlags, HyperAlg, HyperAlgFlags,
                NNormalHypersurfaceVector, NNormalHypersurfaceVectorMirrored,
                NNormalHypersurfaceVectorStandard,
                NXMLNormalHypersurfaceReader, NXMLNormalHypersurfaceListReader:
            - New suite of classes to support normal hypersurfaces in
              4-manifold triangulations.
        Class NNormalSurface:
            - New convenience routines normal() and embedded().
            - Renamed getTriangleCoord(), getQuadCoord(), getOctCoord(),
              getOrientedTriangleCoords(), getOrientedQuadCoord() and
              getTriangleArcs() to triangles(), quads(), octs(),
              orientedTriangles(), orientedQuads() and arcs().
              The old names are kept but deprecated.
        Class NNormalSurfaceList:
            - Renamed getNumberOfSurfaces() to size().  The old name is
              deprecated, but has been kept for backward compatibility.
            - Now uses C++11 std::thread internally instead of the old NThread.
            - Removed the deprecated enumerate(..., bool embeddedOnly, ...),
              since this was (incorrectly) taking precedence over the new
              enumerate() in certain scenarios.  See TODO for details.
        Class NNormalSurfaceSubset:
            - Renamed getNumberOfSurfaces() to size().  The old name is
              deprecated, but has been kept for backward compatibility.
        Class NNormalSurfaceVector:
            - The subclass constant coordType is renamed to coordsID, and is
              now a constant of type NormalCoords, not an anonymous enum type.
              The old name is kept but deprecated.
            - Renamed getTriangleCoord(), getQuadCoord(), getOctCoord() and
              getTriangleArcs() to triangles(), quads(), octs() and arcs().
              The old names are kept but deprecated.
        Class NPacket:
            - Added a variant of save() that takes an output stream (as
              opposed to a filename).
            - New routine adornedLabel() for creating modified packet labels.
            - New routine transferChildren() for bulk tree reorganisation.
            - The subclass constant packetType is renamed to typeID, and is
              now a constant of type PacketType, not an anonymous enum type.
              The old name is kept but deprecated.
            - Renamed getPacketLabel(), setPacketLabel(), getPacketType() and
              getPacketTypeName() to label(), setLabel(), type() and typeName().
              The old names are kept but deprecated.
            - Renamed getTreeParent(), getFirstTreeChild(), getLastTreeChild(),
              getNextTreeSibling(), getPrevTreeSibling() and getMatriarch() to
              parent(), firstChild(), lastChild(), nextSibling(), prevSibling()
              and root() respectively.  The old names are kept but deprecated.
            - Renamed getXMLReader() to xmlReader().  The old name has
              been removed completely.
            - In python, makeOrphan() returns void again, making it consistent
              once more with the C++ API.  Memory leaks are avoided thanks to
              the new safe pointer machinery.
        Class NPacketListener:
            - New events childToBeRenamed(), childWasRenamed().
        Class NPerm:
            - New generic template class for permutations of 2..16 objects.
              The old NPerm3, NPerm4 and NPerm5 classes, as well as a
              new NPerm2 class, are now specialisations of this template.
            - Removed the old deprecated NPerm typedef (this was synonymous
              with NPerm4).
        Class NPerm3, NPerm4, NPerm5:
            - These are now specialisations NPerm<3>, NPerm<4> and NPerm<5>.
              The old names NPerm3, NPerm4 and NPerm5 remain as typedefs.
            - Added a Code typedef for internal permutation codes.
            - New routines atIndex() and index(), for consistency with the
              new NPerm template.
            - Added an Image typedef for use with index() and atIndex().
            - Added imageBits const for NPerm5, in line with the new
              generic NPerm template.
            - The nPerms and nPerms_1 constants are now static const ints,
              not enum constants.
            - New trunc() routine that takes a length argument.
            - New constructors that take two arrays.
            - New static rand() routine for generating a random permutation.
            - New routine reverse() for reversing a permutation.
            - New extend() and contract() routines for converting from
              different sized permutations.
            - Removed deprecated toString() and setPerm() routines.
            - Removed deprecated arrays from NPerm4::invS3 and NPerm4::invS2.
            - Removed deprecated global arrays from nperm4.h, including
              allPermsS{4,3,2}, allPermsS{4,3,2}Inv, and orderedPermsS{4,3}.
            - Removed deprecated global functions from nperm4.h, including
              faceOrdering(), faceDescription(), edgeOrdering(), and
              edgeDescription().
        Class NPolynomial:
            - New class for working with single-variable polynomials
              over arbitrary rings.
        Class NPrismSpec:
            - Added != operator to complement the existing == operator.
        Class NPrismSetSurface:
            - Deprecated this class, which has been little more than a
              placeholder for 12 years.  Also removed its python bindings.
        Class NProgress, NProgressFinished, NProgressManager,
                NProgressMessage, NProgressNumber, NProgressStateNumeric:
            - Removed these old deprecated classes entirely.
        Class NProgressTrackerBase, NProgressTrackerOpen:
            - New classes to support open-ended integer-based progress
              tracking, with no "numerical end point" known in advance.
        Class NRational:
            - The destructor is no longer virtual.
        Class NSatBlock:
            - Classes inheriting from this must now implement writeTextShort,
              and can optionally overwrite the default writeTextLong function.
        Class NSatBlockSpec:
            - Added == and != comparison operators.
        Class NSFSpace, NSFSSpaceFibre:
            - Added != operators to complement the existing == operators.
        Class NSimpleSurfaceBundle, NSnapPeaCensusManifold, NSnapPeaCensusTri:
            - Added != operators to complement the existing == operators.
        Class NSnapPeaCensusManifold:
            - Change the behaviour of == and != to reflect the recent discovery
              that the manifolds x101 and x103 are homeomorphic.  For details,
              see B.B., "A duplicate pair in the SnapPea census",
              Experimental Mathematics, 23:170-173, 2014.
        Class NSnapPeaTriangulation:
            - Updated the SnapPea kernel to the one shipped with SnapPy 2.4
              (standard precision).
            - The definitions of geometric_solution and non_geometric_solution
              have changed (following a similar change in SnapPea): now
              geometric_solution means that all tetrahedra must be positive.
            - Routine fundamentalGroupFilled() has a new boolean argument for
              shortening relations.
        Class NSpiralSolidTorus:
            - Renamed getNumberOfTetrahedra() to size().  The old name
              is deprecated but kept for backward compatibility.
        Class NStandardTriangulation:
            - Renamed first homology routine getHomologyH1() to homology().  In
              addition, homology() has a new alias homologyH1().  The old names
              are kept but deprecated.
        Class NSurfaceFilter:
            - The subclass constant filterType has been renamed to filterTypeID,
              and is now a constant of type SurfaceFilterType, not an
              anonymous enum type.  The old name has been removed completely.
            - Removed the deprecated getFilterID() and getFilterName()
              routines, and the deprecated filterID constants.
        Class NSurfaceFilterProperties:
            - New set-based routine setEulerChars().
            - Renamed getEC(), getECs() and getNumberOfECs() to eulerChar(),
              eulerChars() and countEulerChars().  The old names are kept but
              deprecated.
            - Renamed addEC(), removeEC() and removeAllECs() to addEulerChar(),
              removeEulerChar() and removeAllEulerChars().  The old names are
              kept but deprecated.
        Struct NTetFace:
            - Removed data members tet and face from the python bindings.
              These were already removed from C++ in 2012.
        Class NTetrahedron:
            - Now just a typedef for the new class Simplex<3>, which has
              the same functionality as the old NTetrahedron.
            - New routine facetInMaximalForest(), for examining a
              precomputed maximal forest in the dual 1-skeleton.
            - New dimension-agnostic face<subdim>() and faceMapping<subdim>()
              template functions.
            - Removed the old deprecated public constructors.  The only way
              to construct a new tetrahedron is via the triangulation, using
              NTriangulation::newTetrahedron() or NTriangulation::newSimplex().
            - Removed deprecated routines getAdjacentTetrahedron(),
              getAdjacentTetrahedronGluing(), getAdjacentFace(), getFace()
              and getFaceMapping().
            - You can now safely call unjoin() on a boundary face.
            - Routine joinTo() has been renamed to join().  The old name
              joinTo() has been kept but is now deprecated.
            - Removed the long-deprecated public constructors.  To create new
              tetrahedra, call NTriangulation::newTetrahedron() instead.
        Class NThread:
            - Deprecated; just use std::thread and related classes instead.
        Class NTreeBag, NTreeDecomposition:
            - Classes for computing tree decompositions of graphs
              (including facet pairing graphs of triangulations).
        Class NTriangle, NTriangleEmbedding:
            - Now just typedefs for the new classes Face<3, 2> and
              FaceEmbedding<3, 2>, which have the same functionality as
              the old NTriangle and NTriangleEmbedding respectively.
            - Added a new Type enumeration to NTriangle, which encapsulates
              (and replaces) the old triangle type constants.  Also added a
              new type constant UNKNOWN_TYPE.
            - New routine inMaximalForest() in NTriangle for working with the
              dual 1-skeleton.
            - Added begin(), end(), front() and back() to NTriangle.  In
              particular, this class now supports C++11 range-based for loops.
            - Added getEmbeddings() to NTriangle for Python (but not C++).
            - Changed the ordering[] array to a static ordering() function.
            - New faceNumber() function as an "inverse" for ordering().
            - New containsVertex() function for testing which vertices
              belong to which triangles.
            - New trivial routines isValid() and isLinkOrientable(), for
              consistency with faces in higher dimensions.
            - Removed the old routine getNumberOfEmbeddings(), and replaced
              it with the new (and equivalent) routine getDegree().
        Class NTriangulation:
            - Now just a typedef for the new class Triangulation<3>, which has
              the same functionality as the old NTriangulation.
            - The routine turaevViro() now computes Turaev-Viro invariants
              using exact arithmetic, as elements of a cyclotomic field.  The
              old floating-point routine has been renamed to turaevViroApprox().
            - The second argument to turaevViro() is now a boolean indicating
              the parity of whichRoot, as opposed to the integer whichRoot
              itself (since in cyclotomic fields, this is all that matters).
            - Both turaevViro() and turaevViroApprox() now offer a default
              value for the second argument (whichRoot / parity), and now take
              an optional third argument to specify which algorithm to use.
            - Both turaevViro() and turaevViroApprox() now offer a treewidth-
              based algorithm.  This can be significantly faster than the old
              backtracking algorithm, but also uses significantly more memory.
              They also now offer two variants of the backtracking algorithm,
              differing in if/how arithmetic operations are cached.
            - Removed Turaev-Viro invariants from the XML data file format.
              Any Turaev-Viro invariants contained in older data files
              (which will be floating-point approximations) will be ignored.
            - Removed the optional boolean argument (forceDivision) from
              idealToFinite().
            - New dimension-agnostic function hasBoundaryFacets().
            - New dimension-agnostic face<subdim>() and faces<subdim>()
              template functions.
            - New routine fVector().
            - New routine niceTreeDecomposition() for constructing and
              caching a nice tree decomposition of the face pairing graph.
            - New routines retriangulate() and simplifyExhaustive() for
              breadth-first searching through the Pachner graph.
            - Reconstruction from isomorphism signatures now allows
              leading and/or trailing whitespace.
            - Routine getNumberOfSimplices() has been renamed to size().
              The old names is deprecated but kept for backward compatibility.
            - Routines findAllIsomorphisms() and findAllSubcomplexesIn() now
              take an arbitrary output iterator, instead of the user passing a
              std::list to fill with results.
            - Routines getVertices(), getEdges() and getTriangles() no
              longer return a reference to a std::vector.  Instead they return
              a FaceList structure, which also supports C++11 range-based for
              loops and operator [] (amongst other things).
            - Routine finiteToIdeal() now inserts its new tetrahedra in
              a different order (though the isomorphism type of the resulting
              triangulation has not changed).
            - Routines simplexIndex(), vertexIndex(), edgeIndex(),
              triangleIndex(), tetrahedronIndex(), componentIndex() and
              boundaryComponentIndex() are all deprecated.  Just call
              NVertex::index() and so on instead.
            - Renamed first homology routines getHomologyH1(),
              getHomologyH1Rel() and getHomologyH1Bdry() to homology(),
              homologyRel() and homologyBdry(), and renamed second homology
              routines getHomologyH2() and getHomologyH2Z2() to homologyH2()
              and homologyH2Z2().  In addition, homology() has a new
              alias homologyH1().  The old names are kept but deprecated.
            - Removed deprecated routines addTetrahedron() and
              gluingsHaveChanged().
            - Removed maximalForestInDualSkeleton().  Just use
              NTriangle::inMaximalForest() instead.
            - Removed getEulerCharacteristic(), which was deprecated
              years ago to clarify the ambiguity in how it was computed.
            - New dimension-agnostic routine countBoundaryFacets().
            - Removed 2-face members FaceIterator, faceIndex(), getFace(),
              getFaces(), getNumberOfFaces() and hasBoundaryFaces(), all of
              which were deprecated.  Instead use the names that replace
              "face" with "triangle".
            - In python, simplifiedFundamentalGroup() now clones its argument
              (as opposed to claiming ownership of it).
        Class NVertex:
            - Now just typedefs for the new classes Face<3, 0> and
              FaceEmbedding<3, 0>, which have the same functionality as
              the old NVertex and NVertexEmbedding respectively.
            - Added a new LinkType enumeration to NVertex, which encapsulates
              (and replaces) the old link type constants.
            - Added begin(), end(), front() and back() to NVertex.  In
              particular, this class now supports C++11 range-based for loops.
            - New routines ordering(), faceNumber() and containsVertex(), for
              consistency with higher-dimensional faces.
            - The link constant NON_STANDARD_BDRY has been renamed to INVALID.
              The old name has been kept but is now deprecated.
            - New routine isValid(), which is equivalent to testing whether
              getLink() == INVALID.
            - Removed getEmbeddings() for C++, but kept it for Python.
            - Removed the old routine getNumberOfEmbeddings().  Just use
              the equivalent routine getDegree() instead.
        Class NXML...:
            - Renamed routines of the form getFoo() to foo() across all of
              these internal XML I/O classes, removing the old names completely.
            - NXMLDim2TriangulationReader and NXMLTriangulationReader are now
              just typedefs for the new class XMLTriangulationReader<dim>.
        Class Output, ShortOutput, OutputBase:
            - New classes that provide consistent APIs for objects to provide
              short and detailed string output.  These have been introduced as
              lightweight replacements for the now-defunct ShareableObject.
            - These new classes also provide an output operator << that allows
              any object derived from Output to be written to an output stream,
              as well as a new utf8() function that allows classes to provide
              optional support for richer unicode output.
        Class ReturnsTraits:
            - Helper class for compile-time analysis of function objects.
        Class SafePtr, SafePointeeBase, SafeRemnant:
            - New classes that provide a smart pointer that can never be
              dangling.  SafePtr and SafePointeeBase are the end-user classes;
              SafeRemnant provides implementation details.
        Class ShareableObject:
            - Removed entirely.  This is no longer needed as a base class for
              objects that are mirrored in external interfaces (e.g., python).
            - The output routines str() and detail(), as well as a new output
              routine utf8(), are provided by the Output template class instead.
        Class Simplex, SimplexBase, SimplexFaces, SimplexFacesSuite:
            - Simplex<dim> is now a generic class that replaces the old
              Dim2Triangle, NTetrahedron and so on.  SimplexBase<...>,
              SimplexFaces<...> and SimplexFacesSuite<...> are base classes
              with functionality common to all dimensions, whereas Simplex<dim>
              is specialised for dimensions 2, 3 and 4.
            - The old class names Dim2Triangle and NTetrahedron have
              been kept as typedefs for convenience.
        Class Triangulation, TriangulationBase, FaceList, FaceListSuite:
            - Triangulation<dim> is now a generic subclass of NPacket that
              replaces the old Dim2Triangulation, NTriangulation, etc.
              TriangulationBase<...>, FaceList<...> and FaceListSuite<...>
              are base classes with functionality common to all dimensions,
              whereas Triangulation<dim> is specialised for dimensions 2, 3, 4.
            - The old class names Dim2Triangulation and NTriangulation have
              been kept as typedefs for convenience.
        Class XMLTriangulationReader, XMLTriangulationReaderBase,
                XMLTriangulationTags, XMLSimplexReader, XMLSimplicesReader:
            - XMLTriangulationReader<dim> is now a generic class that replaces
              the old NXMLDim2TriangulationReader and NXMLTriangulationReader.
              XMLTriangulationReaderBase<...>, XMLTriangulationTags<...>,
              XMLSimplexReader<...> and XMLSimplicesReader<...> provide the
              implementation details, including functionality common to all
              dimensions, and XMLTriangulationReader<dim> itself is
              specialised for dimensions 2, 3 and 4.
            - The old class names NXMLDim2TriangulationReader and
              NXMLTriangulationReader have been kept as typedefs.
        Routine binomSmall():
            - New constant-time routine to compute (n choose k) for small n.
        Routine bitsRequired():
            - New constexpr routine for counting bits in an integer.
        Routine digit():
            - New constexpr routine for converting integers into characters.
        Routine factorial():
            - New constexpr routine for computing factorials.
        Routine forCoords(), forFilter(), forPacket():
            - Removed the initial Coords / Filter / PacketType argument,
              which was only used to convey type information and never
              contained any real data.
            - Now supports additional trailing arguments, which are
              passed through to the bracket operator.
            - The void / non-void variants now require that the function
              object must / must not be derived from Returns<T> respectively.
        Routine hasInt128():
            - New routine for runtime queries on whether native 128-bit
              arithmetic is available.
        Routine makeAngleEquations():
            - Added as a global routine so that Python users can access it.
              This is identical to NAngleStructureVector::makeAngleEquations().
        Routine nextPowerOfTwo():
            - New constexpr routine for rounding up to a power of two.
        Routine open():
            - Added a variant that takes an input stream (as opposed to
              a filename).
        Routine perm3to4(), perm3to5(), perm4to5():
            - Deprecated.  Use the new routines NPerm<n>::extend() instead.
        Routine perm4to3(), perm5to3(), perm5to4():
            - Deprecated.  Use the new routines NPerm<n>::contract() instead.
        Routine readIsoSigList():
            - Now supports both 3-manifold and 4-manifold triangulations.
        Routine subscript(), superscript():
            - New routines that convert integers to UTF-8 subscript and
              superscript strings.
        Routine valueOf():
            - Now overloaded to support 8-bit, short and long long integers.
        Routine versionSnapPy(), versionSnapPea():
            - New routine for runtime queries on the version of the bundled
              SnapPea kernel.
        Global arrays edgeNumber[][], edgeStart[], edgeEnd[]:
            - This long-deprecated global arrays have now been removed, and
              the corresponding static arrays in NEdge are now deprecated.
              Instead, use NEdge::edgeNumber[][] and/or NEdge::edgeVertex[][].
        Global arrays vertexSplit...:
            - Renamed global arrays vertexSplit[][], vertexSplitMeeting[][][],
              vertexSplitPartner[][], vertexSplitString[][] to quadSeparating,
              quadMeeting, quadPartner, quadString respectively.  The old
              names are kept but deprecated.
            - Deprecated array vertexSplitDefn[][].  Simply use
              NEdge::ordering() instead (with the caveat that NEdge::ordering()
              might switch the images of 2 and 3).
        Header dim2edgepairing.h, nfacepairing.h:
            - Relocated from census/ into dim2/ and triangulation/ respectively.
              Deprecated headers have been kept in the old census/ folder.
        Header dimtraits.h:
            - Deprecated, since this header is now empty.
        Header nfacetspec.h:
            - Renamed to facetspec.h.  The old header is kept but deprecated.
        Header ngenericfacetpairing.h, ngenericfacetpairing-impl.h:
            - Moved to generic/facetpairing.h and generic/facetpairing-impl.h.
              The old headers are kept but deprecated.
        Header nperm.h:
            - Removed this deprecated header from the triangulation/ directory.
        Header zstream.h:
            - Removed entirely.  Regina now uses boost::iostreams instead.
        Macro INT128_AVAILABLE, INT128_T_FOUND, __INT128_T_FOUND:
            - Both INT128_T_FOUND and __INT128_T_FOUND are now internal,
              and should not be used by end users.
            - The macro INT128_AVAILABLE has been moved from regina-config.h
              into intutils.h, and it is now an explicit requirement that any
              128-bit arithmetic must use the typedefs from IntOfSize<16>.
            - A new cmake option USE_BOOST_INT128 allows users to override
              cmake's 128-bit integer detection, and instead use boost's
              compile-time detection.
        Macro REGINA_INLINE_REQUIRED:
            - New macro to help reduce noisy warnings under windows.
    USER INTERFACE:
        - Now builds against Qt5, not Qt4.
        - Supports hi-resolution (e.g., retina) displays.
        - Removed the old and increasingly poorly supported option of
          docking packets into the main window.
        - Drilling an edge now creates a new triangulation, as opposed
          to modifying the current triangulation.
        - Puncturing a triangulation, making it ideal or truncating ideal
          vertices now automatically simplify the resulting triangulation.
        - Removed some of the more exotic 3-D triangulation constructions.
        - Now links against Graphviz instead of running it externally.
    UTILITIES:
        tricensus, tricensus-mpi:
            - Can now run a census of 4-manifold triangulations (rather than
              3-manifold triangulations) by passing the argument -4 / --dim4.
        trisetcmp:
            - Now runs through both 3-manifold and 4-manifold triangulations.
              However, subcomplexes must be of the same dimension (i.e.,
              it does not identify when a 3-manifold triangulation
              appears as a subcomplex of a 4-manifold triangulation).
    PYTHON:
        - No longer clobbers Python's own builtin open() function in the
          global namespace.  You can still access Regina's open() function
          by calling regina.open().
        - For all classes, writeTextShort() and writeTextLong() are no
          longer exposed to Python.  Simply use str() and detail() instead.
        - The behaviour of == and != under python has been formalised.
          For those classes that have == and != operators in C++, the
          python == and != operators compare by value (i.e., they call the
          C++ operators).  For those classes that have neither == nor != in
          C++, the python == and != operators compare by reference.
          Every wrapped C++ class has an equalityType attribute in
          python to indicate which behaviour it uses.
          Thanks to Matthias Goerner for his help with this.
        - Memory management for packets is now more sensible - in particular,
          when one packet is inserted beneath another the python reference
          is no longer invalidated.  Thanks again to Matthias Goerner.

Version 4.96  [ 29 August, 2014 ]

    ENGINE:
        Class BanConstraintBase (and subclasses):
            - Extended the tree traversal / linear programming machinery to
              work with angle structures.  This is used for enumerating all
              taut angle structures, or finding a single strict angle structure.
        Class Dim2BoundaryComponent:
            - New convenience routine getComponent().
            - New routine index().
        Class Dim2Census:
            - Routines formCensus() and formPartialCensus() and the typedef
              AcceptTriangulation are now deprecated.  To build a census
              you should call Dim2EdgePairing::findAllPairings() and
              Dim2GluingPermSearcher::findAllPerms() directly.
        Class Dim2Component:
            - New routine getNumberOfBoundaryEdges().
            - New routine index().
        Class Dim2Edge:
            - New routine index().
        Class Dim2EdgeEmbedding:
            - New convenience operators == and !=.
        Class Dim2Triangle:
            - New routine index().
        Class Dim2Triangulation:
            - New routine isIdenticalTo().
            - New local modification oneThreeMove().
            - New routine findAllIsomorphisms().
            - New routine isEmpty().
            - Several isomorphism-related routines have been moved into
              the dimension-agnostic NGenericTriangulation template, and
              isomorphism signature routines now inherit directly from
              NGenericTriangulation instead of using wrappers.
              See the NGenericTriangulation notes below for details.
            - New routines getNumberOfBoundaryEdges() and hasBoundaryEdges().
              The latter is redundant, but is provided for compatibility with
              NTriangulation.
        Class Dim2Vertex:
            - New routine index().
        Class Dim2VertexEmbedding:
            - New convenience operators == and !=.
        Class LPConstraintBase (and subclasses), LPData, LPInitialTableaux,
              LPMatrix:
            - Extended the tree traversal / linear programming machinery to
              work with angle structures.  This is used for enumerating all
              taut angle structures, or finding a single strict angle structure.
        Class NAbelianGroup:
            - New convenience operator !=.
        Class NAngleStructure:
            - New convenience routine rawVector().
            - Routine getTriangulation() now returns a const NTriangulation*
              (previously this was non-const).  Likewise, many routines in
              this and related classes have NTriangulation* arguments changed
              from non-const to const.
        Class NAngleStructureList:
            - Enumeration of taut angle strutures now uses Regina's tree
              traversal / linear programming machinery, which is *much*
              faster than the old double description method.
            - The new routine enumerateTautDD() allows users to access the
              older (and much slower) double description method if required.
        Class NAngleStructureVector:
            - New routine makeAngleEquations() to build the angle structure
              equations independently of an angle structure list.
        Class NBoundaryComponent:
            - New convenience routine getComponent().
            - New routine index().
            - Renamed getEulerCharacteristic() to getEulerChar(), which
              is easier on the fingers.  The old name has been kept as a
              deprecated alias for backward compatibility.
        Class NCensus:
            - New routine lookup() (in two variants) to quickly search for a
              given triangulation in Regina's various census databases.
              The databases themselves are now installed alongside the
              mathematical engine, and are much larger and richer than before.
            - Routine mightBeMinimal() is deprecated; you should call
              NTriangulation::simplifyToLocalMinimum(false) instead.
            - Routines formCensus() and formPartialCensus() and the typedef
              AcceptTriangulation are now deprecated.  To build a census
              you should call NFacePairing::findAllPairings() and
              NGluingPermSearcher::findAllPerms() directly.
            - The PURGE_... constants have been moved to the
              NGluingPermSearcher class.  The old flags in NCensus
              are deprecated, but have been kept for backward compatibility.
        Class NCensusDB, NCensusHit, NCensusHits:
            - New classes to support the new NCensus::lookup() routines.
        Class NComponent:
            - New routine getNumberOfBoundaryTriangles().
            - New routine index().
        Class NCusp:
            - New class to support NSnapPeaTriangulation.
        Class NEdge:
            - New routine index().
        Class NExampleTriangulation:
            - New example trefoilKnotComplement().
            - New example sphere600() (sourced from the 600-cell in the
              Benedetti-Lutz library of triangulations).
        Class NGenericTriangulation:
            - Moved isIdenticalTo(), isIsomorphicTo(), isContainedIn(),
              findAllSubcomplexesIn() and makeCanonical() from
              Dim2Triangulation and NTriangulation into this class.
            - New routine findAllIsomorphisms().
            - New routine isEmpty().
            - Made isoSig(), fromIsoSig() and isoSigComponentSize() public.
        Class NGluingPermSearcher:
            - New PurgeFlags enumeration, which is the new home for the
              PURGE_... constants that used to live in the NCensus class.
              This enumeration also contains new flags PURGE_NON_MINIMAL_HYP
              (for use in building a census of cusped finite volume hyperbolic
              3-manifolds), and PURGE_NONE.
            - Removed protected routine mayPurge(), since this behaviour is
              already provided by specialised subclasses of NGluingPermSearcher.
        Class NHyperbolicMinSearcher:
            - New enumeration class for building a census of minimal ideal
              triangulations of cusped finite-volume hyperbolic 3-manifolds.
        Class NManifold:
            - New routine isHyperbolic().
        Class NNormalSurface:
            - Renamed boundarySlopes() to boundaryIntersections(), to make it
              clear that it returns algebraic intersection numbers and not the
              usual (m, l) pairs.  The old name has *not* been deprecated,
              but removed completely.
            - Furthermore, boundaryIntersections() now requires the underlying
              triangulation to be of type NSnapPeaTriangulation, and it takes
              the meridian and longitude directly from the SnapPea kernel.
              It also now orders its rows by SnapPea cusp indices (not Regina's
              vertex indices); this is identical to past behaviour, but now
              that SnapPea triangulations can be modified through the SnapPea
              kernel, it is possible for the numbering schemes to differ
              and so this distinction now matters.
            - Renamed getEulerCharacteristic() to getEulerChar(), which
              is easier on the fingers.  The old name has been kept as a
              deprecated alias for backward compatibility.
            - Renamed the protected routine calculateEulerCharacteristic() to
              calculateEulerChar().
            - Routine getTriangulation() now returns a const NTriangulation*
              (previously this was non-const).  Likewise, many routines in
              this and related classes have NTriangulation* arguments changed
              from non-const to const.
        Class NNormalSurfaceList:
            - New routines saveCSVStandard() and saveCSVEdgeWeight().
              These are now the preferred ways of exporting a normal surface
              list to CSV format.
            - Many routines in this and related classes have NTriangulation*
              arguments changed from non-const to const.  This also applies to
              related global routines, such as makeMatchingEquations().
        Enum NormalCoords:
            - New coordinate system NS_ANGLE for use with angle structures.
        Class NPacket:
            - New routine save(), which is now the preferred way of saving
              Regina data files.
        Class NPDF:
            - New constructor that reads a PDF document from a given file.
            - New routine isNull() to test if a PDF document is stored.
            - New routine savePDF(), which is now the preferred way of
              exporting a PDF packet to a PDF file.
        Class NPerm3, NPerm4, NPerm5:
            - New dimension-agnostic alias invSn.
            - Changed the type of NPerm3::invS3 from int to unsigned,
              for consistenty with NPerm4 and NPerm5.
        Class NScript:
            - Scripts are now stored as complete strings, not sequences
              of individual lines.  This affects the member functions
              (see below) and also the XML file format.  Whilst Regina
              has removed much of the functionality for working line-by-line,
              it can still read older files that were stored that way.
            - A script now fires a change event if one of its variables
              changes its packet label.
            - New routines getText(), setText() and append().
            - New routine getVariableIndex(), setVariableName(),
              setVariableValue() and removeVariable(unsigned long).
            - Removed routines getLine(), getNumberOfLines(), addFirst(),
              addLast(), insertAtPosition(), replaceAtPosition(),
              removeLineAt(), and removeAllLines().  These are not deprecated,
              but removed entirely.
        Class NSnapPeaTriangulation:
            - Updated the SnapPea kernel to the one shipped with SnapPy 2.2
              (standard precision).
            - NSnapPeaTriangulation is now a fully-fledged packet type, and
              derives from NTriangulation.  The inherited NTriangulation
              must not be modified directly; instead this is automatically
              kept in sync with the SnapPea data.
            - Closed triangulations are now supported always by default
              (i.e., you do not need to explicitly pass allowClosed=true).
              The second argument (allowClosed) for the constructor
              NSnapPeaTriangulation(const NTriangulation&, bool) is
              deprecated, and is now ignored.
            - Many new routines: countCompleteCusps(), countCusps(),
              countFilledCusps(), cusp(), fill(), filledTriangulation(),
              fundamentalGroupFilled(), gluingEquations(),
              gluingEquationsRect(), homologyFilled(), minImaginaryShape(),
              name(), protoCanonize() and protoCanonise(), shape(), unfill(),
              volumeZero(), plus others (listed individually below).
            - Two new constructors: a default constructor that builds a null
              triangulation, and a string constructor that takes either the
              name or the contents of a native SnapPea data file.
            - The Regina-to-SnapPea constructor now doubles as another copy
              constructor: which behaviour you get now depends on whether
              you pass an object of Regina's own NTriangulation type or
              of the subclass NSnapPeaTriangulation.
            - If one of Regina's own NTriangulation objects is passed to
              the constructor, then the constructor now installs the (shortest,
              second-shortest) curves on each cusp as its (meridian, longitude)
              basis.  This reverts a change in behaviour from the previous
              release caused by the recent sync with the SnapPy 2.0.3 kernel.
            - New output routines snapPea() and saveSnapPea().  These override
              the "lossy" conversion routines NTriangulation::snapPea() and
              NTriangulation::saveSnapPea() so that they output all
              SnapPea-specific data.
            - Renamed saveAsSnapPea() to saveSnapPea() (see above).  The new
              routine now returns a boolean, and requires a non-empty filename.
              The old name is deprecated but kept for backward compatibility.
            - Routine dump() is deprecated.  Instead, simply call snapPea() and
              write the resulting string to standard output.
            - Added synonym canonise() for canonize().
            - Routine solutionType() now returns the filled solution type
              (not the complete solution type).
            - Routine slopeEquations() now orders rows by SnapPea cusp indices
              (not Regina's vertex indices).  This is identical to past
              behaviour, but now that SnapPea triangulations can be modified
              through the SnapPea kernel, it is possible for the numbering
              schemes to differ and so this distinction now matters.
            - Routines toRegina() and verifyTriangulation() are deprecated,
              since they are obsolete now that NSnapPeaTriangulation inherits
              from NTriangulation.
            - The entire SnapPea kernel now lives within the namespace
              regina::snappea, which should ensure safety even if a
              conflicting SnapPy kernel is simultaneously loaded via Python.
              The SnapPea kernel is also linked as C++ now (no 'extern "C"').
            - Fatal errors in the SnapPea kernel are now handled by throwing
              exceptions, instead of quitting abruptly.
        Class NTautEnumeration:
            - New class for enumerating taut angle structures that uses
              Regina's tree traversal / linear programming machinery.
              This is *much* faster than the old double description method.
        Class NTetrahedron:
            - New routine index().
        Class NTreeTraversal:
            - Extended the tree traversal / linear programming machinery to
              work with angle structures.  This is used for enumerating all
              taut angle structures, or finding a single strict angle structure.
            - Changed all NTriangulation types in this and related
              classes from non-const to const.
        Class NTriangle:
            - New routine index().
        Class NTriangleEmbedding:
            - New convenience operators == and !=.
        Class NTriangulation:
            - New routines hasStrictAngleStructure(),
              findStrictAngleStructure() and knowsStrictAngleStructure(),
              which use fast linear programming machinery.
            - Routine connectedSumDecomposition() now works for non-orientable
              triangulations also (arXiv:1212.1441).  There is a caveat if
              there are embedded two-sided projective planes (see the
              documentation for details), and so the return type is now a
              signed long to allow for error conditions to be returned.
            - New routine connectedSumWith() for building connected sums.
            - New routine isIdenticalTo().
            - New routine isEmpty().
            - New local modification oneFourMove().
            - New routines findAllIsomorphisms() and makeCanonical().
            - Several isomorphism-related routines have been moved into
              the dimension-agnostic NGenericTriangulation template, and
              isomorphism signature routines now inherit directly from
              NGenericTriangulation instead of using wrappers.
              See the NGenericTriangulation notes above for details.
            - New routine getNumberOfBoundaryTriangles().
            - New routine puncture().
            - New routines snapPea(std::ostream&) and saveSnapPea().
              These (and the existing snapPea()) are now the preferred ways
              of exporting an NTriangulation to SnapPea's native file format.
            - New routines recogniser(), recogniser(std::ostream&),
              saveRecogniser(), plus US-spelled variants recognizer(), etc.
              These are now the preferred ways of exporting data for
              Matveev's 3-manifold recogniser.
            - Routines snapPea() and saveSnapPea() now do nothing if the
              triangulation is empty.
        Class NVertex:
            - Renamed getLinkEulerCharacteristic() to getLinkEulerChar(), which
              is easier on the fingers.  The old name has been kept as a
              deprecated alias for backward compatibility.
            - New routine index().
        Class NVertexEmbedding:
            - New convenience operators == and !=.
        Class NXMLSnapPeaReader:
            - New I/O class for the new SnapPea triangulation packet type.
        Class SnapPeaException, SnapPeaFatalError, SnapPeaMemoryFull:
            - New exceptions to be thrown by the SnapPea kernel.
        Enum SurfaceExportFields:
            - Moved from foreign/csvsurfacelist.h to
              surfaces/nnormalsurfacelist.h.
        Routine open():
            - New routine which is now the preferred way to read a
              native Regina data file.
        Routine readFileMagic(), readXMLFile():
            - Renamed to regina::open(), and now declared in npacket.h.
              The old names are deprecated but kept for backward compatibility.
        Routine readPDF():
            - Deprecated, in favour of the new filename-based NPDF constructor.
            - Explicitly return 0 if the given file exists but is empty.
        Routine readSnapPea():
            - Both variants of this routine are now deprecated, in favour of the
              new NSnapPeaTriangulation constructor which preserves additional
              SnapPea-specific data.  The old routines have been kept for
              backward compatibility, and (unlike the new routines) retain
              their old "lossy" behaviour (i.e., returning an NTriangulation
              that drops any SnapPea-specific data, such as peripheral curves).
        Routine writeCSVStandard(), writeCSVEdgeWeight():
            - Renamed to NNormalSurfaceList::saveCSVStandard() and
              NNormalSurfaceList::saveCSVEdgeWeight().  The old names
              are deprecated but have been kept for backward compatibility.
        Routine writePDF():
            - Renamed to NPDF::savePDF().  The old name is deprecated but has
              been kept for backward compatibility.  The new NPDF::savePDF()
              has a slight change in behaviour: if the PDF packet contains
              no data then the old routine created an empty file and returned
              true, whereas the new routine does nothing and returns false.
        Routine writeRecogniser(), writeRecognizer():
            - Renamed to NTriangulation::saveRecogniser() / saveRecognizer().
              The old names are deprecated but kept for backward compatibility.
              The new versions have a change in behaviour, in that they now
              require a non-empty filename (the old behaviour can be recreated
              by calling NTriangulation::recogniser() instead).
        Routine writeSnapPea():
            - The two variants of this routine have been renamed as
              NTriangulation::snapPea(std::ostream&) and
              NTriangulation::saveSnapPea(const char*).  The old names
              are deprecated but have been kept for backward compatibility.
        Routine writeXMLFile():
            - Renamed to NPacket::save().  The old name is deprecated but
              has been kept for backward compatibility.
        Header csvsurfacelist.h:
            - Deprecated.  The declaration of SurfaceExportFields is now
              in surfaces/nnormalsurfacelist.h instead.  The old header
              now includes surfaces/nnormalsurfacelist.h automatically.
        Header nxmlcallback.h, nxmlelementreader.h:
            - Moved from file/ into utilities/.  The old headers have
              been kept for backward compatibility.
        Header permconv.h:
            - New conversion routines perm3to5() and perm5to3().
    USER INTERFACE:
        - The commit/refresh buttons are gone: changes are now committed
          automatically.
        - Many other changes that implement the engine updates listed above.
    UTILITIES:
        censuslookup:
            - New command-line utility for looking up triangulations in
              Regina's census databases.
        tricensus:
            - New argument -h/--minhyp for enumerating minimal ideal
              triangulations of cusped finite-volume hyperbolic 3-manifolds.
    TEST SUITE:
        - The test suite will no longer be covered by this changelog, since
          changes to the test suite have not been logged thoroughly for some
          years now (i.e., releases typically have many more new tests than are
          being listed here).  If you ever want to see what is currently
          covered by the test suite, you can always run "make test ARGS=-V"
          and watch the tests scroll by.

Version 4.95  [ 12 November, 2013 ]

    GENERAL:
        - Updated the bundled copy of Normaliz to version 2.10.1 (27 June 2013).
        - All 2-faces of a triangulation are now called "triangles" (not
          just "faces" as before).  This is to avoid ambiguity in dimension.
        - Regina and SnapPy can now talk directly via python: on many
          systems, 'import snappy' from either a GUI python console or
          the command-line regina-python tool should work out of the box.
        - Packets in a data file are no longer required to have unique labels.
    ENGINE:
        Class Dim2BoundaryComponent:
            - Detailed string output (via detail() / toStringLong()) now
              outputs details of the constituent edges.
        Class Dim2Component:
            - New routines getNumberOfSimplices() and getSimplex(), which are
              dimension-agnostic aliases for getNumberOfTriangles() and
              getTriangle().
            - New template routine getNumberOfFaces<dim>(), which is a
              dimension-agnostic routine for counting faces of any dimension.
            - Detailed string output (via detail() / toStringLong()) now
              outputs details of the constituent triangles.
        Class Dim2Edge:
            - Detailed string output (via detail() / toStringLong()) now
              outputs details of where the edge appears in each triangle.
        Class Dim2Triangulation:
            - Now inherits from the new helper class NGenericTriangulation<2>.
            - New routine isoSigComponentSize() for extracting the number of
              triangles from a signature (inherited from NGenericTriangulation).
            - New "magic constructor" that attempts to interpret a given
              string as a 2-manifold triangulation under several possible
              encodings (currently only isomorphism signatures are supported
              for 2-manifolds, but this list may grow in the future).
            - Routine isoSig() now takes an optional argument that returns
              the isomorphism with the reconstruction from fromIsoSig().
        Class Dim2Vertex:
            - Detailed string output (via detail() / toStringLong()) now
              outputs details of where the vertex appears in each triangle.
        Class NBoundaryComponent:
            - Renamed getFace() and getNumberOfFaces() to getTriangle()
              and getNumberOfTriangles().  The old names are deprecated but
              have been kept for backward compatibility.
            - Detailed string output (via detail() / toStringLong()) now
              outputs details of the constituent triangles or vertex.
        Class NComponent:
            - Renamed getFace() and getNumberOfFaces() to getTriangle()
              and getNumberOfTriangles().  The old names are deprecated but
              have been kept for backward compatibility.
            - Detailed string output (via detail() / toStringLong()) now
              outputs details of the constituent tetrahedra.
        Class NEdge:
            - Detailed string output (via detail() / toStringLong()) now
              outputs details of where the edge appears in each tetrahedron.
        Class NEulerSearcher:
            - A new subclass of NGluingPermSearcher that can enforce an
              arbitrary fixed Euler characteristic on the vertex links.
        Struct NewNormalSurfaceVector:
            - Moved into registryutils.h and redesigned as the more general
              template struct NewFunction1<>.  The old type is equivalent to
              NewFunction1<NNormalSurfaceVector, size_t>, and a deprecated
              typedef has been kept for backward compatibility.
        Class NExampleTriangulation:
            - Routines weberSeifert() / seifertWeber(), bingsHouse(), weeks()
              and poincareHomologySphere() all now build oriented
              triangulations.
        Class NFace:
            - Renamed to NTriangle.  The old name is deprecated but has
              been kept as a typedef for backward compatibility.
        Class NFaceEmbedding:
            - Renamed the class to NTriangleEmbedding, and renamed getFace()
              to getTriangle().  The old names are deprecated but have been
              kept for backward compatibility.
        Class NGenericFacetPairing:
            - Renamed toString() to the simpler-to-type str().  The old name
              has been kept as a deprecated alias.
        Class NGenericTriangulation:
            - New template helper class that allows different triangulation
              classes to share the same implementations of member functions.
              Currently this class implements isoSig() and fromIsoSig().
        Class NGlobalDirs:
            - Routine pythonModule() now returns an empty string if the
              module is installed in the standard python site-packages
              directory (now the default for an XDG install).
        Class NGroupPresentation:
            - Renamed toStringCompact() to compact().  The old name has
              been kept as a deprecated alias.
        Class NInteger, NLargeInteger:
            - Fixed a (thankfully hard-to-trigger) error in the mod operators.
              The error was triggered on (x % m) or (x %= m) when:
              (i) x was negative and stored as a native integer;
              (ii) m could fit into a native integer but was unnecessarily
              stored as a large GMP integer; (iii) x <= m < |x|.  The result
              was then reported as x (i.e., the mod operation did nothing).
            - Fixed a (thankfully even-harder-to-trigger) error in
              the GCD operation.  This error was triggered only when
              computing gcd(LONG_MIN, 0), for either order of the operands.
        Class NNormalSurface, NNormalSurfaceVector:
            - Renamed getFaceArcs() to getTriangleArcs().  The old name is
              deprecated but has been kept for backward compatibility.
            - Incorporated the new fast branch-and-bound machinery into
              NNormalSurface::isIncompressible().
            - All normal surface vector classes have now gained the enum
              constant coordType (representing the corresponding NormalCoords
              constant), and the typedef Info (representing the
              template specialisation NormalInfo<coordType>).
            - The requirements for new vector subclasses have changed, since the
              old macro-based registry was replaced with the new template-based
              registry.  See the NNormalSurfaceVector class notes for details.
            - Python users can now create a normal surface by hand, e.g.,:
              NNormalSurface(tri, NS_STANDARD, [ 1, 2, 0, ... ]).
        Class NNormalSurfaceList:
            - Re-enabled enumeration using NS_HILBERT_FULLCONE, which previously
              returned an empty list.  Users will not be affected unless
              they were explicitly asking for this much slower algorithm.
            - Routine flavour() has been renamed to coords().  The old
              name remains for now as a deprecated alias.
        Class NNormalSurfaceSubset:
            - Routine getFlavour() has been renamed to coords().  The old
              name remains for now as a deprecated alias.
        Enum NormalCoords:
            - Renamed NS_FACE_ARCS to NS_TRIANGLE_ARCS.  The old name is
              deprecated but has been kept for backward compatibility.
        Class NormalFlavour<...>, NormalInfo<...>:
            - This recently-added registry helper template has changed since
              the last release.  Since this is a very new class whose primary
              role is in the redesign of the coordinate system registry,
              no backward compatibility aliases are provided.
            - The template itself has been renamed from NormalFlavour<...>
              to NormalInfo<...>.
            - The declaration has moved from flavourregistry.h to
              normalsurface.h, and the specialisations have moved to the
              corresponding coordinate system headers (nsstandard.h and so on).
            - The typedefs Vector, StandardFlavour and ReducedFlavour
              have been renamed to Class, Standard and Reduced.
        Class NPacket:
            - The requirements for new subclasses have changed, since the old
              macro-based registery was replaced with the new template-based
              registry.  See the NPacket class notes for details.
            - The constant packetType is now a compile-time enum constant,
              not a static const int.
            - The new routine getHumanLabel() returns the packet label,
              but adjusted for human-readable output.  In particular, an
              empty label will be replaced by "(no label)".
            - Routine getFullName() now makes labels more suitable for
              human-readable output as described above.
            - New routine internalID() to produce a string that uniquely
              identifies the packet (which nowadays the packet label does not).
        Class NPerm3, NPerm4, NPerm5:
            - New dimension-agnostic aliases orderedSn, SnIndex() and
              orderedSnIndex().  These all reference existing arrays/routines
              involving S3, S4 or S5 in NPerm3, NPerm4 and NPerm5 respectively.
            - Renamed toString() to the simper-to-type str().  The old name
              has been kept as a deprecated alias.
        Class NPillowTwoSphere:
            - Renamed getFace() and getFaceMapping() to getTriangle()
              and getTriangleMapping().  The old names are deprecated but
              have been kept for backward compatibility.
        Class NScript:
            - Variables are now stored as pointers to packets, not string-based
              packet labels.  This affects the API (in a non-backward-
              compatible way), the behaviour (e.g., renaming a packet will
              not affect any script variable that references it), and the
              data file format (packets now have IDs that scripts can use to
              reference them).
        Class NSnapPeaTriangulation:
            - Updated the SnapPea kernel to the one shipped with SnapPy 2.0.3.
            - New routines randomize() / randomise() to randomly retriangulate.
        Class NSurfaceFilter:
            - The requirements for new subclasses have changed, since the old
              macro-based registry was replaced with the new template-based
              registry.  See the NSurfaceFilter class notes for details.
            - The constant filterID has been renamed to filterType, and
              is now a compile-time enum constant (not a static const int).
              The old name has been kept as a deprecated alias.
            - Routines getFilterID() and getFilterName() have been renamed
              to getFilterType() and getFilterTypeName().  The old names
              have been kept as deprecated aliases.
        Class NTetrahedron:
            - Renamed getFace() and getFaceMapping() to getTriangle()
              and getTriangleMapping().  The old names are deprecated but
              have been kept for backward compatibility.
        Class NThread:
            - New routine join() to wait for threads to finish.
        Class NTriangle:
            - Detailed string output (via detail() / toStringLong()) now
              outputs details of where the triangle appears in each tetrahedron.
        Class NTriangulation:
            - New routines isIrreducible(), knowsIrreducible(),
              isHaken(), knowsHaken(), and knowsCompressingDisc().
            - Routine hasCompressingDisc() has been updated to use the new
              fast branch-and-bound machinery.
            - New routines getNumberOfSimplices() and getSimplex(), which are
              dimension-agnostic aliases for getNumberOfTetrahedra() and
              getTetrahedron().
            - New template routine getNumberOfFaces<dim>(), which is a
              dimension-agnostic routine for counting faces of any dimension.
            - Now inherits from the new helper class NGenericTriangulation<3>.
            - New routine isoSigComponentSize() for extracting the number of
              triangles from a signature (inherited from NGenericTriangulation).
            - Routine isoSig() now takes an optional argument that returns
              the isomorphism with the reconstruction from fromIsoSig().
            - New routines snapPea() and fromSnapPea() to import and export
              SnapPea data using strings, without writing to the filesystem.
            - New "magic constructor" that attempts to interpret a given
              string as a 3-manifold triangulation under several possible
              encodings.
            - Routine isThreeSphere() now includes a fast check for an
              "obviously" trivial fundamental group.
            - Renamed FaceIterator, faceIndex(), getFace(), getFaces(),
              getNumberOfFaces() and hasBoundaryFaces(), where "face"
              now becomes "triangle".  The old names are deprecated but
              have been kept for backward compatibility.
            - Results from hasCompressingDisc() and isHaken() are now
              stored in data files.
            - The output from getPacketTypeName() has changed from
              "Triangulation" to "3-Manifold Triangulation".
        Class NVertex:
            - Added buildLinkDetail(), which returns details of how triangles
              of the vertex link are embedded within individual tetrahedra.
            - Detailed string output (via detail() / toStringLong()) now
              outputs details of where the vertex appears in each tetrahedron.
        Class NXMLPacketReader, NXMLTreeResolver, NXMLTreeResolutionTask:
            - The API for reading packets from an XML data file has changed to
              incorporate the new NXMLTreeResolver class, which allows the
              resolution of dangling packet references after an entire
              data file has been read.
        Class PacketInfo:
            - Template classes that store traits of the various packet types.
              These are used with the new forPacket() template functions.
        Enum PacketType:
            - A new enumeration that contains constants representing
              different packet types.  Include "packet/packettype.h".
        Struct Returns:
            - Moved into utilities/registry.h.  However, its contents are
              still included from its previous header surfaces/filterregistry.h.
        Class ShareableObject:
            - Renamed toString() and toStringLong() to the simper-to-type str()
              and detail().  The old names have been kept as deprecated aliases.
        Class SurfaceFilterInfo:
            - Template classes that store traits of the various normal
              surface filter classes.  These are used with the new
              forFilter() template functions.
        Enum SurfaceFilterType:
            - A new enumeration that contains constants for different types of
              normal surface filter.  Include "surfaces/surfacefiltertype.h".
        Routine forFlavour(), forCoords():
            - Renamed each variant of forFlavour() to forCoords().  The
              old names have been kept as deprecated aliases.
        Routine stringToToken():
            - Moved from foreign/snappea.h into utilities/stringutils.h.
        Routine readSnapPea(), writeSnapPea():
            - Added istream/ostream versions of these routines.
            - In writeSnapPea(), the NTriangulation& argument is now const.
        Headers dimtraits.h, nfacetspec.h, ngenericisomorphism.{h,tcc}:
            - Moved from triangulation/ to generic/.  The old header locations
              are now deprecated.  They have been kept for backward
              compatibility, but simply include the new headers instead.
        Header filterregistry.h:
            - The REGISTER_FILTER macros have been removed.  To iterate through
              surface filter types, use the new forFilter() template functions.
        Header flavourregistry.h, coordregistry.h:
            - Renamed flavourregistry.h to coordregistry.h.  The old header
              has been kept as a deprecated alias.
            - The REGISTER_FLAVOUR macros have been removed.  To iterate through
              coordinate systems, use the forCoords() template functions.
        Header packetregistry.h:
            - The REGISTER_PACKET macros have been removed.  To iterate through
              packet types, use the new forPacket() template functions.
        Headers *.tcc:
            - All *.tcc headers have been renamed as *-impl.h, to play
              better with development IDEs.  The old header names are now
              deprecated but have likewise been kept for backward compatibility.
    USER INTERFACE:
        - The root container packet is now hidden from the user (it still
          exists internally within the packet tree).
        - The triangulation viewer now explicitly states "not oriented"
          for orientable-but-not-oriented triangulations.
        - The old regina-kde placeholder app (which did nothing but pop up
          a message directing the user to the new regina-gui) has been removed.
        - The boundary component viewer now displays more detailed information.
    PYTHON:
        - The python module 'regina' now has its own __init__.py, and loads
          'regina.engine' as an extension submodule.  All symbols from
          regina.engine are imported directly into 'regina', so users can
          continue to work directly with the 'regina' namespace as before.
        - For an XDG build (e.g., on GNU/Linux), the python module is now
          installed in the standard python site-packages directory, which
          means you can easily import the module from a normal python session.
        - Added a useful __repr__ for the core types NInteger, NLargeInteger,
          NRational, NPerm3, NPerm4 and NPerm5.
    TEST SUITE:
        - More NInteger / NLargeInteger tests, this time comparing operations
          when the same arguments are coerced from natives to GMP integers.
        - NBitmask tests for the bits() function.
        - Added python tests for the Orb import filter; thanks to
          Craig Hodgson for the sample files.

Version 4.94  [ 24 September, 2013 ]

    GENERAL:
        - Old-style binary files are no longer supported.  These have not been
          in use for over a decade.  If you have an old-style binary file that
          you need to use, install Regina 4.93 and use the regconvert tool.
        - Widespread alignment of integer sizes throughout the code.
          Many integers have changed from int to long, or from unsigned to
          unsigned long (or size_t), throughout the API.
        - Fixed some minor memory leaks.
    ENGINE:
        Class NAbelianGroup, NGroupExpression, NGroupExpressionTerm,
                NGroupPresentation:
            - Removed writeToFile(NFile&) and readFromFile(NFile&, ...),
              which were used for old-style binary files.
        Class NAngleStructure:
            - Removed writeToFile(NFile&) and readFromFile(NFile&, ...),
              which were used for old-style binary files.
        Class NAngleStructureList:
            - More frequent and robust cancellation checking during
              enumeration of vertex angle structures.
        Class BanConstraintBase, BanNone, BanBoundary, BanTorusBoundary:
            - New constraint classes for use with the new tree traversal code
              for enumerating normal surfaces.  See NTreeTraversal for details.
        Class Dim2Census, Dim2EdgePairing, Dim2GluingPerms,
                Dim2GluingPermSearcher:
            - New classes for building a census of 2-manifold triangulations.
        Class Dim2TriangleEdge:
            - New convenience typedef for NFacetSpec<2>.
        Class Dim2Triangulation:
            - New 2-manifold triangulation class.  This is a new packet
              type that can be independently stored in data files.
        Class Dim2BoundaryComponent, Dim2Component, Dim2Edge, Dim2EdgeEmbedding,
                  Dim2Isomorphism, Dim2Triangle, Dim2Vertex,
                  Dim2VertexEmbedding, NXMLDim2TriangulationReader:
            - New classes to support Dim2Triangulation.
        Class Dim2ExampleTriangulation:
            - New class for building common 2-manifold triangulation.
              Includes support for every possible 2-manifold.
        Class DimTraits:
            - New template class to assist with dimension-agnostic code.
        Class Flags:
            - New template class for forming bitwise combinations of
              flags based on enumeration values.
        Class HashPointer, HashString:
            - Removed, after being deprecated for a very long time now.
        Class IntOfSize:
            - New template class for using native integer types whose sizes
              are not determined until compile time.
        Class LPConstraintBase, LPConstraintSubspace, LPConstraintNone,
                LPConstraintEuler, LPConstraintNonSpun:
            - New constraint classes for use with the new tree traversal code
              for enumerating normal surfaces.  See NTreeTraversal for details.
        Class LPData, LPInitialTableaux, LPMatrix:
            - New classes that implement the dual simplex method, for use with
              the new tree traversal code for enumerating normal surfaces.
              See NTreeTraversal for details.
        Class NAbelianGroup:
            - New convenience routines isZ() and isZn().
        Class NBlockedSFS:
            - Now supports Seifert fibred spaces with boundary.
        Class NCensus:
            - The NProgressManager* argument has been removed from formCensus().
              If you are doing serious census generation, use the command-line
              utility tricensus (or tricensus-mpi) instead.
        Class NClosedPrimeMinSearcher, NCompactSearcher:
            - Improved the way in which cones and L(3,1) spines are
              detected and pruned during census enumeration.
            - Improved the way in which too many high degree edges are
              detected and pruned during census enumeration.
        Class NDoubleDescription:
            - More frequent polling for cancellation.
            - The progress tracker passed to enumerateExtremalRays() is now of
              class NProgresstracker, not NProgressNumber.
        Class NEdge:
            - New convenience routine getTriangulation().
        Class NEnumConstraintList:
            - This now holds unsigned longs, not unsigned ints, for
              consistency with the integer types used for NVector indexing.
        Class NFace:
            - New convenience routine getTriangulation().
        Class NFacePairing:
            - Now derives from the template base class NGenericFacetPairing<3>.
            - Renamed getNumberOfTetrahedra() to size().  The old name
              is deprecated, and will be removed in a future release.
        Class NFile, NFilePropertyReader:
            - Removed these classes, which were used for old-style binary files.
        Class NFileInfo:
            - Removed TYPE_BINARY, which was used for old-style binary files.
        Class NGenericFacetPairing:
            - New template base class that contains dimension-agnostic
              code for representing face/facet pairings.
        Class NGenericIsomorphism:
            - New template base class that contains dimension-agnostic
              code for representing isomorphisms between triangulations.
        Class NGroupExpression:
            - New routines wordLength(), erase(), cycleLeft(), cycleRight(),
              invert(), writeTeX(), and a version of writeText()
              that takes an extra argument to control the output style.
        Class NGroupPresentation:
            - Finally intelligentSimplify() really is intelligent.  It
              now uses Dehn simplification / small cancellation theory.
            - New routine intelligentSimplify(NHomGroupPresentation*)
              for keeping track of how the group was simplified.
            - New routines relatorLength(), abelianlisation(),
              markedAbelianisation(), writeTeX(), toTeX(),
              writeTextCompact() and toStringCompact().
            - More readable output from writeTextLong().
            - New assignment operator (=).
        Class NHilbertCD:
            - The NProgressMessage* argument to enumerateHilbertBasis()
              has been removed, since in reality the current algorithm offers
              no sensible progress tracking or cancellation polling.
        Class NHilbertDual:
            - More frequent polling for cancellation.
            - The progress tracker passed to enumerateHilbertBasis() is now of
              class NProgressTracker, not NProgressNumber.
        Class NHilbertPrimal:
            - The progress tracker passed to enumerateHilbertBasis() is now of
              class NProgressTracker, not NProgressMessage.
        Class NHomGroupPresentation:
            - New class to represent homomorphisms between groups.
        Class NHomMarkedAbelianGroup:
            - New routine torsionSubgroup().
        Class NHomologicalData:
            - Removed all dependencies on the old NIndexedArray.
        Class NIndexedArray:
            - Removed, after being deprecated for a very long time now.
        Class NInteger:
            - NInteger is a typedef for the new template class
              NIntegerBase<false>, which offers fast arbitrary precision
              integers but does not support infinity.
        Class NIntegerBase:
            - This is a new template class that supercedes (and is based on)
              the old NLargeInteger.  The boolean template argument indicates
              whether the class supports infinity as an allowed value.
            - Heavily rewritten from the old NLargeInteger: this class works
              with native C/C++ integers for as long as possible, and only
              switche to GMP when it becomes unavoidable.  This makes the code
              enormously faster (rough testing suggests a roughly 7x speedup).
            - Made the destructor non-virtual to avoid the unwanted class
              overhead that comes with polymorphism.
            - Added new routines that were not in the old NLargeInteger,
              including isZero(), sign(), gcdWith(), lcmWith(), and
              nativeValue<bytes>().
        Class NIsomorphism:
            - Now a subclass of NGenericIsomorphism<3>, with inherited
              dimension-agnostic aliases for several routines.
        Class NLargeInteger:
            - NLargeInteger is now a typedef for the new template class
              NIntegerBase<true>, and maintains backward compatibility.
            - Performance is much, much faster; see NIntegerBase for details.
        Class NLocalFileResource, NRandomAccessResource:
            - Removed these classes, which were used for old-style binary files.
        Class NMarkedAbelianGroup:
            - New routines torsionSubgroup() and torsionInclusion().
        Class NMatrix:
            - New routine isZero().
        Class NNativeInteger:
            - New template class that wraps native integer types with very
              little overhead and offers an interface compatible with NInteger.
        Class NNativeLong:
            - A convenience typedef for the new class NNativeInteger<long>.
        Class NNormalSurface:
            - Routine boundarySlopes() now requires that the
              triangulation is oriented (otherwise SnapPea will relabel
              tetrahedron vertices and the matrix returned will be null).
            - Routines findNonTrivialSphere() and findVtxOctAlmostNormalSphere()
              are deprecated.  Use NTriangulation::hasNonTrivialSphereOrDisc()
              and NTriangulation::hasOctagonalAlmostNormalSphere() instead.
            - Removed writeToFile(NFile&) and readFromFile(NFile&, ...),
              which were used for old-style binary files.
        Class NNormalSurfaceList:
            - New routines which() and algorithm() now retain details of
              which surfaces where enumerated and how this was done.
            - Now uses the new tree traversal method as a preferred
              enumeration algorithm where possible.  This is a significant
              improvement upon the old double description method.  See
              NTreeEnumeration and arXiv:1010.6200 for details.
            - The coordinate flavours (STANDARD, QUAD, etc.) are deprecated,
              and have changed from integers to NormalCoords enum types.
              Instead of these, use the NormalCoords enum values directly
              (NS_STANDARD, NS_QUAD, etc.).  For both C++ and Python users,
              these enum values are available directly in the namespace scope.
            - More frequent and robust cancellation checking during
              enumeration of vertex surfaces.
            - The old enumeration routines have been deprecated.  These
              include enumerate(NTriangulation*, int, bool, NProgressManager*),
              enumerateStandardDirect(), enumerateStandardANDirect(),
              enumerateFundPrimal(), enumerateFundDual(),
              enumerateFundCD() and enumerateFundFullCone().
              Users should now use the "universal" enumeration routine
              enumerate(NTriangulation*, NormalCoords, NormalList, NormalAlg,
              NProgressTracker*), which offers sensible default as well
              as fine-grained control over the underlying algorithms.
            - In all enumeration routines that take progress trackers, the
              old-style NProgressManager* arguments have been replaced with
              NProgressTracker* arguments, which are more flexible and
              more streamlined.
            - The routine getFlavour() is now renamed to flavour().
              The old getFlavour() is still available but deprected.
            - This class no longer inherits from NSurfaceSet (which has been
              removed).  As a result, getShareableObject() is no longer
              necessary and has likewise been removed.
        Enum NormalCoords:
            - A new enumeration that contains constants for different normal
              surface coordinate systems.  Include "surfaces/normalcoords.h".
        Class NormalFlavour:
            - Template classes that store traits of the various normal
              surface coordinate systems.  These are used with the new
              forFlavour() template functions.
        Enum NormalListFlags, Class NormalList:
            - Flags that specify which normal surfaces a particular list
              represents within a given triangulation.
        Enum NormalAlgFlags, Class NormalAlg:
            - Flags that specify details and parameters of normal surface
              enumeration algorithms.
        Class NPacket:
            - Fix crash when sortChildren() is run on the root packet.
            - Removed writePacket(NFile&) and readPacket(NFile&), which
              were used for old-style binary files.
        Class NPerm3, NPerm4, NPerm5:
            - New dimension-agnostic alias Sn that refers to S3, S4 and S5 in
              NPerm3, NPerm4 and NPerm5 respectively.
            - New dimension-agnostic alias Sn_1 that refers to S2, S3 and S4 in
              NPerm3, NPerm4 and NPerm5 respectively.
            - New dimension-agnostic enum constants nPerms and nPerms_1 that
              contain the number of permutations in Sn and Sn_1 respectively.
            - New construtors that take an array of images.
            - NPerm3 and NPerm5 now have a copy of S2 (which NPerm4 already
              had).  Likewise, NPerm5 now has a copy of S3, orderedS3,
              S4 and orderedS4 (which NPerm4 again already had).
            - NPerm4::invS2 and NPerm4::invS3 are deprecated: the former
              is unnecessary, and the latter is identical to NPerm3::invS3.
            - NPerm3 now has a transposition constructor: NPerm3(a,b).
        Class NProgress, NProgressFinished, NProgressManager,
                NProgressMessage, NProgressNumber, NProgressStateNumeric:
            - Deprecated in favour of the new NProgressTracker (see below).
        Class NProgressTracker:
            - A new unified and streamlined progress tracking mechanism that
              replaces the old suite of NProgress classes (i.e.,
              NProgressManager and the NProgress class hierarchy).
        Class NQitmask1, NQitmask2:
            - Fast classes for working with 0/1/2/3 "qits", i.e., "base 4 bits".
        Class NSatBlock:
            - Routine nextBoundaryAnnulus() has acquired an extra boolean
              argument, which allows us to choose between "next" and "previous".
        Class NSatRegion:
            - Routine createSFS() no longer need to be given the number
              of boundary components, and now supports Klein bottle
              boundaries.  The old two-argument version is now deprecated.
        Class NSnapPeaTriangulation:
            - Updated the SnapPea kernel to the one shipped with SnapPy 1.8.0.
            - New routine toRegina() to extract the underlying SnapPea
              triangulation, or to see exactly how SnapPea has relabelled
              and/or retriangulated.
            - New routine canonize() to produce the canonical retriangulation
              of the canonical cell decomposition.
        Class NSurfaceFilter:
            - Removed writeFilter(NFile&) and readFilter(NFile&, ...),
              which were used for old-style binary files.
        Class NSurfaceSet:
            - Removed.  The corresponding functionality has been moved directly
              into the subclasses NNormalSurfaceList and NSurfaceSubset.
        Class NSurfaceSubset:
            - No longer inherits from NSurfaceSet (which has been removed).
              As a result, getShareableObject() is no longer necessary and
              has likewise been removed.
            - The constructor now takes a reference to an NNormalSurfaceList,
              not an NSurfaceSet.
        Class NTetrahedron:
            - New dimension-agnostic aliases adjacentSimplex() and
              adjacentFacet().  These are identical to adjacentTetrahedron()
              and adjacentFace() respectively, and can help with
              writing code that works with more than one dimension.
        Class NTreeTraversal, NTreeEnumeration, NTreeSingleSolution:
            - New class for enumerating vertex normal surfaces and
              locating a single vertex normal surface under some linear
              constraint (such as positive Euler characteristic).  These are a
              significant improvement upon the old double description method.
              For details see arXiv:1010.6200 and arXiv:1211.1079 respectively.
        Class NTriangulation:
            - New routine drillEdge() to drill out a regular
              neighbourhood of an edge.
            - New optimised routines hasNonTrivialSphereOrDisc() and
              hasOctagonalAlmostNormalSphere() that use linear programming
              where possible to avoid a full enumeration of vertex surfaces.
              See arXiv:1211.1079 for details.
            - Some routines are now *much* faster for larger triangulations,
              thanks to the new linear programming code (arXiv:1211.1079).
              These include isZeroEfficient(), isThreeSphere(), isSolidTorus(),
              connectedSumDecomposition(), and makeZeroEfficient().
            - Rewrote barycentricSubdivision(): the code is now clearer,
              but note that the precise labelling of the new tetrahedra has
              changed from earlier versions of Regina.
            - Routine insertTriangulation() now works in the case where
              a triangulation tries to insert itself.
            - New dimension-agnostic aliases getNumberOfSimplices(),
              getSimplices(), getSimplex(), simplexIndex(), newSimplex(),
              removeSimplex(), removeSimplexAt() and removeAllSimplices().
              These are identical to the corresponding routines for
              operating on tetrahedra, and can help with writing code that
              works with more than one dimension.
            - Fixed isZeroEfficient(), which was reporting incorrect results
              for ideal triangulations.
            - Removed the old (and slow) getTetrahedronIndex(), getFaceIndex()
              and so on.  Use tetrahedronIndex(), faceIndex(), etc. instead.
            - All routines that took stdhash::hash_set arguments now take
              std::set arguments instead.
        Class NTritmask1, NTritmask2:
            - Fast classes for working with 0/1/2 trits, i.e., "ternary bits".
        Class NTypeTrie:
            - A fast data structure for storing zero/non-zero patterns in
              vertex normal surfaces.  This supports the new tree
              traversal enumeration code; see NTreeTraversal for details.
        Class NVertex:
            - New routine buildLink() to triangulate the vertex link.
            - New convenience routine getTriangulation().
        Class ZBuffer:
            - Updated xsgetn() to support n larger than UINT_MAX.
        Routine base64Decode(), base64Encode():
            - Replace the old GPL-licensed implementation with a different
              MIT-licensed implementation.  Functionality is the same.
        Routine forFlavour():
            - New template functions that offer a typesafe way of iterating
              through cases of different normal coordinate systems without
              abusing the C++ preprocessor.  These should be used instead of
              the old (and now deprecated) REGISTER_FLAVOUR macros.  Variants
              of forFlavour() are offered for different function types.
        Routine readFromFile(), writeToFile():
            - Removed, since these were used with old-style binary files.
        Routine readOrb():
            - Updated to correctly read the modern (and more verbose)
              Orb file format.  Thanks to Lorenzo Losa for the patch.
        Typedef NFacePairingIsoList, UseFacePairing:
            - These typedefs have been renamed as NFacePairing::IsoList
              and NFacePairing::Use respectively.  The old typedefs are
              deprecated, and will be removed in some future release.
        Header flavourregistry.h:
            - The old REGISTER_FLAVOUR macros are now deprecated, and will
              eventually be removed.  The preferred way to iterate through
              coordinate flavours is the new forFlavour() template functions.
        Header hashmap.h, hashset.h, hashutils.h:
            - Removed, after being deprecated for a very long time now.
        Header nlargeinteger.h:
            - Deprecated in favour of the new ninteger.h.
    USER INTERFACE:
        In addition to incorporating the new mathematical changes above:
            - The preference dialog is somewhat simpler now.
              + Some preferences are gone, and instead Regina simply remembers
                your last selection (e.g., default tabs for various viewers).
              + Some preferences have just been removed from the dialog (e.g.,
                the calculations thresholds), though users who really need
                these can still access them through the configuration file.
            - The elementary move dialog contains richer information
              about where the moves can take place, and stays open so that
              you can perform several moves one after another.
    UTILITIES:
        regconvert:
            - The option -b (for old-style binary files) is no longer supported.
        regina-python:
            - Enabled tab completion, courtesy of readline and rlcompleter.
            - The --quiet option no longer lists libraries as they are loaded.
        tricensus:
            - Now takes an optional argument -2/--dim2 to enumerate
              2-manifold triangulations.
            - Now takes an optional argument -c/--subcontainers to store
              triangulations in subcontainers according to face pairings.
    TEST SUITE:
        - Greatly expanded the tests for NLargeInteger and NInteger,
          which are now extremely thorough.
        - New and more thorough NTriangulation tests for barycentric
          subdivision, drilling edges, 0-efficiency testing, 3-sphere
          recognition, connected sum decomposition, solid torus recognition,
          and comparing H1 with the abelianised fundamental group.
        - New NNormalSurfaceList tests for comparing the results of different
          vertex / fundamental surface enumeration algorithms.  Also,
          exhaustive tests over census data now include ideal triangulations.
        - New enumeration tests for Dim2EdgePairing and Dim2Census.
        - New tests for permutation databases Sk and orderedSk.
        - New tests for base64 conversion.
        - Expanded tests for the NRational class.
        - Expanded enumeration tests for facet pairing classes to
          include pairings with boundary facets.

Version 4.93  [ 30 May, 2012 ]

    ENGINE:
        Class NAngleStructure:
            - New routine isVeering() to test for veering structures.
            - Flags (taut/strict/veering) are no longer stored in data files.
        Class NBlockedSFSLoop, NBlockedSFSTriple, NPluggedTorusBundle:
            - Corrected an off-by-one error in computing the genus of certain
              non-orientable base orbifolds for Seifert fibred pieces.
              This only affects census manifolds with >= 12 tetrahedra;
              in particular, no existing census data is affected.
        Class NExampleTriangulation:
            - New routine weeks() to build the Weeks manifold.
        Class NNormalSurface:
            - Routines isOrientable(), isTwoSided() and isConnected() now
              return bool instead of NTriBool.  This helps avoid unintended
              errors in scripts, but be warned: these properties can only be
              computed for compact surfaces (not spun normal surfaces).
            - Routines isIncompressible() and isCompressingDisc() likewise
              now return bool instead of NTriBool.
        Class NTriangulation:
            - New routines isSolidTorus() and knowsSolidTorus()
              for "one-click unknot recognition".
            - Routine hasCompressingDisc() now returns bool instead of NTriBool.
        Class NTriBool:
            - Deprecated.  This class has been replaced with ordinary (two-way)
              bool throughout Regina, and will be removed in a future release.
        Routine writeRecogniser():
            - Added to support sending triangulations to Matveev's
              3-manifold recogniser software.
    USER INTERFACE:
        - Restored File -> Save and File ->Save As, which were missing from
          the main menu in version 4.92.
        - In the triangulation viewer, the old "Surfaces" tab has been renamed
          as the "Recognition" tab, and includes high-level algorithms such as
          3-sphere recognition as well as "opportunistic" combinatorial
          recognition.
        - Replaced the python icon with a generic terminal icon.
        - GUI python consoles now set the variable "item", not "selected".
          This is easier to type, and avoids the misconception that selecting
          a different packet in the tree might change the variable (which it
          doesn't).  The variable "selected" is also set for backward
          compability, though this will be removed in a future release.
        - GUI python consoles will now set item=None if there is
          nothing selected in the packet tree.
        - Simplified the cut/copy/paste behaviour in graphical Python consoles.
        - The knot/link census is now explicitly called the *hyperbolic*
          knot/link census, since non-hyperbolic knots or links are excluded.
    DOCUMENTATION:
        - Layout and navigation improvements in the user handbook.
    TEST SUITE:
        - Added several tests related to Hakenness testing.

Version 4.92  [ 12 April, 2012 ] - The "hello Windows!" release.

    INSTALLATION:
        - Regina now builds and runs under Windows!
        - MacOS users now have a drag-and-drop app bundle, and do not
          need fink at runtime.
        - Linux (and indeed all) users no longer need KDE, since the user
          interface is now Qt-only.
    ENGINE:
        Class NBitmask:
            - Make NBitmask more suitable for use in containers.  Specifically,
              the assignment operator can now be used to initialise an
              uninitialised bitmask or to reset an already-initialised
              bitmask to a different length, and one or both of its
              operands may be invalid.
        Class NBitmask, NBitmask1, NBitmask2:
            - New function lessThan() for lexicographical comparisons.
        Class NDoubleDescription:
            - Removed the inner class LexComp, and replaced it with the new
              global class NPosOrder (see below).  A deprecated typedef
              NDoubleDescription::LexOrder is kept for backward compatibility.
        Class NFacePairing:
            - Function writeDot() can now optionally label graph
              vertices with the corresponding tetrahedron numbers.
            - Added graphviz export routines dot() and dotHeader(), which
              are like writeDot() and writeDotHeader() but return strings
              instead of writing to standard output.
        Class NFacetSpec:
            - New template class that generalises NTetFace to arbitrary
              dimensions.  NTetFace is retained as a convenience typedef,
              but with changes; see the NTetFace notes below.
        Class NGlobalDirs:
            - New routine setDirs() to be used when an application has
              been moved from the cmake-configured installation directory.
        Class NHilbertCD:
            - New class that implements a modified Contejean-Devie algorithm
              for Hilbert basis enumeration, based on the original algorithm in
              "An efficient incremental algorithm for solving systems of
              linear Diophantine equations", Contejean and Devie,
              Inform. and Comput. 113 (1994), 143-172.
        Class NHilbertDual:
            - New class that implements a modified dual algorithm for
              Hilbert basis enumeration, based on the dual algorithm in
              "Normaliz: Algorithms for affine monoids and rational cones",
              W. Bruns and B. Ichim, J. Algebra 324 (2010), 1098-1113.
        Class NHilbertPrimal:
            - New class that enumerates Hilbert bases by decomposing into
              maximal admissible faces and running the primal algorithm from
              Normaliz on each such face.  For details, see
              "Fundamental normal surfaces and the enumeration of Hilbert
              bases", B. Burton, arXiv:1111.7055, November 2011.
        Class NLargeInteger:
            - Made separate constructors and assignment operators for
              arguments of type int, unsigned int, long, and unsigned long.
            - Added ++ and -- operators.
            - Added (long + NLargeInteger) and (long * NLargeInteger) operators.
            - New routines setRaw() and rawData() for interacting directly
              with libgmp and libgmpxx.
        Class NMaxAdmissible:
            - New class for enumerating maximal admissible faces of the
              normal surface solution cone.
        Class NNormalSurface:
            - New routine boundarySlopes() that calculates boundary slopes
              for spun normal surfaces.
            - New routines getOrientedTriangleCoord() and
              getOrientedQuadCoord() for transversely oriented normal surfaces.
        Class NNormalSurfaceList:
            - New routines enumerateFundPrimal() and enumerateFundDual() to
              enumerate fundamental normal surfaces, as well as slower routines
              enumerateFundFullCone() and enumerateFundCD() for comparing
              different enumeration algorithms.
            - New coordinate systems ORIENTED and ORIENTED_QUAD to
              support transverse oriented normal surfaces.
            - New routines beginVectors() and endVectors() and new inner class
              VectorIterator for iterating through raw normal surface vectors.
            - New routine allowsOriented(), indicating whether the underlying
              coordinate system supports transverse orientations.
        Class NNormalSurfaceVector:
            - New routines getOrientedTriangleCoord() and
              getOrientedQuadCoord() for transversely oriented normal surfaces.
            - New routine allowsOriented(), indicating whether the underlying
              coordinate system supports transverse orientations.
        Class NNormalSurfaceVectorOriented, NNormalSurfaceVectorOrientedQuad:
            - New coordinate systems for transversely oriented normal surfaces.
        Class NPacket:
            - Fixed potential crash in fireDestructionEvent().
        Class NPerm3:
            - New routine compareWith() for sorting permutations.
        Class NPerm5:
            - New class describing permutations of five elements.
        Class NPosOrder:
            - Class for sorting hyperplanes during vertex enumeration.
              This is the new name for the old NDoubleDescription::LexComp.
        Class NSnapPeaTriangulation:
            - New routine slopeEquations() that uses code from SnapPy to
              compute boundary slope matrices for cusps.
            - New routine verifyTriangulation() for ensuring that
              SnapPea has not retriangulated unexpectedly.
        Class NSurfaceSet:
            - New routine allowsOriented(), indicating whether the underlying
              coordinate system supports transverse orientations.
        Class NTetFace:
            - Now an instance of the arbitrary-dimension template class
              NFacetSpec.  NTetFace is retained as a typedef, but the fields
              have been renamed from tet/face to the more general simp/facet.
        Class XMLPropertyDict:
            - Removed the optional defaultVal argument from lookup();
              the default is now always the empty string.
        Routines perm4to5, perm5to4, perm3to4, perm4to3:
            - New routines for converting between permutation classes.
        Routine makeEmbeddedConstraints():
            - Added to help generate admissibility constraints based on a
              flavour constant, instead of an NNormalSurfaceVector subclass.
        Routines writeCSVStandard, writeCSVEdgeWeight:
            - Included boundary slopes of spun-normal surfaces in CSV output.
        Macro REGISTER_FLAVOUR:
            - Now requires an additional argument, indicating whether
              the coordinate system supports transverse orientations.
    USER INTERFACE:
        - Ported from KDE to Qt-only.
        - Moved from a single monolithic window to lots of small windows
          (one for the tree, one for each open packets). The old
          interface can be re-enabled through Regina's preferences.
        - Continued the user interface overhaul, again with many more
          improvements that give cleaner and more sensible behaviour
          (too many changes to list individually).
        - Graphical Python consoles now execute "from regina import *"
          automatically.
    UTILITIES:
        regina-python:
            - Now executes "from regina import *" automatically.  You
              can suppress this with the argument --noautoimport.
            - For MacOS users: make sure 32-bit python is called when running
              32-bit fink on a 64-bit machine.
        tricensus:
            - Now outputs all face pairings as it runs, instead of periodic
              snapshots of where the census is up to.

Version 4.91: Internal development version.

Version 4.90  [ 12 September, 2011 ] - First prerelease for version 5.0.

    OVERALL:
        - The graphical user interface has been ported from KDE3 to KDE4.
        - The build system has been ported from autotools to cmake.
        - The built-in portions of the SnapPea kernel have been re-synced
          with the September 2009 version of SnapPea.
    DOCUMENTATION:
        - The users' handbook has undergone a thorough overhaul.  It is
          cleaner, more streamlined, and now full of screenshots.
        - The data file format has been split out of the users' handbook
          and placed in its own separate reference manual.
    ENGINE:
        Typedef AcceptTriangulation:
            - This global typedef has been deprecated.  Please use the
              class typedef NCensus::AcceptTriangulation instead.
        Class BitManipulator, GenericBitManipulator:
            - BitManipulator has new routines firstBit() and lastBit(), which
              return the positions of the first and last true bit respectively.
              This has required the addition of a new non-optimised base class
              GenericBitManipulator, which end users need never use directly.
        Class NAbelianGroup:
            - Routine addRank() now takes a signed integer, so that you
              can subtract from the rank as well as add to it.
            - Two new constructors to compute the homology of a chain complex
              with integer or mod-p coefficients.  Thanks to Ryan Budney.
        Class NAngleStructureList:
            - There is now an option to enumerate only taut angle structures,
              which is significantly faster than enumerating all vertex angle
              structures.  As a result, enumerate() now takes three arguments,
              there is a new routine isTautOnly(), and the data file format
              for angle structure lists contains a new element "angleparams".
            - Renamed allowsStrict() and allowsTaut() to spansStrict() and
              spansTaut().  The old routines are now deprecated but have been
              preserved (for now) for backward compatibility.
        Class NAngleStructureVector:
            - Removed clone().  Just use the copy constructor instead.
        Class NBitmask, NBitmask1, NBitmask2:
            - New operators ^= (XOR), -= (set difference) and = (assignment).
            - New routine truncate(), which truncates a bitmask to a given
              number of bits by setting all subsequent bits to zero.
            - New routines firstBit() and lastBit(), which return the
              positions of the first and last true bit respectively.
            - New convenience typedefs NBitmaskLen8, NBitmaskLen16,
              NBitmaskLen32 and NBitmaskLen64 for fast-and-small bitmasks
              of predetermined sizes.
        Class NCensus:
            - New class typedef NCensus::AcceptTriangulation to replace the
              old global typedef AcceptTriangulation.
        Class NDiscSetTetData:
            - Added assertions in data() to ensure that the given disc
              type and number are valid.  These can be circumvented by
              compiling with -DNDEBUG.
        Class NDoubleDescription:
            - Method enumerateExtremalRays() no longer has the "base" argument
              (which was used for cloning vectors); instead the method takes a
              new template argument specifying a vector class, and new vectors
              are created using the corresponding class constructors.
            - Improved the speed of adjacency testing by using an
              NTrieSet instead of a linear search through all vertices.
              See the NNormalSurfaceList notes below for further information.
            - Method enumerateExtremalRays() now takes an optional argument
              initialRows, allowing the user to force certain hyperplanes
              to be processed first.
        Class NExampleTriangulation:
            - New routine bingsHouse() returning the dual triangulation to
              Bing's house with two rooms.
            - Renamed seifertWeber() to weberSeifert(), for consistency with
              the original paper.  The old routine is now deprecated, but has
              being preserved (for the time being) for backward compatibility.
        Class NFacePairing:
            - Fixed the human-readable output for boundary faces in toString().
              Previously boundary faces were displayed as "n:0"; now they
              are displayed as "bdry".
        Class NFastRay:
            - Merged into the NRay class; see the NRay and NVector changes for
              details.  Because typedefs cannot be templated, there is no
              legacy typedef; instead NFastRay has been removed completely.
        Class NFastVector:
            - Merged into the NVector class; see the NVector changes for
              details.  Because typedefs cannot be templated, there is no
              legacy typedef; instead NFastVector has been removed completely.
        Class NGlobalDirs:
            - New routine data() to return the internal data directory.
        Class NGroupPresentation:
            - Fixed a memory leak in intelligentSimplify().
        Class NIsomorphism:
            - New routine applyInPlace() to directly modify a triangulation.
            - Routine apply() now copies tetrahedron descriptions as
              well as gluings (and so does the new routine applyInPlace()).
        Class NLayeredSurfaceBundle:
            - In isLayeredTorusBundle(), extend the search for possible
              cores to 11 and 12 tetrahedra.
        Class NLargeInteger:
            - New routines randomBoundedByThis(), randomBinary() and
              randomCornerBinary() for pseudo-random number generation.
            - Faster (GMP-native) implementation of swap().
        Class NMarkedAbelianGroup, NHomMarkedAbelianGroup:
            - Both of these classes have much richer interfaces than before,
              and some old routines have now been deprecated.  See the class
              documentation for full details.  Thanks to Ryan Budney.
        Class NMarkedVector:
            - Added swap() to swap the contents of two vectors.
        Class NNormalSurface:
            - New routines isCompressingDisc() and isIncompressible() for
              testing incompressibility.
            - Fixed a memory leak in crush().
        Class NNormalSurfaceList:
            - Sped up enumeration (again), this time by using a
              trie-like structure for adjacency testing.  For the
              Weber-Seifert space this improves speed threefold (roughly).
              Many thanks to Jonathan Shewchuk for encouraging me to
              focus on the adjacency testing bottleneck.
            - New filtering routines filterForLocallyCompatiblePairs() and
              filterForDisjointPairs().
            - New routine filterForPotentiallyIncompressible() to assist with
              bulk incompressibility testing; see arXiv:0909.4625 for details.
            - New routine allowsSpun() to easily identify coordinate systems
              that support spun normal surfaces.
        Class NNormalSurfaceVector:
            - Due to the changes in the NVector hierarchy, clone() is
              now introduced as a virtual function of NNormalSurfaceVector
              (not NVector), and it now returns an NNormalSurfaceVector*.
        Class NPacket:
            - In the python interface, makeOrphan() now returns the packet
              itself and the ownership becomes the responsibility of whoever
              takes this return value.  If nobody takes this return value
              then the packet and its descendants are automatically destroyed.
            - ChangeEventBlock has been renamed to ChangeEventSpan, it
              fires both packetToBeChanged() and packetWasChanged() (on
              construction and destruction respectively), and the
              optional boolean argument is gone (events are now fired always).
              The old class name ChangeEventBlock remains as a
              deprecated typedef for ChangeEventSpan.
            - The protected routine fireChangedEvent() has been removed.  The
              only way to fire a "packet changed" event now is to declare a
              local ChangeEventSpan.
        Class NPacketListener:
            - All events (except for destruction) now come with both future
              and past events: packetToBeChanged() and packetWasChanged(),
              childToBeAdded() and childrenWereAdded(), and so on.
        Class NPerm:
            - Renamed to NPerm4.  The C++ header has also moved from
              triangulation/nperm.h to maths/nperm4.h .  Both the old
              class name and the old header are now deprecated.
            - There are many other changes; see the NPerm4 notes below.
        Class NPerm3:
            - New class describing permutations of three elements.  This
              is extremely fast, using lookup tables for all calculations.
        Class NPerm4:
            - This is the new name for the old class NPerm (see above).
            - New routines S4Index() and orderedS4Index() for reverse
              lookups into the arrays NPerm4::S4 and NPerm4::orderedS4.
            - The constructor that takes an internal permutation code is
              now private, and is replaced by a new static routine
              NPerm4::fromPermCode().  This new routine is easier to
              spot and grep for.
            - The internal permutation codes have changed.  As a result,
              NPerm4 operations are significantly faster.  The old codes
              are now referred to as "first-generation", and the new codes
              are referred to as "second-generation".
            - Routines getPermCode(), setPermCode(), isPermCode() and
              fromPermCode() continue to refer to first-generation codes.
              These old routines are not recommended, since they now incur
              additional overhead.  To replace them, the new (and faster)
              routines getPermCode2(), setPermCode2(), isPermCode2() and
              fromPermCode2() work with second-generation codes instead.
            - The XML data file format continues to use first-generation
              permutation codes (for backward compatibility).
        Class NRational:
            - New STL-compatible routine swap().
        Class NRay:
            - Like the vector hierarchy, NFastRay and NRay are now merged
              into a single NRay class.  The result is that NRay is now
              cleaner and faster, but methods are no longer virtual.
              See the NVector class notes for full details of the changes
              (including important changes in the parent NVector class).
            - Removed the old intersect() function, which was based on
              virtual methods.
        Class NScript:
            - Fixed a bug that lost script variables when reading ancient
              binary files (i.e., files created before Regina 3.0, around
              mid-2002).  This bug only showed up on some compilers.
        Class NSnapPeaCensusManifold, NSnapPeaCensusTri:
            - Routines getHomologyH1() (for both classes) and construct()
              (for NSnapPeaCensusManifold) are now implemented for all SnapPea
              census manifolds/triangulations, not just the smallest few.
        Class NSnapPeaTriangulation:
            - Kernel messages are now disabled by default.
        Class NSurfaceSet, NSurfaceSubset:
            - New routine allowsSpun() to easily identify coordinate systems
              that support spun normal surfaces.
        Class NTetrahedron:
            - Tetrahedra should now always belong to a triangulation, from
              creation until destruction.  In particular:
              + Tetrahedra should be created by calling
                NTriangulation::newTetrahedron(), which will insert them
                into a triangulation immediately.  There is no need to
                call NTriangulation::addTetrahedron() any more.
              + NTetrahedron::joinTo() now recursively adds adjacent
                tetrahedra to the relevant triangulation (but if you use
                NTriangulation::newTetrahedron() as described above then
                this is fast and changes nothing).
            - Users no longer need to call NTriangulation::gluingsHaveChanged()
              after gluing or ungluing tetrahedron faces; this is now handled
              automatically.
            - The NTetrahedron constructors are now deprecated in favour
              of NTriangulation::newTetrahedron(), as described above.
            - New routine getVertexMapping(), which facilitates a
              consistent orientation around the given vertex for the
              three remaining vertices in each tetrahedron.
            - Added assertions in joinTo() and unjoin() to ensure that
              the preconditions are met.  These can be circumvented by
              compiling with -DNDEBUG.
            - Routines that need the triangulation skeleton (e.g., getVertex(),
              getEdgeMapping(), orientation(), etc.) will now compute the
              skeleton automatically if this has not already been done.
            - New routine getTriangulation() to return the enclosing
              triangulation.
        Class NTriangulation:
            - Add new routines newTetrahedron() and
              newTetrahedron(const std::string&).  This is now the
              preferred way of creating tetrahedra (see the NTetrahedron
              notes above).  The old addTetrahedron() is now deprecated.
            - Users no longer need to call gluingsHaveChanged(), which
              is likewise deprecated.  Again, see the NTetrahedron notes above.
            - Routines removeTetrahedron() and removeTetrahedronAt() now
              destroy the tetrahedron immediately and return nothing.
            - New routines hasCompressingDisc() and hasSimpleCompressingDisc()
              to search for compressing discs; see arXiv:0909.4625 for details.
            - The "legality conditions" on closeBook() are now simpler, since
              some of the conditions were automatic consequences of others.
              Practically, nothing has changed (i.e., the new conditions will
              be satisfied if and only if the old conditions were satisfied).
            - The "legality conditions" on twoOneMove() were originally too
              conservative, and are now weaker.  In particular, the endpoints
              of the edge may now both be boundary.  Practically, this means
              that 2-1 moves may now be legal where they were not legal before.
            - New static routine rehydrate() to rehydrate a new triangulation
              from a Callahan-Hildebrand-Weeks dehydration string.  This is a
              more convenient version of insertRehydration().
            - New routines isoSig() and fromIsoSig() for detecting and hashing
              combinatorial isomorphism classes of triangulations.
            - New routines isOriented() and orient() to relabel tetrahedron
              vertices for consistent orientation.  Thanks to Matthias Goerner.
            - New routines isOrdered() and order() to relabel tetrahedron
              vertices so that they are ordered consistently across adjacent
              faces.  Thanks again to Matthias Goerner.
            - New routines swapContents() and moveContentsTo() for
              moving tetrahedra between triangulations.
            - Fixed a memory leak in shellBoundary().
        Class NTrieSet:
            - A new class for storing and querying a large number of sets,
              where the elements of these sets are taken from a small universe.
              The underlying data structure is essentially a trie of bitmasks.
        Class NVector:
            - Streamlined the vector hierarchy by merging NFastVector and
              NVectorDense into a single NVector class, and removing NVectorUnit
              and NVectorMatrix entirely.  The result is that NVector
              is now cleaner and faster, but methods are no longer virtual.
              See the NVector class notes for full details of the changes.
            - Removed the old virtual clone() and makeLinComb() methods.
        Class NVectorDense:
            - Merged into the NVector class; see the NVector changes for
              details.  Because typedefs cannot be templated, there is no
              legacy typedef; instead NFastVector has been removed completely.
        Class NVectorMatrix, NVectorUnit:
            - Removed.  Use NVector instead.
        Class NVertexEmbedding:
            - New routine getVertices(), which facilitates a consistent
              orientation for the three remaining vertices in each tetrahedron.
        Class XMLPropertyDict:
            - The interface for this class is now much more restricted.
              The class now derives from std::map instead of stdhash::hash_map,
              and it allows access to only a few inherited members of std::map.
        Routine metricalSmithNormalForm():
            - New alternative Smith normal form routine that is better for
              working with extremely large matrices.  Thanks to Ryan Budney.
        Routine readIsoSigList():
            - New routine that reads a text file filled with isomorphism
              signatures and returns a container filled with triangulations.
        Routine readSnapPea():
            - Allows additional text on the first line following the
              "% Triangulation" marker (thanks to Matthias Goerner).
        Routine torsionAutInverse():
            - New routine for inverting automorphisms, thanks to Ryan Budney.
        Routines writeCSVStandard(), writeCSVEdgeWeight():
            - Changed the text that is written to the "boundary" field,
              to be consistent with changes to the user interface.
              Possible values are now "spun", "real" or "none".
        File surfaces/flavourregistry.h:
            - The final "pre_test" argument (which is never used) has been
              removed.  As a result, REGISTER_FLAVOUR now takes five arguments,
              not six.
    USER INTERFACE:
        - Ported from KDE3 to KDE4.  Finally!
        - The user interface has had a thorough overhaul, and includes
          many usability updates to help new users find their way around.
          Overall, the behaviour is generally cleaner and more sensible.
          A full list of changes is omitted for reasons of space and sanity.
        - There is now an option to enable or disable diagnostic
          messages from the SnapPea kernel.
    UTILITIES:
        tricensus, tricensus-mpi:
            - New option -s to output lists of isomorphism signatures instead
              of the much larger Regina data files.
        tricensus-mpi-status:
            - Now finishes with a running total of all triangulations found.
            - Compressed logs (using gzip or bzip2) are now supported.
              Requires the perl module IO::Uncompress::AnyUncompress.
        tricensus-manager:
            - Removed, since tricensus-mpi is a much better alternative.
    TEST SUITE:
        - Some slower but more detailed tests are now optional, and are
          disabled by default.  To switch these tests on, set the
          environment variable REGINA_DETAILED_TESTS to any non-empty value.
        - New tests for file I/O using both modern XML and legacy binary
          file formats.
        - More detailed tests for bitmask operations.
    BUILD ENVIRONMENT:
        - Dropped support for ancient hacks like std::ios::no_create and
          the boost.python make_constructor hack.
        - Iconv is now mandatory, not optional.

Version 4.6  [ 16 May, 2009 ]

    OVERALL:
        - Deprecated everything relating to the non-standard STL/g++ classes
          hash_set and hash_map, for the sake of portability.
        - Added a "deprecation guide" to the website, with a table listing
          the outdated routines/classes/etc. to be removed in Regina 5.0 and
          the corresponding new routines/classes/etc. that replace them.
    ENGINE:
        Class HashPointer, HashString:
            - Deprecated, along with everything else relating to the hash_set
              and hash_map classes.  See the "overall" notes above.
        Class NBoundaryComponent, NComponent, NEdge, NFace, NVertex:
            - All constructors for skeletal objects are now private, since
              only the triangulation skeletal routines should be creating them.
            - Cleaned up some of the more obscure parts of the documentation.
        Class NCensus:
            - Removed findAllCompletions(), which (as the documentation
              points out) is an empty shell of a routine that has never been
              implemented and quite possibly never will.
        Class NDiscType:
            - New class for specifying a normal or almost normal disc type.
        Class NDoubleDescription, NDoubleDescriptor:
            - The old NDoubleDescriptor class has been renamed, and is now
              called NDoubleDescription.  This is merely for consistency
              with documentation and papers; the functionality of the class
              has not changed.  The old name (NDoubleDescriptor) is
              deprecated, but for the time being a typedef is provided
              for backward compatibility.
        Class NEdge:
            - Added new static arrays NEdge::edgeNumber and NEdge::edgeVertex
              to replace the old global arrays regina::edgeNumber,
              regina::edgeStart end regina::edgeEnd.  The old global
              arrays are now deprecated (see below).
            - Added a new static array NEdge::ordering to replace the old
              global routine regina::edgeOrdering().  The old routine is
              now deprecated (see below).
        Class NFace:
            - Added a new static array NFace::ordering to replace the old
              global routine regina::faceOrdering().  The old routine is
              now deprecated (see below).
        Class NFacePairing:
            - Added a missing precondition to isCanonical(), which requires
              that the face pairing be connected.
            - Changed the output format of toString() to make it clearer
              which faces are boundary faces.
        Class NFastRay:
            - New fast but inflexible ray class; this builds on NFastVector
              in the same way that the slower NRay builds on NVector.
        Class NGluingPermSearcher, NCompactSearcher, NClosedPrimeMinSearcher:
            - Overhauled the census code so that some of the optimisations
              used in the closed minimal irreducible / P^2-irreducible census
              can be made available to more general censuses.  In particular,
              the modified union-find for vertex and edge links is now
              available to any census that insists on compact (finite)
              3-manifolds.  For details of these optimisations, see
              "Enumeration of non-orientable 3-manifolds using face-pairing
              graphs and union-find", B. A. Burton, Discrete Comput. Geom. 38
              (2007), no. 3, 527--571.
        Class NIndexedArray:
            - Deprecated, along with everything else relating to the hash_set
              and hash_map classes.  For a replacement, try the NMarkedVector
              class, which is smaller and faster but requires modification
              of the data type being stored.
        Class NIsomorphism, NIsomorphismDirect, NIsomorphismIndexed:
            - NIsomorphism has been enhanced to add all of the functionality
              of the old NIsomorphismDirect class, so NIsomorphism is now a
              fully-fledged isomorphism class in its own right.
            - NIsomorhpismDirect has been deprecated, since this is now an
              empty subclass of NIsomorphism with no extra functionality.
              Programmers can change their code to use NIsomorphism instead.
            - NIsomorphismIndexed has been removed entirely.  Python users
              will not be affected, since this class was never available to
              them.  C++ programmers can now use NIsomorphism in conjunction
              with the NPerm::S4 array instead.
        Class NLargeInteger:
            - The old header utilities/nmpi.h is now deprecated.  Please use
              the new header maths/nlargeinteger.h instead.
        Class NMatrix2:
            - The old header utilities/nmatrix2.h is now deprecated.  Please
              use the new header maths/nmatrix2.h instead.
        Class NNormalSurface:
            - Finally implemented cutAlong()!
            - New routine isEmpty() for identifying empty surfaces.
            - New routine sameSurface() for comparing two normal surfaces.
            - New routines locallyCompatible() and disjoint() for testing
              intersections between normal surfaces.
            - New routine getOctPosition() for locating the non-zero
              octagonal coordinate in an almost normal surface.
            - New routine rawVector() that gives direct read-only access to
              the underlying vector in case this is needed.
            - Removed canCrush() and knownCanCrush(), which are both
              placeholders for routines that have never been implemented.
              The corresponding <cancrush> element has been removed from
              the data file format (though old files that happen to contain
              it will load without problems).
            - Added an optional argument to findVtxOctAlmostNormalSphere()
              that lets the user choose between working in standard and
              quadrilateral-octagon coordinates.
        Class NNormalSurfaceList:
            - Implemented quadrilateral-octagon coordinates for almost normal
              surfaces (the relevant flavour constant is AN_QUAD_OCT).
              See arXiv:0904.3041 for details.
            - Added routines quadToStandard(), standardToQuad(),
              quadOctToStandardAN() and standardANToQuadOct() to convert
              between different solution sets.  See arXiv:0901.2629 for
              details of the underlying algorithms.
            - Changed enumerate() in standard coordinates so that, if
              possible, it enumerates in quadrilateral coordinates first
              and then converts between solution sets (see above).  This
              typically runs orders of magnitude faster.  Similarly for
              standard almost normal coordinates.
            - New routines enumerateStandardDirect() and
              enumerateStandardANDirect() to allow people to circumvent the
              above changes to enumerate() and instead use the old direct
              enumeration from Regina 4.5.1.
            - Almost normal surface enumeration no longer strips out surfaces
              with more than one octagonal *disc* (though it still avoids
              surfaces with more than one octagonal disc *type*).  This
              change is necessary for conversion between quad-oct and
              standard almost normal space, and is also necessary if we
              wish to enumerate *all* almost normal surfaces (as opposed
              to just all *vertex* almost normal surfaces).
            - Added a new coordinate flavour AN_LEGACY to reflect almost
              normal surface lists created with Regina 4.5.1 or earlier,
              where surfaces with more than one octagon were stripped out
              (see above).
        Class NPerm:
            - New routines trunc2() and trunc3() to build a truncated
              version of a permutation string.
            - New arrays NPerm::S4, NPerm::invS4, NPerm::orderedS4,
              NPerm::S3, NPerm::invS3, NPerm::orderedS3, NPerm::S2 and
              NPerm::invS2.  These replace the old (and now deprecated)
              arrays regina::allPermsS4, regina::allPermsS4Inv,
              regina::orderedPermsS4, and so on.
            - Deprecated the setPerm() routines; these are unnecessary
              because NPerm objects are very small and can just be copied
              around using the assignment operator.
        Class NPermItS4:
            - Deprecated, since all this class does is wrap a trivial loop.
              Just loop through the elements of NPerm::S4 directly.
        Class NPillowTwoSphere, NSnappedTwoSphere:
            - Removed reduceTriangulation() and getReducedTriangulation(),
              both of which are empty shells of routines that have never
              been implemented and quite possibly never will.
        Class NRational:
            - Added new routines getTeX() and writeTeX() for TeX-friendly
              output (thanks Ryan!).
            - The old header utilities/nrational.h is now deprecated.  Please
              use the new header maths/nrational.h instead.
        Class NTetrahedron:
            - Renamed getAdjacentTetrahedron(), getAdjacentTetrahedronGluing()
              and getAdjacentFace() to adjacentTetrahedron(), adjacentGluing()
              and adjacentFace(), which should be easier on the fingers.
              The old names are still available for backward compatibility,
              but they are now deprecated and will be removed in Regina 5.0.
            - Proofreading and clarification for some of the older and more
              opaque parts of the documentation.
        Class NTriangulation:
            - New routines isBall() and knowsBall() for recognising the
              3-dimensional ball.
            - New elementary move closeBook().
            - Completely overhauled collapseEdge().  The eligiblity checks for
              this routine are now correct and not overly conservative, which
              makes this routine both useful and safe.  The big warning is
              now gone from the collapseEdge() documentation as a result.
            - Routine simplifyToLocalMinimum() now collapses edges, which
              makes a big difference for multiple-vertex triangulations.
            - Routine intelligentSimplify() now uses book opening moves to
              create new opportunities for collapsing edges (which makes a
              big difference for bounded triangulations), and also uses
              book closing moves to reduce the number of boundary faces
              once nothing else can be done.
            - Routine isThreeSphere() now works in quadrilateral-octagon
              coordinates instead of standard almost normal coordinates.
              See arXiv:0904.3041 for details.
            - Removed crushMaximalForest(), which (as the documentation has
              pointed out since the first release) has never worked properly,
              and which is therefore never actually used.
            - Fixed crashes in twoOneMove(), twoZeroMove(NVertex*, ...)
              and shellBoundary().  These crashes were triggered by certain
              types of non-minimal triangulations with boundary.
            - Fixed a couple of nasty bugs in shellBoundary(), which had the
              potential to give incorrect results when simplifying
              triangulations with boundary.
            - Fixed bugs in several simplification routines when working
              with invalid triangulations; these sometimes "simplified"
              invalid edges to become valid edges.
            - New routine reorderTetrahedraBFS() for renumbering tetrahedra
              in a more sensible fashion.
            - Routines isZeroEfficient() and hasSplittingSurface() now
              operate on a clone of the triangulation, to avoid triggering
              changes to the packet tree.
        Routine edgeOrdering(), faceOrdering():
            - Deprecated these routines, in favour of the new NEdge::ordering[]
              and NFace::ordering[] lookup tables.
        Routine edgeDescription(), faceDescription():
            - Deprecated these routines, in favour of the new NPerm::trunc2()
              and NPerm::trunc3() routines.
        Routine writeResUsage():
            - New helper routine to assist with diagnostics and measurements
              of performance.
        Global arrays allPermsS4, allPermsS4Inv, orderedPermsS4, allPermsS3,
                allPermsS3Inv, orderedPermsS3, allPermsS2, allPermsS2Inv:
            - All of these arrays are now deprecated.  Please use the new
              arrays NPerm::S4, NPerm::invS4, NPerm::orderedS4, and so on.
        Global arrays edgeNumber, edgeStart, edgeEnd:
            - Deprecated; users are advised to switch to the new arrays
              NEdge::edgeNumber and NEdge::edgeVertex instead.
        Namespace stdhash:
            - Deprecated, along with everything else relating to the hash_set
              and hash_map classes.  See the "overall" notes above.
    USER INTERFACE:
        - The elementary moves dialog now has additional "Close book"
          and "Collapse edge" options.
        - Items in the triangulation composition list can now be copied
          into the clipboard via the right mouse button.  Amongst other
          things, this makes extracting the dehydration string much simpler.
        - In the triangulation viewer, the Surfaces panel now has a new
          "3-ball?" entry beneath the current "3-sphere?" entry.
        - The normal surface list viewer now has two additional tabs: one to
          summarise all surfaces in the list (which is now the default tab),
          and one to list pairwise compatibilities between surfaces.
        - The normal surface list viewer now has an additional "Cut Along"
          menu item.  The shortcut letter for "Crush" has changed as well.
        - Warn the user before enumerating immersed and/or singular normal
          surfaces, in case the "embedded surfaces only" box was unchecked
          by accident.  Moreover, refuse to enumerate immersed and/or
          singular *almost* normal surfaces, since this feature was designed
          for use with normal surfaces only.
        - The surface coordinate viewer now lists the location of the almost
          normal disc(s) alongside the other high-level surface properties.
        - Normal surfaces are now individually numbered within surface lists,
          which should make it easier to keep track of which is which.
        - Added "Troubleshooting" and "Handbook won't open?" entries to
          the Help menu, to make it easier to find solutions if things break.
        - The "Python Reference" entry in the Help menu should now work
          even when konqueror is not installed.
        - Fixed a bug whereby small triangulations occasionally became
          read-only after a user visited the Surfaces panel.
        - Added a scrollbar to the Cellular Info pane in case the window
          is small.
    TEST SUITE:
        - Added very thorough tests for NPerm.
        - Additional tests for triangulation simplification and Euler
          characteristic.
        - New tests for the recognition of families of standard triangulations
          and manifolds.
        - New tests that enumerate automorphisms of triangulations and
          test for subcomplexes.
        - Added exhaustive testing for 3-sphere and 3-ball recognition.
        - Added exhaustive testing for conversions between normal surface
          solution sets in different coordinate systems.
    BUILD ENVIRONMENT:
        - Installing into a staging area (i.e., building packages) now works
          fine even if older versions of the Regina development libraries are
          installed (this used to cause relinking problems on some systems).

Version 4.5.1  [ 28 October, 2008 ]

    CENSUS:
        - Replaced the old plain-text Notation packets with detailed PDF
          packets in the closed orientable / non-orientable censuses.
          These new Notation packets explain the manifold names and
          parameters precisely, and include supporting diagrams.
        - Renamed some census manifolds to avoid arbitrary (a), (b) suffixes.
          In the 11-tetrahedron closed orientable census:
            Hyp_2.13401634 (Z_14) (a)  ->  Hyp_2.13401634 (Z_14, geod = 0.4606)
            Hyp_2.13401634 (Z_14) (b)  ->  Hyp_2.13401634 (Z_14, geod = 0.3684)
            (These have also been reordered in the overall list of manifolds.)
          In the 11-tetrahedron closed non-orientable census:
            SFS [M] U m003 (a)  ->  SFS [M] U m003 (Z + Z_5)
            SFS [M] U m003 (b)  ->  SFS [M] U m003 (Z + Z_10)
          These changes are only stop-gaps until hyperbolic manfiolds are
          dealt with properly (i.e., expect the names to change again).
    ENGINE:
        Class NBitmask, NBitmask1, NBitmask2, BitManipulator:
            - New classes for manipulating bitmasks.  NBitmask is for bitmasks
              of arbitrary length, whereas NBitmask1 and NBitmask2 are
              optimised for situations where the length is known to be small.
              BitManipulator makes it easier to offer optimised template
              specialisations.
        Class NCompConstraint, NCompConstraintSet:
            - Removed.  Compatibility constraints now refer to facets of
              the original cone, not coordinate positions (hence the
              rename, since the semantics have changed in a fundamental way).
              Individual compatibility constraints are now straight sets of
              integers, and the deque-based NCompConstraintSet has been
              replaced with the new vector-based class NEnumConstraintList.
        Class NDoubleDescriptor:
            - Streamlined the vertex enumeration routine, which is now
              much, much faster.  See arXiv:0808.4050 for a full list of
              improvements.
            - The vertex enumeration routine now takes its arguments in
              a different form, and more importantly now insists that
              the original cone is in fact the non-negative orthant.
              To ensure that python/C++ users notice that things have changed,
              this routine has been renamed from enumerateVertices() to
              enumerateExtremalRays().
            - Major overhaul of the documentation, which is now (hopefully)
              much clearer.
        Class NEnumConstraintList:
            - Added to replace the old NCompConstraintSet class.  See
              the notes above on NCompConstraintSet for details.
        Class NFastVector:
            - New vector class that is less flexible than NVector but
              more streamlined, largely because it has no virtual functions.
        Class NGraphTriple:
            - Fixed a bug in writeTeXName() that listed incorrect entries for
              the first matrix.  This does not affect any census data that
              has been published or shipped with earlier versions of Regina.
        Class NLargeInteger:
            - Fixed lcm() to do the right thing in the case of lcm(0,0).
        Class NMatrixInt:
            - New integer-specific routines divRowExact(), divColExact(),
              gcdRow(), gcdCol(), reduceRow() and reduceCol().
        Class NMatrixField:
            - Removed this class, since it is never used and since it does not
              actively address the accuracy problems raised by real numbers.
        Class NNormalSurfaceVector:
            - Removed createNonNegativeCone() from subclasses (which is
              no longer required after the vertex enumeration overhaul),
              and added makeZeroVector() (which is now required).
        Class NPDF:
            - A new packet type that allows PDF documents to be stored
              directly as packets inside Regina data files.
        Routines base64Length(), isBase64(), base64Encode(), base64Decode():
            - New routines for base64 encoding and decoding, taken and
              modified from the gnulib library.
        Routines createNonNegativeCone(), makeZeroVector():
            - Removed global routine createNonNegativeCone() and replaced it
              with the new global makeZeroVector(), in line with the changes
              to NNormalSurfaceVector listed above.
        Routine gcd():
            - Now takes longs instead of unsigned longs, and guarantees
              that the gcd returned will be non-negative.
        Routine lcm():
            - Added to the collection of basic number theory routines.
        Routines readPDF(), writePDF():
            - New routines for importing and exporting PDF packets to
              real PDF files.
        Routines rowBasis(), rowBasisAndOrthComp():
            - Added to find the rank of an integer matrix and bases for its
              row space and orthogonal complement.
    USER INTERFACE:
        - PDF documents can now be embedded within data files as PDF packets.
          Added import, export and creation facilities, plus a PDF packet
          viewer that uses either an embedded KPart (such as kpdf or
          kghostview's embedded viewer) or an external application (such
          as xpdf or evince) according to the user's preferences.
    TEST SUITE:
        - Added new tests for normal surfaces that exploit generic properties
          of layered loops; these tests push to 50 tetrahedra, and can
          easily be extended further as surface enumeration becomes faster.
        - Added additional tests for normal surfaces and angle strutures
          that compare solutions coordinate by coordinate (instead of
          counting solutions and looking for large-scale properties).

Version 4.5  [ 17 May, 2008 ]

    OVERALL:
        - Regina finally pays attention to character encodings:
            + All strings in the calculation engine are assumed to be UTF-8,
              except for filenames which should be in whatever local encoding
              the operating system expects.
            + Regina's XML data files store their data in UTF-8, as does the
              python configuration file ~/.regina-libs.
            + The various user interfaces ensure that the correct character
              encodings are always used, and translate between encodings
              where required.
            + Users who pass strings directly to the calculation engine
              (through the python or C++ interface) must ensure that
              their strings are either UTF-8 or just plain ASCII.
        - Builds under gcc 4.3.
        - Supports building out-of-tree (e.g., making separate builds in
          debug/ and release/ subdirectories).
    ENGINE:
        Class Locale, IConvBuffer, IConvStream:
            - New classes in the regina::i18n namespace for working with
              internationalisation and character encodings.
        Class NExampleTriangulation:
            - New routine seifertWeber() to build the Seifert-Weber
              dodecahedral space.
        Class NFileInfo:
            - Made the XML identification routines more robust, so that
              they work even if extra parameters (such as encoding or
              standalone declarations) are present in the XML prologue.
        Class NGlobalDirs:
            - New class for easy access to system installation directories
              for various components of Regina.
        Class NMarkedVector, NMarkedElement:
            - New class for a vector with fast reverse lookups.  This
              is more memory efficient than NIndexedArray, but requires
              modifications to the data type being stored.
        Class NPacket, NPacketListener:
            - Fires packetWasRenamed() when packet tags are added or removed.
              Note that packet tags still cannot be accessed through the GUI
              except for via the python bindings.
            - Made the event handling code more robust; this fixes a
              couple of crashes in the GUI that occured when packets were
              deleted from the tree while they were still in use elsewhere.
        Class NTriangulation:
            - Streamlined the implementation, cutting ~ 1/3 of the memory
              usage and improving speed also.  As a result:
                + Tetrahedra and skeletal components are now stored using
                  NMarkedVector, not NIndexedArray.  As a result the return
                  types of getTetrahedra(), getVertices(), etc. have changed.
                + The old reverse lookup routines getTetrahedronIndex(),
                  getVertexIndex(), etc. are now deprecated.  The new routines
                  tetrahedronIndex(), vertexIndex(), etc. are even faster,
                  but have new preconditions requiring the given tetrahedron,
                  vertex, etc. to belong to the triangulation.
        Class NXMLElementReader:
            - New routine usingParser() that passes the current parser to the
              top-level element reader.
        Class XMLParserCallback:
            - Callback routine start_document() now takes a single argument
              that points to the current XMLParser.
        Routine readXMLFile(), readFileMagic():
            - Assumes that any Regina data files created by version 4.4 or
              earlier use a LATIN-1 encoding (which is what the old GUI used
              by default), and that any data files created by version 4.5 or
              later use UTF-8.
        Routine versionUsesUTF8():
            - Added to assist code that works with files on a low-level basis.
        Routines writeCSVStandard(), writeCSVEdgeWeight():
            - New routines for exporting normal surface lists to plain-text
              CSV files (which can then be imported into a spreadsheet or
              database).
    USER INTERFACE:
        - Normal surface lists can now be exported to plain-text CSV files
          (which can then be imported into a spreadsheet or database).
        - The default SnapPea filename filter is now *.tri instead of just *.
        - Several imports and exports (e.g., to/from python scripts and C++
          source) now allow the user to select an explicit character encoding.
        - Added the Seifert-Weber dodecahedral space to the list of example
          triangulations that can be created.
        - When adding a new library in Regina's python settings, the file
          dialog now opens in the pylib/ directory where sample libraries
          are installed.
        - Application icons are now listed under hicolor instead of crystalsvg,
          which should make them easier for other desktop environments to find.
    PYTHON:
        - Use docstrings for the helper routines in pylib/, so documentation
          for these routines can be accessed from within python at runtime.
        - Added loadCensus.py as a new collection of optional helper routines
          in pylib/.  These make it easy to load census data files from within
          python.
    UTILITIES:
        regfiledump, trisetcmp:
            - Now respects the default locale; any international characters
              in packet labels or packet contents are displayed using the
              correct character set (e.g., LATIN-1 for Western European users).

Version 4.4  [ 25 November, 2007 ] - The "hug a Mac today" release.

    OVERALL:
        - Builds and runs happily on MacOS!  Requires Fink to be installed.
        - Tidied up the directory hierarchy a little.  The old engine/engine/
          is now just engine/, and the old engine/doc-files/ is now
          engine/doxygen/.
        - Thanks to Ryan Budney for his many contributions to this release!
    CENSUS:
        - Expanded the closed non-orientable census to 11 tetrahedra.
        - Expanded the closed orientable census to 11 tetrahedra, and
          split it into three data files.  The 9-tetrahedron and
          10-tetrahedron files are shipped with Regina as before (as
          closed-or-census.rga and closed-or-census-large.rga); the
          11-tetrahedron file is extremely large and must be downloaded
          separately from the Regina website.
        - Modified the closed orientable census files to use more
          consistent choices of monodromy matrices for torus bundles.
        - Clarified the matrix notation used with graph manifolds.
    ENGINE:
        Class NClosedPrimeMinSearcher:
            - Census generation is much faster for larger numbers of
              tetrahedra, due to new tests for high-genus vertex links.
            - Also made census generation more efficient by pruning on
              high-degree edges (as well as the usual low-degree edges).
        Class NDoubleDescriptor:
            - Now a standalone class, since the base NVertexEnumerator
              has been removed.
            - Made all member functions static.  Objects of this class
              can no longer be created.
        Class NFacePairing:
            - Modified writeDot() to behave well with ancient versions
              of Graphviz.
        Class NHomologicalData:
            - New class for computing all sorts of detailed homological
              information for a manifold; thanks to Ryan Budney for this.
        Class NLargeInteger:
            - New routine divisionAlg() for using the division algorithm.
            - New routine legendre() for calculating Legendre symbols.
        Class NMatrix:
            - New == and != operators for element-by-element comparison.
        Class NMatrixInt:
            - Added a set() routine to the python interface for setting
              matrix elements (which was previously not possible in python).
            - Made matrix multiplication available in the python interface.
            - Added a python-only variant of initialise() that fills a
              matrix given a complete list of elements.
        Class NMatrixRing:
            - New routine det() for fast calculation of matrix determinants.
            - New convenience routine isIdentity().
            - Changed the return type of operator * from a raw pointer to a
              std::auto_ptr, to make it easier to multiply matrices inside
              temporary expressions.
            - Added a new multiplyAs() template routine that multiplies but
              (unlike operator *) returns a subclass of NMatrixRing.
        Class NMarkedAbelianGroup, NHomMarkedAbelianGroup:
            - New classes for working with groups defined by chain
              complexes; thanks to Ryan Budney for these.
        Class NPacket:
            - New routine reparent() to simplify ownership issues when
              using Python scripting.
        Class NPerm:
            - Micro-optimised routines that are called extremely frequently,
              such as sign().
        Class NPrimes:
            - New class that provides a more sophisticated infrastructure
              for prime factorisation than the old factorise() and
              primesUpTo() routines.
        Class NRational:
            - New routine abs() for calculating absolute value.
            - New routine doubleApprox() for converting to a real number.
        Struct NSatAnnulus:
            - New routine attachLST() to help with Seifert fibred spaces.
        Class NSFSpace:
            - Updated reduce() to make the best possible decisions on
              whether to reflect all fibres in cases where this is
              possible (previously it made faster decisions but
              occasionally missed some more subtle reductions).
            - Enhanced construct() to support the triangulation of all
              Seifert fibred spaces over the 2-sphere without punctures
              or reflector boundaries.
        Class NTetrahedron:
            - New routine orientation() for tracking orientation.
        Class NTorusBundle:
            - Greatly improved monodromy matrix reduction, to the point
              where equivalent torus bundles should give equal matrices.
            - Fixed a bug in the matrix reduction for non-symmetric
              matrices in non-orientable manifolds (sometimes the
              transpose matrix was obtained instead of the correct matrix).
        Class NTriangulation:
            - New routine layerOn() for performing layerings.
            - New routine dehydrate() for extracting Callahan-Hildebrand-Weeks
              dehydration strings.
            - Optimised the skeletal calculations, which now run *much* faster.
            - Renamed getEulerCharacteristic() to getEulerCharTri(), since for
              ideal triangulations this differs from the Euler characteristic
              of the corresponding compact manifold.  The old name is kept as
              an alias but is now deprecated.
            - Added a new routine getEulerCharManifold(), which *does* calculate
              the Euler characteristic of the corresponding compact manifold.
            - Fixed a crash in splitIntoComponents() that occurred when
              the triangulation skeleton had not yet been calculated.
        Class NVertexEnumerator:
            - Removed.  This abstract class existed to support multiple
              vertex enumeration algorithms, but in reality we're only
              using double descriptor anyway.  The virtual template
              member functions caused problems with g++-4.2, which was
              the final push.  NDoubleDescriptor is now a standalone class.
        Routine smithNormalForm():
            - New five-argument version that not only calculates the Smith
              normal form but also returns appropriate change of basis
              matrices; thanks to Ryan Budney.
        Routines columnEchelonForm() and preImageOfLattice():
            - New routines for working with matrices and homomorphisms;
              thanks again to Ryan Bydney.
        Routines factorise(), primesUpTo():
            - Deprecated in favour of routines from the new NPrimes class.
        Routine clonePtr():
            - New routine to assist copy constructors for classes that
              compute data on demand.
    USER INTERFACE:
        - New Algebra -> Cellular Info tab containing a variety of new
          homological data for triangulations; thanks to Ryan Budney.
        - Graphs now look better when drawn using an old Graphviz 1.x
          (previously the graphs were only tested under Graphviz 2.x).
        - Better infrastructure for determining the status of the
          current Graphviz installation.  For version 1.x, Regina now
          insists on using dot, since the old neato 1.x cannot handle
          multiple edges.
        - Removed the Crush column from normal surface lists, since it has
          never contained any information beyond "N/A" or "Unknown".
        - The Regina reference manual is now called the Regina handbook,
          for consistency with other KDE applications.
    PYTHON:
        - The regina-python tool has new options -i/--interactive (run a
          script and leave the interpreter open) and -n/--nolibs (do not
          load any of the normal user libraries).
    UTILITIES:
        trisetcmp:
            - Now outputs more appropriate messages when subcomplex testing
              (previously the same messages were used for both subcomplex
              testing and isomorphism testing).
    TEST SUITE:
        - Added a new test suite for python bindings, in addition to the
          usual C++ test suite that is already present.
        - Added tests for the NPerm class.
        - Added tests for vertex link calculations.
        - Added tests for the orientable double cover of a triangulation.
        - Added tests for the new NPrimes class.
        - Added division algorithm tests for NLargeInteger.
        - Added tests for the new NHomologicalData class.
        - Added tests for triangulation dehydrations and rehydrations.
        - Initial work on tests for the NRational class.
    BUILD ENVIRONMENT:
        - Updated libtool from version 1.5a to 1.5.22 with Debian patches
          (required for MacOS support).

Version 4.3.1  [ 5 May, 2006 ]

    ENGINE:
        Class NClosedPrimeMinSearcher:
            - Improved speed by adding additional face pairing graph
              tests; see math.GT/0604584 for details.
            - Made a very slight improvement in speed by testing for
              extremely high degree edges.
            - Fixed memory leak (the destructor was not deallocating some
              internal arrays).
            - Minor changes to the behaviour of mergeEdgeClasses()
              (might return only some flags instead of all flags).
        Class NFacePairing:
            - New constructor for building the face pairing of an
              existing triangulation.
            - New routines hasOneEndedChainWithStrayBigon() and
              hasTripleOneEndedChain() for testing for more types of
              graphs that cannot appear in a closed census.
            - New routines hasSingleStar(), hasDoubleStar() and
              hasDoubleSquare() for investigating larger face pairing graphs.
            - New routines writeDot() and writeDotHeader() to assist
              with graph visualisation.
        Routine readOrb():
            - New routine for importing Orb / Casson triangulations;
              thanks to Ryan Budney for contributing this import filter.
        Routine readSnapPea():
            - Verifies that the first line of the file is "% Triangulation",
              instead of simply testing for the '%' and ignoring the rest.
    USER INTERFACE:
        - Now displays face pairing graphs in the triangulation viewer, using
          Graphviz for the rendering (see the Skeleton tab).  This required
          splitting the main Skeleton tab into two smaller child tabs.
        - New configuration options for the Graphviz executable and the
          default Skeleton child tab.
        - No longer crashes when attempting to clone the root packet
          (it simply displays an error message instead).
        - Added a workaround for the icon problems that arise when using
          GNU/Linux distributions with buggy icon themes.
        - Added 48x48 and 64x64 icons for Regina and its data files.
    TEST SUITE:
        - New tests for recognising bad and otherwise interesting subgraphs
          within face pairing graphs.

Version 4.3  [ 27 March, 2006 ]

    OVERALL:
        - Expanded the closed non-orientable census to 10 tetrahedra.
        - Expanded the closed orientable census to 10 tetrahedra, and
          split it into two data files (large and small).
        - Updated postal address for the Free Software Foundation.
        - Bibliographic updates for the reference manual.
        - Fixed some harmless compiler warnings, and tightened syntax
          to adhere to the requirements of gcc 4.1.
    ENGINE:
        Class LessDeref:
            - New utility class for working with pointers in the Standard
              Template Library.
        Class NGluingPerms, NGluingPermSearcher, NClosedPrimeMinSearcher:
            - Significant overhaul.
            - Moved gluing permutation search routines into new classes
              NGluingPermSearcher and NClosedPrimeMinSearcher.
            - Supports partial depth-based searching (by passing a
              non-negative depth parameter to the new runSearch() routine).
            - Tracks both vertex and edge links using a modified union
              find structure to prune more braches of the search tree
              where possible.  This makes an incredible difference to the
              census running time.  Pruning takes place on non-orientable
              vertex links, too many or too few vertices or edges, low
              degree or invalid edges, conical faces, and L(3,1) spines.
        Class NGraphLoop, NGraphPair, NGraphTriple:
            - New families of graph manifolds.
        Class NKnot:
            - Removed this unwritten placeholder class.
        Class NLayering:
            - New class to help follow through layerings of tetrahedra
              within a triangulation.
        Class NLayeredSolidTorus:
            - New routine formsLayeredSolidTorusTop() for finding an LST
              from the top end instead of the bottom.
            - New routine transform() for following through an isomorphism.
        Class NLayeredTorusBundle, NTxICore, NTxIDiagonalCore, NTxIParallelCore:
            - Added for recognition of layered surface bundles.
        Class NListOnCall:
            - New class for expensive and rarely used hard-coded lists.
        Class NManifold:
            - Routine writeTeXName() no longer provides wrapping dollar signs.
            - New operator < for ordering manifolds deterministically.
        Class NMatrix2:
            - New specialised class for working with 2-by-2 integer matrices.
        Class NPacket, NPacketListener:
            - New NPacket routine sortChildren().
            - Packet listeners are now unregistered immediately *before*
              packetToBeDestroyed() is called.  This avoids unpleasantries
              when a listener tries to unregister itself during this call.
        Class NPerm:
            - The assignment operator now returns a reference instead of void.
        Class NSatAnnulus, NSatBlock, NSatRegion, NBlockedSFS, NBlockedSFSLoop,
                  NBlockedSFSPair, NBlockedSFSTriple, NPluggedTorusBundle,
                  plus subclasses and other support structures:
            - New classes for recognising and describing Seifert fibred spaces
              and other graph manifolds that are built using saturated blocks.
        Class NSFS, NExceptionalFibre:
            - Removed; see below.
        Class NSFSpace, NSFSFibre:
            - Complete overhaul of the Seifert fibred space classes.
            - Now more general, supporting both orientable and
              non-orientable 3-manifolds as well as base orbifolds with
              reflector boundary components.
            - Classes have been renamed from the old NSFS / NExceptionalFibre
              to make it clear that large-scale changes have taken place.
        Class NSFSAltSet:
            - New class for finding alternative simple representations of
              the same bounded Seifert fibred space.
        Class NSnapPeaTriangulation:
            - Added a boolean argument to the constructor that permits the
              SnapPea kernel to work with closed triangulations if the user
              really wants to allow it.
        Class NStandardTri:
            - Routine writeTeXName() no longer provides wrapping dollar signs.
        Class NTorusBundle:
            - New class of 3-manifolds describing torus bundles over the
              circle.
        Class NTriangulation:
            - Combined isomorphism and subcomplex testing routines into
              a single all-in-one routine to avoid excessive code reuse.
            - Added new subcomplex testing routine findAllSubcomplexesIn(),
              in which all matches (not just the first) are returned.
            - Routines getTetrahedronIndex(), getComponentIndex(),
              getBoundaryComponentIndex(), getFaceIndex(), getEdgeIndex()
              and getVertexIndex() now returned signed instead of unsigned
              longs, so that -1 can be returned if the object could not
              be found.
    USER INTERFACE:
        - Added a configuration option that allows the SnapPea kernel to
          work with closed triangulations.
        - Fixed the crash when deleting a triangulation that is currently the
          target of an isomorphism/subcomplex test.
        - Fixed a crash that sometimes occurs in large files when deleting
          a triangulation that is currently being viewed.
        - Fixed extremely slow updates in the triangulation composition tab
          for very large data files.
        - Text and script packets now open with the cursor at the top
          instead of the bottom.
    PYTHON:
        Class NSnapPeaTriangulation:
            - Offers the additional zero-argument routine volumeWithPrecision()
              as a way of returning the precision of the volume calculation.
    UTILITIES:
        tricensus-mpi:
            - Significant overhaul.
            - Now supports finer-grained subsearches via --depth.
            - Better logging.
            - Only writes .rga data files for cases in which at least
              one triangulation was found.
            - New option --dryrun for a quick overview of the search space.
        tricensus-mpi-status:
            - New tool for parsing tricensus-mpi logs.
        trisetcmp:
            - Support subcomplex testing as well as isomorphism testing.
    TEST SUITE:
        - Don't enforce precision limits for degenerate snappea volume
          testing, to allow for flexibility in floating point behaviours
          of different chipsets.
        - Added tests for NIsomorphism.

Version 4.2.1  [ 18 September, 2005 ]

    OVERALL:
        - Added a chapter on imports and exports to the reference manual.
        - Expanded the closed non-orientable census to eight tetrahedra.
    ENGINE:
        Overall structure:
            - Fixed "regina-engine-config --cflags", which wrote includes
              for Regina's dependencies but not for Regina itself (sigh).
        Class NIsomorphism:
            - New routine random() for generating random isomorphisms.
            - New routine apply() for permuting the tetrahedra and
              vertices/faces of an existing triangulation.
            - New routine isIdentity() for testing for identity isomorphisms.
        Routine writeSnapPea():
            - Add a precondition that the triangulation has no boundary faces.
    USER INTERFACE:
        - Refuse to export a triangulation to SnapPea format if it
          has boundary faces.
    UTILITIES:
        trisetcmp:
            - New utility for comparing two different sets of triangulations.

Version 4.2  [ 7 July, 2005 ]

    ENGINE:
        Overall structure:
            - Included portions of the SnapPea kernel!  Thanks again to
              Jeff Weeks for his support.
            - Added a regina-engine-config script to make it easier to
              build Regina's calculation engine into other applications.
        Class NExampleTriangulation:
            - Added to facilitate construction of several different
              ready-made sample triangulations.
        Class NFacePairing:
            - New routine hasWedgedDoubleEndedChain.
        Class NLayeredSolidTorus:
            - New routine isLayeredSolidTorus for classifying an entire
              triangulation component.
        Class NPacketListener:
            - Added an extra boolean argument to childWasRemoved() to indicate
              the situation in which the parent is also being destroyed.
        Class NSnapPeaCensusManifold, NSnapPeaCensusTri:
            - Added to aid recognition of very small SnapPea census
              triangulations.
        Class NSnapPeaTriangulation:
            - Added to give Regina triangulations access to the SnapPea kernel.
        Class NTriangulation:
            - New routine finiteToIdeal() for extending a triangulation.
            - New routines insertConstruction() and dumpConstruction() to
              make it easier to hard-code triangulations in source code.
            - Fixed vertex link calculations, which were previously
              incorrect if a triangulation contained invalid edges.
            - Fixed bug in twoZeroMove() which caused a crash in some cases
              involving triangulations with boundary.
        Class NTrivialTri:
            - Added recognition of one-tetrahedron balls.
    USER INTERFACE:
        - Include several example triangulations in the triangulation
          creation dialog.
        - Allow exporting a triangulation to C++ source.
        - Renamed "Ideal to Finite" as "Truncate Ideal Vertices" in the menu.
        - Include a padlock in the corner of a packet icon if the packet
          is uneditable.
        - Tighter thread safety in the GUI.  This is required because some
          calculations (such as surface enumeration) run in a separate thread.
        - Worked around a Qt bug that caused a crash when pressing a key in
          a table of normal surfaces or matching equations.
        - Fixed a bug in which GAP output was unparseable due to GAP
          inserting spaces where Regina was not expecting them.
    UTILITIES:
        tricensus-mpi:
            - New census manager for use on MPI-enabled clusters.
    TEST SUITE:
        - Added tests for SnapPea calculations.
        - Further additions to the triangulation tests, in particular
          involving invalid and non-standard triangulations.
        - Beginning of a series of tests for elementary moves.
    BUILD ENVIRONMENT:
        - Updated libtool to version 1.5a.  Hopefully this will make
          things better for Darwin/Fink.
        - Requires KDE >= 3.2, so that the XDG applications directory can
          be used for the desktop file.
        - Verifies in the configure script that shared libraries are
          enabled where necessary (i.e., in the KDE and Python interfaces).
        - Better magic in the configure script for finding the correct
          boost.python libraries.
        - Fixed a bug in the configure script whereby -g stripping was
          too agressive, resulting in a compile failure for the python
          interface under some environments.

Version 4.1.3  [ 25 July, 2004 ]

    OVERALL:
        - Included the closed hyperbolic census of Hodgson and Weeks.
        - Made explicit in the reference manual introduction where the
          example files can be found.
    PYTHON:
        - For most objects, == now works like C++ pointer equality
          instead of Python object equality.  That is, it tests whether
          the Python wrappers point to the same C++ object, not whether
          the Python wrappers are in fact the same wrapper.
        - Fixed scripting in the GUI, which was broken with python 2.3
          (indented blocks were treated as complete after just one line).
        - Added a sample python session illustrating progress reporting.
    USER INTERFACE:
        - Added an "Open Example" menu item for easy access to the
          sample files.
        - Allow the choice of text editor component to be configured.
        - Several fixes to make Regina work properly with the vimpart,
          including work-arounds for bugs in the vimpart itself.
        - Fixed the massive resource drain while editing a script's
          variable table in a heavily populated data file.
        - Fixed crashes that occured when deleting packets while a
          drop-down packet chooser is in use elsewhere.
        - Tightened up the handling of read-only mode for internal
          components.  Also removed some loopholes that allowed editing
          of uneditable packets.
        - Improved handling of keyboard focus.
        - Changed "Python Reference" to point to the modules index
          instead of the title page.

Version 4.1.2  [ 14 June, 2004 ]
    OVERALL:
        - Updated configure scripts so that the python interface builds
          out of the box on a larger number of platforms (specifically Red Hat
          and Fedora Core are now supported).  Many thanks to Craig Macintyre
          for his patience and assistance with this.
        - More updates to the troubleshooting section; overhauled the
          README.txt and website to hopefully make everything clearer
          and the important information easier to find.
        - Added a suggested form for citing Regina.
        - Updated INSTALL.txt to reflect current --prefix guessing.
    ENGINE:
        Class NTriangulation:
            - Added simplifiedFundamentalGroup() to allow external bodies
              such as GAP to simplify group presentations.
    USER INTERFACE:
        - Allow users to simplify fundamental groups using GAP.
        - Added "Education" to the categories for the desktop file, since
          KDE seems adamant about having no separate maths/science menu.
          Anything is better than showing up in Lost & Found. :)
        - Fixed compile error when building against an STL-enabled Qt
          (thanks to Robert Myers for spotting this one).

Version 4.1.1  [ 24 April, 2004 ]
    USER INTERFACE:
        - Fixed compile error when building against Python 2.3.
        - Added "What's This?" button to main/packet window decorations.

Version 4.1  [ 7 March, 2004 ]
    OVERALL:
        - Further enhancements to the reference manual, including more
          detailed explanations in the main body as well as a new index.
    ENGINE:
        Class NNormalSurface:
            - New routine doubleSurface().
            - Added findNonTrivialSphere() and findVtxOctAlmostNormalSphere()
              to support 0-efficiency algorithms.
        Class NProgress:
            - Added timing utilities getRealTime() and totalCPUTime().
        Class NTriangulation:
            - New 0-efficiency / decomposition routines splitIntoComponents(),
              connectedSumDecomposition(), isThreeSphere(), knowsThreeSphere()
              and makeZeroEfficient().
            - New Seifert fibred space constructions insertAugTriSolidTorus()
              and insertSFSOverSphere().
    USER INTERFACE:
        - Actions specific to each packet type now appear in their own
          context-specific menus, i.e., a "Triangulation" menu appears
          when a triangulation is open, etc.
        - Added "Please Wait" dialogs during slow operations.
        - Thorough "What's This?" support and tooltips offered across the
          entire user interface.
        - New tip-of-the-day support.
        - More icons for triangulation actions.
        - Updated the .desktop file and mimetype tests to work correctly
          with KDE 3.2.
    UTILITIES:
        tricensus:
            - Fixed bug in which --genpairs created empty output files.
    TEST SUITE:
        - Added tests for connected sum decomposition.

Version 4.0.1  [ 26 January, 2004 ]
    OVERALL:
        - The ./configure script now takes a guess at the correct --prefix,
          runs sanity tests upon it and insists upon Qt >= 3.2.
        - Regina now ships with pregenerated manpages to avoid the need
          for docbook-utils and its complicated dependencies.
        - The troubleshooting section of the reference manual now
          includes compile-time problems and discusses the test suite.
    USER INTERFACE:
        Class GridListViewItem:
            - Added to centralise support for list views with grids.
            - Fixed a compile error with Qt versions 3.1 and earlier.

Version 4.0  [ 20 December, 2003 ]
    ENGINE:
        Class NAngleStructureList:
            - Enumeration routine now takes an optional progress manager
              and can run in a separate thread.
        Class NGroupPresentation:
            - Improved simplification of group presentations.
        Class NNormalSurface:
            - Using NProperty to store calculable properties.
            - Using NTriBool instead of 1/-1/0 for orientability,
              two-sidedness and connectedness.
        Class NNormalSurfaceList:
            - Enumeration routine now takes an optional progress manager
              and can run in a separate thread.
        Class NProgress:
            - Removed isCancellable() since this is not really necessary;
              an operation may simply choose not to poll for cancellation
              requests.
            - Removed isChanged() and made the changed flag protected so
              subclasses can modify it directly.
            - Requires subclasses to adjust the changed flag on all
              public access/update routines.
            - Made cancel() const so that reading threads can use it.
        Class NProgressNumber:
            - New convenience routine incCompleted().
            - New lookup routine getNumericState().
        Class NTriBool:
            - Added for representing three-way booleans.
        Class NVectorMatrix, NVectorUnit:
            - Modification routines throw exceptions if called.
    USER INTERFACE:
        Class NAngleStructureCreator:
            - Displays progress and allows cancellation.
        Class NNormalSurfaceCreator:
            - Displays progress and allows cancellation.
        Class ProgressDialogNumeric:
            - Added for displaying progress using regina::NProgressNumber.
        Class PythonConsole:
            - Added Help menu for displaying scripting documentation.
        Class ReginaMain:
            - Added Python reference to Help menu.
        Class PythonManager:
            - New static routine openPythonReference() for displaying
              calculation engine documentation.
    TEST SUITE:
        - Added tests for angle structure enumeration and analysis.
        - Expanded normal surface tests to include trivial triangulations.
        - Added tests for fundamental group calculation and recognition.

Version 3.97  [ 24 November, 2003 ] - Final prerelease for version 4.0.
    OVERALL:
        - Ships with the 7-tetrahedron closed non-orientable census.
        - Compile-time configuration uses different tests for pthread, since
          the old tests were broken on some systems.
        - Added a Python caveats section to the reference manual.
    ENGINE:
        Class NEdge, NVertex:
            - Added getDegree() as an alias for getNumberOfEmbeddings().
        Class NGluingPerms:
            - Incorporate new results that allow us to discard more face
              pairings in a non-orientable census (see math.GT/0307382:v2).
        Class NLayeredSolidTorus:
            - Added routine flatten() to flatten a layered solid torus
              to a Mobius band.
        Class NMutex::MutexLock:
            - Added reference constructor as well as a pointer constructor.
        Class NNormalSurface, NNormalSurfaceVector:
            - Added routine isCentral() to test for central surfaces.
        Class NSimpleSurfaceBundle, NTrivialTri:
            - Added for recognition of trivial non-orientable triangulations.
    USER INTERFACE:
        Overall structure:
            - Split out common shell/part material into the separate
              library libregina-kdecommon.
            - Integrated python scripting into the graphical user interface.
              This is contained within libregina-kdecommon and is accessible
              through the main menu/toolbar and through the script editor.
            - Avoid using flat buttons where possible.
        Class ExportDialog:
            - New routine validate() to detect when there are no packets
              suitable for export.
        Class ExtTabCtl, PacketTabbedUI, PacketTabbedViewerTab:
            - Allow changing the current tab (this required a new extension
              class to KTabCtl).
        Class ImportDialog, NewPacketDialog:
            - New routine validate() to detect when there are no
              suitable parent packets.
        Class NNormalSurfaceCreator:
            - Allow the default coordinate system to be configured.
        Class NScriptUI, NTextUI:
            - Fixed problems with word wrapping and line endings in
              the embedded text editor.
        Class NTriangulationUI, NTriAlgebraUI:
            - Allow the initially visible tabs to be configured.
        Class NTriGluingsUI:
            - Implemented census lookup for triangulations.
            - Fixed a bug in the updating of tetrahedron labels when other
              tetrahedra are removed from a triangulation.
        Class PacketChooser:
            - New routine hasPackets() to detect empty packet choosers.
        Class ReginaPart:
            - Make File/Save fall back to File/Save-As for new files.
            - Make File/Save-As respect the automatic file extension setting
              and also check whether the selected file already exists.
        Class ReginaPreferences, ReginaPrefSet:
            - Many new configuration options.  In addition to those
              mentioned above, census data files and Python options can
              also be configured.
    TEST SUITE:
        - Added tests for normal surface enumeration and analysis.

Version 3.96  [ 31 October, 2003 ] - Second prerelease for version 4.0.
    OVERALL:
        - Added surface filter documentation to the reference manual,
          which brings it completely up to date with the GUI.
    ENGINE:
        Overall structure:
            - Yet more routines made const.
        Class NAbelianGroup:
            - Added global comparisons isTrivial() and operator ==.
        Class NMutex:
            - Now uses inner class MutexLock for locking and unlocking.
        Class NProperty, NPropertyBase, StoreValue, StoreConstPtr,
                StoreManagedPtr:
            - New classes for management of calculable object properties.
        Class NPropertyHolder:
            - Moved most of its functionality directly into NFile and
              replaced what was left with the new class NFilePropertyReader.
        Class NTriangulation:
            - Turaev-Viro invariants are now cached; this includes a new
              routine allCalculatedTuraevViro().
        Class ShareableObject:
            - Now derives from regina::boost::noncopyable.
    USER INTERFACE:
        Class NTriAlgebraUI:
            - Redesigned the algebra viewer to make it easier to read.
            - Incorporatd Turaev-Viro invariants into the UI.
        Class NTriCompositionUI:
            - Incorporated isomorphism / subcomplex testing into the UI.
            - Fixed crash when refreshing.
        Class PacketTabbedViewerTab:
            - Added to support tabbed UIs within tabbed UIs.
        Class ReginaPart:
            - Make the main window splitter remember its place when packet
              panes are changed.
    TEST SUITE:
        - Added tests for trivial triangulations and property handling.

Version 3.95  [ 12 October, 2003 ] - Prelease for version 4.0.
    GRAPHICAL USER INTERFACE:
        - Rewrote the entire user interface in C++ using the KDE
          libraries.  The result is much faster, cleaner and easier to
          maintain.  The old Java user interface is gone!  The user
          interface can be started by running "regina-kde".
    PYTHON:
        - Python scripting rewritten to use standard Python, not Jython.
          A python session can be started by running "regina-python".
        - The Python API has changed to be much more faithful to the C++
          calculation engine, especially with respect to global and static
          routines and constants.
        - All classes now sit directly within the module regina.
    ENGINE:
        Overall structure:
            - Fixed minor memory leaks.
            - Made more routines const.
            - Beginning to incorporate std::auto_ptr.
        Class Engine:
            - Removed since this is no longer necessary with the new
              python bindings.
        Class NAngleStructureList:
            - Made the enumerating constructor private and added the
              public replacement enumerate().
        Class NAugTriSolidTorus:
            - Changed to fit into the new NStandardTriangulation structure.
        Class NFacePairings:
            - Fixed bug in isCanonical().
        Class NGluingPerms:
            - Further optimisations for non-orientable census generation.
        Class NGroupPresentation:
            - Slightly improved group recognition.
        Class NHandlebody:
            - Added as a new 3-manifold class.
        Class NIsomorphism:
            - Allows an isomorphism with 0 tetrahedra.
            - Now derives from ShareableObject.
            - Supports boundary incomplete isomorphisms as well as
              complete isomorphisms.
            - Changed return types of const lookup routines from
              const T& to just T.
        Class NL31Pillow:
            - New class for identifying particular L(3,1) triangulations.
        Class NLargeInteger:
            - Added constructor and assignment taking a const std::string&.
            - Routine stringValue() now returns a std::string, not a char*.
        Class NLensSpace:
            - Changed to fit into the new NManifold structure.
        Class NLayeredChain:
            - Changed to fit into the new NStandardTriangulation structure.
        Class NLayeredLensSpace:
            - Changed to fit into the new NStandardTriangulation structure.
        Class NLayeredLoop:
            - Changed to fit into the new NStandardTriangulation structure.
        Class NLayeredSolidTorus:
            - Changed to fit into the new NStandardTriangulation structure.
            - Renamed isLayeredSolidTorusBase() to
              formsLayeredSolidTorusBase().
        Class NManifold:
            - New class to represent a 3-manifold irrespective of its
              triangulation.
        Class NNormalSurfaceList:
            - Made the enumerating constructor private and added the
              public replacement enumerate().
        Class NPacket, NPacketListener:
            - The NPacket destructor now orphans the packet if this has
              not already been done.
            - Added event listening for packets, including new class
              NPacketListener, new routines NPacket::listen(),
              NPacket::isListening() and NPacket::unlisten() and new
              class NPacket::ChangeEventBlock.
            - New NPacket routines moveUp(), moveDown(), moveToFirst()
              and moveToLast().
            - Reclassified member variables from protected to private.
        Class NPerm:
            - Routines edgeDescription() and faceDescription()
              implemented in the calculation engine.
        Class NPlugTriSolidTorus:
            - Changed to fit into the new NStandardTriangulation structure.
        Class NSFS:
            - Changed to fit into the new NManifold structure.
            - New overloaded routine insertFibre(long, long).
            - No longer allows illegal (0,k) fibres to be added.
            - More common names recognised.
        Class NSnappedBall:
            - Changed to fit into the new NStandardTriangulation structure.
            - Renamed isSnappedBall() to formsSnappedBall().
        Class NSpiralSolidTorus:
            - Changed to fit into the new NStandardTriangulation structure.
            - Renamed isSpiralSolidTorus() to formsSpiralSolidTorus().
        Class NStandardTriangulation:
            - New class to represent a standard triangulation.
        Class NTriSolidTorus:
            - Changed to fit into the new NStandardTriangulation structure.
            - Renamed isTriSolidTorus() to formsTriSolidTorus().
        Class NTriangulation:
            - New routine turaevViro() to calculate Turaev-Viro invariants.
            - Changed isIsomorphicTo() to return an entire isomorphism,
              not just whether an isomorphism exists.
            - New routine isContainedIn() to test for boundary
              incomplete isomorphisms.
        Routine isKnownSFS():
            - Removed in favour of
              NStandardTriangulation::isStandardTriangulation().
        File dehydration.h:
            - New routine readDehydrationList().
        File nsnappea.h:
            - Renamed to snappea.h.
        File stringutils.h:
            - Added routines startsWith() and stripWhitespace().

Version 3.2  [ 22 June, 2003 ] - The post-thesis release!
    OVERALL:
        - Added file format documentation to reference manual.
        - Calculation engine test suite is much enhanced.
        - Closed orientable census, closed non-orientable census and
          splitting surface signature census added to example files.
        - PhD thesis submitted on 30 May, 2003!
    ENGINE:
        Overall structure:
            - Using C++-style casts instead of C-style casts.
            - Signedness of chars is explicitly specified where it matters. 
        Class NBoolSet:
            - Using unsigned chars for byte codes.
        Class NCensus:
            - New constant PRUNE_P2_REDUCIBLE.
        Class NFacePair:
            - New class for working with pairs of face numbers.
        Class NFacePairing:
            - Added convenience operator [].
            - Added hasTripleEdge(), hasBrokenDoubleEndedChain(),
              hasOneEndedChainWithDoubleHandle() and associated routines.
            - Renamed private routine isCanonical() to
              isCanonicalInternal(), added public routine isCanonical()
              with no preconditions.
        Class NGluingPerms:
            - Uses new NFacePairing routines to identify certain
              situations in which no solutions are possible.
            - Uses a completely redesigned algorithm in the closed
              prime minimal P2-irreducible case.
            - Added pruning during permutation generation to eliminate
              edges identified with themselves in reverse.
            - Added pruning using low-degree edges in the non-orientable
              P2-irreducible case.
            - Allows a null automorphism list in findAllPerms().
        Class NLayeredLoop:
            - Renamed getIndex() to getLength().
        Class NLayeredSolidTorus:
            - Fixed a bug in isLayeredSolidTorusBase() that generated
              false positives in ideal triangulations.
        Class NNormalSurface:
            - Added routine knownCanCrush().  Currently this routine
              is next to useless; it is expected to be enhanced with
              future releases.
            - Property queries are now const since internal cached
              properties are declared mutable.
        Class NPerm:
            - Using unsigned chars for permutation codes.
        Class NPrismSpec, NPrismSetSurface:
            - New classes for dealing with triangular prisms defined by
              slicing along normal quads in a tetrahedron.  Currently
              these classes do very little.
        Class NSFS:
            - Better recognition of common names; now recognises all
              spaces with finite fundamental group.
        Class NTetFace:
            - Added routine setFirst().
            - Added copy constructor.
            - Operators ++ and -- are now implemented in all forms
              (++x, x++, --x, x--) and all have return values.
        Class NTriangulation:
            - New routine insertLayeredLoop().
            - 0-efficiency testing is done in quad space where possible.
            - Fixed a bug in which getHomologyH1Bdry() gave incorrect
              answers if the skeleton had not already been calculated.
            - New boundary queries hasTwoSphereBoundaryComponents() and
              hasNegativeIdealBoundaryComponents().
            - Renamed insertLensSpace() to insertLayeredLensSpace().
            - Interface-only skeletal query routines are now also
              implemented in the C++ calculation engine.
        Routine prior(), next():
            - Copied from the Boost C++ libraries for easy access to
              prior and following iterators.
    JAVA USER INTERFACE:
        Overall structure:
            - Incorporated engine enhancements listed above.
    UTILITIES:
        regconcat:
            - New utility for combining several data files.
        tricensus:
            - New option --minprimep2 for P2-irreducibility.
            - Explicitly verifies that all face pairings supplied on
              standard input are in canonical form.

Version 3.1  [ 18 October, 2002 ]
    OVERALL:
        - Added calculation engine test suite.
        - Environment variables now take precedence over configuration
          files when running the startup script.
        - Build process now uses standard autoconf/automake structure.
    ENGINE:
        Overall structure:
            - Added support for multiple vertex enumeration engines.
        Class NCensus:
            - Redesigned to do its work through classes NFacePairing and
              NGluingPerms.
            - Added support for arbitrary criterion functions.
            - Added support for splitting a census into pieces.
        Class NCompConstraint, NCompConstraintSet:
            - Added.
        Class NConeRay:
            - Removed in favour of new class NRay.
        Class NFacePairing, NGluingPerms:
            - Added to bear the brunt of census generation.
            - Massive optimisations and rewrites throughout census code.
            - Removed all thread yields, which were causing processes to
              have 0.0% CPU time on some systems.
        Class NIndexedArray:
            - Added routine validate().
        Class NKnot:
            - New (but incomplete) knot/link class.
        Class NLensSpace, NSFS:
            - Added getCommonName().
        Class NNormalSurfaceVector:
            - Replaced isCompatibleWith() with makeEmbeddedConstraints().
        Class NPerm:
            - Routine isIdentity() now implemented in C++ engine.
            - New routine setPerm(int, int).
        Class NTriangulation:
            - Fixed idealToFinite() which was newly broken in Regina 3.0.
            - Routine intelligentSimplify() now tries random 4-4 moves.
            - New routine collapseEdge().
            - Routine simplifyToLocalMinimum() now make boundary moves last
              and does not do book opening at all.
            - Fixed bug in 2-3, 3-2 and 4-4 moves that appears when faces of
              the old tetrahedra are glued to each other.
        Class NRay:
            - Added to replace old class NConeRay.
        Class NVector:
            - Added negate().
        Class NVertexEnumerator, NDoubleDescriptor:
            - Added to bear the brunt of normal surface enumeration and
              to allow different enumeration engines to be plugged in.
            - Caches some frequent calculations, resulting in a startling
              performance increase.
        Routine getVersionString(), getVersionMajor(), getVersionMinor(),
                testEngine():
            - Moved to engine.h and added to the C++ calculation engine.
        Routine reducedMod():
            - Fixed bug in the midpoint case.
        File nfile.h:
            - New file format constants to replace the constants removed
              with regina.h.
        File nhashmap.h, nhashset.h:
            - Added to deal with differing STL extension installations.
        File nknownmanifold.h:
            - Added global 3-manifold recognition routines.
        File nperm.h:
            - New arrays allPermsS2Inv, allPermsS3Inv, allPermsS4Inv.
        File regina.h:
            - Removed along with the constants it defined.
    JAVA USER INTERFACE:
        normal.algorithm.Algorithm:
            - Fixed bug in which isPacketEditable() was enforced even for
              non-modifying algorithms.
        normal.console.JPythonPacketConsole:
            - Optionally creates an additional Jython variable for direct
              access to some preselected packet within the tree.
        normal.mainui.NormalFrame:
            - New Jython consoles create an additional variable for the
              packet currently selected in the visual tree.
        normal.packetui.surfaces.NSFPropertiesEditor:
            - Don't enforce Euler characteristic <= 2 (singular surfaces
              can give other values).
    UTILITIES:
        tricensus:
            - Completely redesigned interface (now command-line based).
            - Supports splitting a census into pieces.
        tricensus-manager:
            - New utility for distributing a census amongst several machines.

Version 3.0  [ 28 June, 2002 ] - The "XML, about bloody time" release.
    OVERALL:
        - Moved from old impenetrable binary data files to new
          compressed XML data files.
        - Introduced various command-line utilities (see UTILITIES below).
        - Removed CORBA engine/interface.  It was too much hassle to
          maintain, and with Regina building on more platforms it has
          lots much of its usefulness.
        - JNI engine no longer requires autogenerated JNI headers.
        - Reference manual much enhanced.
    ENGINE:
        Overall structure:
            - Moved entire calculation engine into namespace regina.
            - The Great STL Port: replaced hand-rolled container classes
              with Standard Template Library classes.
            - Added numerous XML-related routines and classes.
            - Modified to also build under gcc3.
            - Removed configuration macro __MUTE_WARNINGS.
            - Replaced configuration macros __NO_IOS_NOCREATE and
              __NO_RAW_CASTING with their negations __USE_IOS_NOCREATE and
              __USE_RAW_CASTING which are optional in all situations.
            - Added configuration macros __HASH_NAMESPACE and
              __NO_NAMESPACE_ALIASES.
        Class NBoolVector, NDoubleList, NDynamicArray, NHashSet,
                NInfiniteArray, NIntMap, NOrderedPair, NPointerSet,
                NQueue, NSet, NStack, NString, NStringPair and associates:
            - All removed in favour of Standard Template Library classes.
        Class NAngleStructureList, NNormalSurfaceList:
            - New nested classes StructureInserter / SurfaceInserter.
        Class NAugTriSolidTorus, NTriSolidTorus:
            - Supports multiple ways of attaching layered chains.
        Class NFileInfo:
            - Added.
        Class NGroupExpressionTerm:
            - Changed from simple ordered pair to its own full class.
        Class NIndexedArray:
            - Added.
        Class NJNIEnumeration:
            - Added to aid the Java-C++ link.
        Class NLargeInteger:
            - Added third error-detection parameter to constructor
              NLargeInteger(const char*, int).
        Class NLayeredChainPair, NPlugTriSolidTorus:
            - Added for further subcomplex recognition.
        Class NLayeredLoop:
            - Added routine getSeifertStructure().
        Class NLensSpace:
            - Fixed bug causing reductions to be sometimes non-optimal
              (although still correct) - see modularInverse() notes below.
        Class NLocalFileResource:
            - Replaced static members MODE_READ, MODE_WRITE with static
              routines sysModeRead(), sysModeWrite().
        Class NNormalSurface:
            - Added routines isVertexLink() and isThinEdgeLink().
        Class NPacket:
            - Added routines to support arbitrary packet tags.
            - Finally changed getPacketName() to getPacketTypeName().
            - Removed tidyReadPacket().
        Class NPerm:
            - Added isPermCode().
        Class NScript:
            - Changed list of variables to a proper map and removed routines
              getVariableIndex() and removeVariableAt().
            - Insistance on unique variable names; in enforcing this
              routine addVariable() now returns bool.
        Class NSFS:
            - Added routine getHomologyH1().
        Class NSignature, NSigCensus, NSigPartialIsomorphism:
            - Added to deal with splitting surface signatures.
        Class NTriangulation:
            - Uses NIndexedArrays for skeletal elements for fast index lookup.
        File boostutils.h:
            - Added utility classes from the Boost C++ libraries.
        File hashutils.h:
            - Added various hash functions.
        File memutils.h:
            - Added allocation/deallocation functions.
        File stlutils.h:
            - Added extension Standard Template Library utility classes.
        File stringutils.h:
            - Added miscellaneous string manipulation routines.
        File zstream.h:
            - Added compressing and decompressing I/O streams.
        Routine modularInverse():
            - Fixed a rather nasty bug in gcdWithCoeffsInternal() that
              caused modularInverse() to sometimes give wrong answers.
        Routine readFileMagic():
            - Added to provide a format-independent file reader.
    JAVA USER INTERFACE:
        Overall structure:
            - Incorporated engine enhancements listed above.
        normal.console:
            - Added class JPythonPacketConsole.
        normal.engine.implementation.jni.JNIShareableObject:
            - Added static method sameCppPtr() which is necessary with gcc3.
        normal.exports:
            - Now exports to three different Regina data file formats.
        normal.mainui:
            - File information dialog is somewhat more informative.
        normal.mainui.NormalFrame:
            - Now supports opening a Jython console linked to a packet tree.
        normal.mainui.PacketPane:
            - Renamed getUI() to getPacketUI() to avoid clashing with j2sdk1.4.
        normal.options.NormalOptionSet:
            - Default "Display Icon" option changed from true to false.
        normal.packetui:
            - Resizing one coordinate column in various coordinate
              viewers now resizes all coordinate columns.
    UTILITIES:
        regconvert, regfiledump, regfiletype, sigcensus, tricensus:
            - Added.

Version 2.4  [ 4 April, 2002 ]
    OVERALL:
        - Much enhanced documentation.
        - Added SnapPea census and knot/link census to examples.
        - Added functionality changelog (HIGHLIGHTS.txt).
        - Added prepackaged Jython library directory.
    ENGINE:
        Overall structure:
            - Moved engine/imports to engine/foreign.
        Class NAngleStructure, NAngleStructureList, NAngleStructureVector:
            - Added.
        Class NConeRay:
            - Now a new class of its own accord, derived from
              NVectorDense and created to allow vertex solution routines
              to work in contexts outside normal surfaces.
        Class NNormalSurface:
            - Added getName() and setName().
        Class NNormalSurfaceVector:
            - Now derives from NConeRay, to which some routines have moved.
            - Changed declaration of createNonNegativeCone() to return
              cone faces as well as extremal rays.
        Class NPerm:
            - Added toString().
        Class NTriangulation:
            - Uses fewest possible tetrahedra in insertLensSpace().
            - Added insertRehydration(), makeDoubleCover().
        File nperm.h:
            - Added constant arrays orderedPermsS4, orderedPermsS3.
        Routine intersectCone():
            - Works with more generic cones by requiring cone faces to
              be passed as well as extremal rays.
        Routine writeSnapPea():
            - Added.
    JAVA USER INTERFACE:
        Overall structure:
            - Added readline/editline support using Bablok's wrapper classes.
            - Converted option REGINA_JNIDIR to a list of directories.
            - Option REGINA_OPTIONS_GLOBAL defaults to REGINA_HOME if
              /etc/regina does not exist.
        normal.ApplicationShell.CommandLineArguments:
            - Added.
        normal.Shell:
            - Allow filenames to be specified on the command-line.
            - Removed some arguments from getParameter().
            - Added getFileParameters().
        normal.exports:
            - Added class SnapPeaExporter.
        normal.imports:
            - Added class DehydrationImporter.
        normal.mainui:
            - Added more keyboard accelerators.
        normal.mainui.FilePane:
            - Added getFileType() and setFileType().
        normal.mainui.NormalFrame:
            - Added File->Info menu item.
            - Made various routines public so outsiders can manipulate
              the primary frame.
        normal.packetui.surfaces.CoordinateViewer:
            - Inserted editable surface name as first column.
        normal.packetui.triangulation.TriangulationCreator:
            - Creates triangulations from dehydration strings.

Version 2.3  [ 12 December, 2001 ] - The "Farewell Stillwater" release.
    OVERALL:
        - Makefile.options variables IDLTOJAVACLIENT and IDLTOCPPSERVER
          became IDLTOJAVA and IDLTOCPP with slightly more generic meanings.
    ENGINE:
        Overall structure:
            - Modified #includes to treat engine/engine, engine/jni
              and engine/corba as top-level include directories.
            - Removed config.h in favour of PD_MACROS in Makefile.options.
            - Removed configuration macros __NO_INCLUDE_PATHS and __BINARY_IO.
            - Introduced macro MY_ENGINE_OBJECT for CORBA wrapper classes.
            - Macros GET_ENGINE_OBJECT no longer crash when null is passed.
        Class NAugTriSolidTorus, NLayeredChain, NLayeredLoop, NLensSpace,
                NSFS, NSpiralSolidTorus, NTriSolidTorus:
            - New classes.
        Class NDiscSetSurface:
            - Modified parameters for adjacentDisc().
        Class NFace:
            - Added getType(), getSubtype(), isMobiusBand(), isCone().
        Class NHashSet, NHashSetIterator:
            - New classes.
        Class NNormalSurface:
            - Added crush().
            - Added isConnected(), isVertexLink(), isSplitting().
            - Fixed isOrientable() and added isTwoSided().
        Class NPacket:
            - Added makeUniqueLabels().
        Class NPerm:
            - Added operators = and != and constructor NPerm(const NPerm&).
        Class NTriangulation:
            - Added isZeroEfficient(), hasSplittingSurface(),
              knowsZeroEfficient() and knowsSplittingSurface().
            - Added extra condition to shellBoundary() covering two
              boundary faces plus two identified faces.
            - Added extra condition to twoZeroMove(NEdge*, ...) covering
              two boundary faces plus two identified faces.
            - Added fourFourMove().
        File ndisc.h:
            - Added routine discOrientationFollowsEdge().
        File nnormalsurface.h:
            - Added arrays triDiscArcs, quadDiscArcs, octDiscArcs.
        Routine hashMap(T*), hashMap(NString):
            - Added to support new class NHashSet.
        Routine readSnapPea():
            - Sets the new packet label to the SnapPea manifold name.
    JAVA USER INTERFACE:
        Overall structure:
            - Loading/saving local files is now possible even through CORBA!
            - Incorporated engine enhancements listed above.
            - Added Jython operator overloads to a number of classes.
        normal.engine.utilities:
            - Added NLargeInteger to replace java.math.BigInteger so
              Jython scripts can use native mathematical operators with
              arbitrary precision integers.
        normal.exports:
            - Created architecture for exporting to foreign file formats.
            - Added classes Exporter, ReginaExporter, ScriptExporter.
        normal.images:
            - A couple of new icons.
        normal.imports:
            - Redesigned import architecture; replaced old class
              ImportFilePane with new class Importer.
            - Imported packets now have appropriate packet labels (such
              as their names in the imported files).
            - The file dialog is now brought up before anything else is done.
            - Added classes ReginaImporter, ScriptImporter.
        normal.mainui.TopologyPane:
            - Fixed bug where icon was sometimes not displayed.
        normal.packetui:
            - Added a new TopologyPane argument to some routines to
              allow interfaces to manipulate the visual packet tree.
        normal.packetui.triangulation.CompositionViewer:
            - Displays more detailed information.
        normal.packetui.triangulation.SkeletonTableFrame:
            - Displays more details regarding face/vertex type.

Version 2.2  [ 7 October, 2001 ]
    OVERALL:
        - Documentation now DocBook-based; generates HTML and man pages.
        - Documentation now in docs/, not docs/normal/docs/.
        - Builds and runs under windows!
        - Added support for both global and local configuration files;
          configuration files are now called regina.conf.
        - Vastly reworked runtime scripts.
        - Tidied up Makefiles and CVS.
    ENGINE:
        Overall structure:
            - Ported CORBA stuff to omniORB3.
        Class NDoubleList, NDynamicArray:
            - Added operator = to the iterator classes.
        Class NEdge, NFace:
            - Added extra skeletal query routines.
        Class NGroupExpression, NGroupPresentation:
            - New classes.
        Class NLayeredLensSpace, NLayeredSolidTorus, NPillowTwoSphere,
                NSnappedBall, NSnappedTwoSphere:
            - New classes.
        Class NPacket:
            - Changed meaning of second (boolean) parameter to clone().
            - Added getNumberOfDescendants() and getNumberOfChildren();
              renamed totalTreeSize() to getTotalTreeSize().
        Class NTriangulation:
            - Added fundamental group as a new property.
            - Added a two-zero move about a vertex.
        File numbertheory.h:
            - Added modularInverse().
    JAVA USER INTERFACE:
        Overall structure:
            - Reads Regina options from directory $REGINA_OPTIONS_LOCAL
              and reads runtime options from system properties (which
              should be set by startup scripts).
            - Ported from JPython 1.1 to Jython 2.1-alpha1.
            - Now supports custom Jython libraries.
            - Improved support for mnemonics and keyboard accelerators.
            - Fixed tooltips in tables.
        normal.Application:
            - Moved fileExtension member into normal.mainui.FilePane subclasses.
        normal.Shell:
            - Dynamically finds JavaHelp classes so JavaHelp is not
              necessary for compilation.
            - Cleanly handles missing runtime options file.
            - Added a registry of all open Jython consoles.
        normal.algorithm:
            - Added class ElementaryMove.
        normal.console:
            - Major rearrangements; new class JPythonUtils now does most of
              the Jython work.
        normal.console.JPythonConsoleFrame:
            - Stores the root of the associated packet tree.
            - Allows saving the contents of the console to a file.
        normal.engine.implementation.corba.CORBAEngine:
            - Better error handling.
        normal.mainui:
            - Renamed SystemPane to TopologyPane and moved generic file
              editing functionality into FilePane to allow for editing
              different file types.
            - Much all-round cleaning up.
        normal.mainui.LibraryPane:
            - New class; allows editing of Jython libraries.
        normal.mainui.NormalFrame:
            - Moved console ownership routines into normal.Shell.
            - More appropriate enabling/disabling of menu items and buttons.
            - Edit menu hooks into current working file.
        normal.mainui.TopologyPane:
            - Closing a file closes all associated consoles.
            - Fixed the bug where double clicking on a tree item opens
              it three times.
            - Fixed bugs in the various fire... routines.
            - Improved interaction with the packet rename dialog.
            - Fixed the packet renaming bug in the visual tree display.
        normal.mainui.PacketTreeNode:
            - Replaced insertUnwrappedDescendants() with
              verifyDescendants() which actually does what it should; thus
              the refresh button now works properly.
            - Added findChildNodeIndex().
        normal.packetui.PacketUI:
            - Added subtreeWasDeleted().
        normal.packetui.packet.NContainerViewer:
            - Displays tree size statistics.
        normal.packetui.surfaces:
            - Coordinate tables in edge weight space now flag boundary edges.
        normal.packetui.surfaces.Coordinates:
            - Some routines now require the triangulation to be passed.
        normal.packetui.triangulation:
            - Pulled SkeletonTableFrame out into its own standalone class
              and turned it into a dialog.
        normal.packetui.triangulation.NTriangulationEditor:
            - Added triangulation component recognition.

Version 2.1.1a  [ 8 March, 2001 ]
    OVERALL:
        - Set up system for creating distributions.
        - Final tidying up for proper release.

Version 2.1.1
    OVERALL:
        - Added a CORBA interface to the engine.
        - Rearranged Makefiles and directory structure for CVS and
          SourceForge.
    ENGINE:
        Overall structure:
            - Split config.h into config.h and regina.h.
        Class Engine:
            - Formalised and slightly rearranged.
            - Added getVersion...() routines.
        Class NBoolSet:
            - Now passed as characters to and from external interfaces.
              Added getByteCode(), setByteCode() and fromByteCode() for
              this purpose.
        Class NNormalSurfaceList:
            - Added coordinate system FACE_ARCS; renumbered EDGE_WEIGHT.
        Class NPerm:
            - Now passed as characters to and from external interfaces.
        Class NTriangulation:
            - Added routine isStandard().
    JAVA USER INTERFACE:
        Overall structure:
            - Allows running as an applet as well as an application.
            - Class normal.Application now contains just global constants
              and a generic applet/application shell.  Class normal.Shell
              contains top-level Regina runtime routines and routines
              specific to the shell type (applet or application).
            - Made miscellaneous optimisations.
        normal.packetui.census.NCensusCreator:
            - Altered the boundary combo box strings to avoid
              misinterpretation.
        normal.packetui.surfaces.NSurfaceFilterEditor:
            - Fixed the bug in which changes in the filter were not
              always being immediately reflected in the surface list.

Version 2.1.0  [ 18 December, 2000 ]
    (Initial public release.)

Ben Burton (bab@maths.uq.edu.au)
http://regina-normal.github.io/

