CHANGES.txt

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 7.4  [ (to be announced) ]

    GENERAL:
        - Now requires C++20 (not C++17), and Python 3.7 or newer.
        - Added support for simplex and facet locks throughout the API.  See
          Simplex<dim>::lock() and Simplex<dim>::lockFacet() for an overview
          of how locks work.  Many routines throughout the API could now
          potentially throw a LockViolation (and this is now explicitly noted
          in their respective docs); other routines now examine locks as part
          of their validity checks (e.g., local moves on triangulations).
        - All enumerations are now C++11 scoped enumerations, with the old
          names kept as deprecated constants in the regina:: namespace (for
          global enumerations) or the relevant class namespace (for class
          enumerations).
        - Explicit inequality tests (!=) have been removed, and are now
          automatically generated from equality tests (==) instead.
        - Explicit comparisons (<, <=, >, >=) have been removed, and are now
          automatically generated from the new spaceship operator (<=>).
        - For several iterator classes, the associated type aliases
          (value_type, etc.) are no longer provided as class members, since
          these were confusing pybind11.  Instead you can (and should) access
          these through the C++ standard iterator library (e.g.,
          std::iterator_traits<T>::value_type, or std::iter_value_t<T>).
        - Several build dependencies are gone: Jansson, Popt, CppUnit.
          See the individual sections below for details.
        - Updated the SnapPea kernel to the one shipped with SnapPy 3.0.3.
        - Updated the bundled copy of Normaliz to version 3.10.3 (30 May 2024).
    ENGINE:
        Class AbelianGroup:
            - New routine hash(), which uses the tight encoding.
            - Added a spaceship operator (<=>) for comparisons.
        Enum Algorithm:
            - This is now a scoped enumeration, for better type safety.
              The old enum constants (e.g., ALG_BACKTRACK) have been
              renamed as scoped enum values (e.g., Algorithm::Backtrack).
              The old names have been kept as deprecated compile-time constants
              in the regina:: namespace.
        Enum AngleAlg, AngleAlgFlags:
            - The individual flags now live inside AngleAlg, which is now a
              scoped enumeration for better type safety.  In paticular, the
              enum constants (e.g., AS_ALG_TREE) have been renamed as scoped
              enum values (e.g., AngleAlg::Tree).  The old constants have
              been kept as deprecated compile-time constants in the regina
              namespace.
            - Flags can still be combined bitwise; the resulting type is now
              just Flags<AngleAlg>, and this should all be happening
              automatically behind the scenes.  AngleAlgFlags is now
              just a deprecated alias for AngleAlg.
        Class AngleStructure:
            - The vector constructors are now templated, so that you can pass a
              vector of some type other than regina::Integer.
            - Added a spaceship operator (<=>) for comparisons.  This has the
              effect of implementing all comparison operators, not just
              less-than (<) as before.
        Class AngleStructures:
            - New routine sort().
        Enum Attachment::OwnershipPolicy:
            - This is now a scoped enumeration, for better type safety.
              The old enum constants (e.g., OWN_MALLOC) have been
              renamed as scoped enum values (e.g., OwnershipPolicy::OwnMalloc).
              The old names have been kept as deprecated compile-time constants
              in the Attachment class.
        Enum BagComparison:
            - This is now a scoped enumeration, for better type safety.
              The old enum constants (e.g., BAG_EQUAL) have been
              renamed as scoped enum values (e.g., BagComparison::Equal).
              The old names have been kept as deprecated compile-time constants
              in the regina:: namespace.
        Class Base64SigDecoder, Base64SigEncoder:
            - New classes to support base64-encoded signatures, such as
              isomorphism signatures and knot/link signatures.
        Class Base64SigEncoding:
            - Deprecated in favour of the new classes Base64SigEncoder and
              Base64SigDecoder.
        Class BitManipulator<T>:
            - New routine swapBits().
            - New routine subsetComparison().
        Class Bitmask, Bitmask1<T>, Bitmask2<T, U>:
            - Added a spaceship operator (<=>) for subset comparisons.  This
              has the effect of implementing all comparison operators, not just
              less-than-or-equal (<=) as before.
        Class BoolSet:
            - New routine full().
            - Renamed empty() to clear(), without a deprecated alias, to avoid
              confusion with the more common pattern where empty() queries
              whether or not a container is empty.
            - Added a spaceship operator (<=>) for subset comparisons.
        Enum CensusPurge, CensusPurgeFlags:
            - The individual flags now live inside CensusPurge, which is now
              a scoped enumeration for better type safety.  In paticular, the
              enum constants (e.g., PURGE_NON_MINIMAL) have been renamed
              as scoped enum values (e.g., CensusPurge::NonMinimal).  The old
              constants have been kept as deprecated compile-time constants
              in the regina namespace.
            - Flags can still be combined bitwise; the resulting type is now
              just Flags<CensusPurge>, and this should all be happening
              automatically behind the scenes.  CensusPurgeFlags is now
              just a deprecated alias for CensusPurge.
        Enum ChangeType:
            - New enum for internal use with triangulation/link change spans.
        Class DiscSpecIterator:
            - This class no longer provides its iterator-related type aliases
              (value_type, etc.) as members, since these confused pybind11.
              Instead you should access them through the C++ standard
              iterator library (e.g., via std::iterator_traits).  The old
              member type aliases have been removed completely.
        Struct DiscType:
            - Added a spaceship operator (<=>) for comparisons.  This has the
              effect of implementing all comparison operators, not just
              less-than (<) as before.
        Class Example<dim>:
            - Routine doubleCone() now preserves orientedness.
        Class Example<2>:
            - Routine sphereOctahedron() now returns an oriented triangulation.
        Class Example<3>:
            - New routine b5().
            - New routine threeTorus(), thanks to Rhuaidi Burke.
            - Routines lst(), lens(), augTriSolidTorus() and sfsOverSphere()
              now check their preconditions and throw an exception if they fail.
            - Renamed cuspedGenusTwoTorus() to idealGenusTwoHandlebody().
              The old name has been kept as a deprecated alias.
        Class Example<4>:
            - New routine fourTorus(), thanks to Rhuaidi Burke.
        Class ExampleLink:
            - New routine chen().
            - Added several new routines that return 3-dimensional embeddings
              of links (i.e., SpatialLink objects).
        Class Face<dim, 1>, FaceNumbering<dim, 1>:
            - New static routine faceNumber(u, v) to return the edge number in
              a simplex spanned by vertices u and v.  This is implemented in
              FaceNumbering<dim, 1> and is also accessible to Face<dim, 1>.
            - New routine Face<dim, 1>::isLoop().
        Class Face<dim, 2>:
            - Triangle<3>::Type is deprecated, and is now an alias for the new
              global type TriangleType.  Moreover, this is now a scoped
              enumeration for better type safety.  The old enum constants
              (e.g., Triangle<3>::CONE) are likewise now deprecated aliases for
              the new scoped enum values (e.g., TriangleType::Cone).
            - The 3-D routines Triangle<3>::type(), Triangle<3>::subtype(),
              isMobiusBand() and isCone() have been renamed to triangleType(),
              triangleSubtype(), formsMobiusBand() and formsCone(), and
              are now available for triangles within triangulations of any
              dimension ≥ 3.  The old 3-D routines are now deprecated.
        Class Face<dim, dim-1>:
            - New routine join().
            - New routines lock(), unlock(), and isLocked().
        Class FacePair:
            - Added a spaceship operator (<=>) for comparisons.
        Class FacetPairing<dim>:
            - New generic routine hasMultiEdge(), which generalises the
              3-D routine hasTripleEdge().
            - New routine hash(), which uses the tight encoding.
        Class FacetSpec<dim>:
            - New routine hash(), which uses the tight encoding.
            - Added a spaceship operator (<=>) for comparisons.  This has the
              effect of implementing all comparison operators, not just
              less-than (<) and less-than-or-equal (<=) as before.
        Enum FileFormat:
            - This is now a scoped enumeration, for better type safety.
              The old enum constants (e.g., REGINA_XML_GEN_3) have been
              renamed as scoped enum values (e.g., FileFormat::XmlGen3).
              The old names have been kept as deprecated compile-time constants
              in the regina:: namespace.
        Class FixedArray:
            - New class for stack-based fixed-size arrays whose sizes are not
              known until runtime.
        Class Flags<T>:
            - Updated to support both scoped and unscoped enumerations.
            - New operator bool(), which tests for a non-empty flag set.
            - Fixed an error in the 3- and 4-argument variants of ensureOne(),
              which would clear out all unrelated flags if none of the 3 or 4
              given flags were set.  This error was harmless in practice:
              the only effect was that, when enumerating fundamental normal
              surfaces with a non-trivial algorithm flag that did _not_ include
              an explicit Hilbert basis algorithm, the algorithm flag could
              have been ignored (thereby using the default vertex enumeration
              algorithm as the first phase of the primal Hilbert basis method).
        Enum Framing:
            - This is now a scoped enumeration, for better type safety.
              The old enum constants (e.g., FRAMING_SEIFERT) have been
              renamed as scoped enum values (e.g., Framing::Seifert).
              The old names have been kept as deprecated compile-time constants
              in the regina:: namespace.
        Class GraphLoop, GraphPair, GraphTriple:
            - Added a spaceship operator (<=>) for aesthetic comparisons.
              This has the effect of implementing all comparison operators,
              not just less-than (<) as before.
        Struct GroupExpressionTerm:
            - Added a spaceship operator (<=>) for comparisons.  This has the
              effect of implementing all comparison operators, not just
              less-than (<) as before.
        Class GroupPresentation:
            - Renamed intelligentSimplify() to simplify().  The old name is
              kept as a deprecated alias.
        Class HomGroupPresentation:
            - Renamed intelligentSimplify() and intelligentNielsen() to
              simplify() and nielsen() respectively.  The old names are kept
              as deprecated aliases.
        Class HomologicalData:
            - New routine triangulation().
        Enum HyperAlg, HyperAlgFlags:
            - The individual flags now live inside HyperAlg, which is now a
              scoped enumeration for better type safety.  In paticular, the
              enum constants (e.g., HS_VERTEX_DD) have been renamed as scoped
              enum values (e.g., HyperAlg::VertexDD).  The old constants have
              been kept as deprecated compile-time constants in the regina
              namespace.
            - Flags can still be combined bitwise; the resulting type is now
              just Flags<HyperAlg>, and this should all be happening
              automatically behind the scenes.  HyperAlgFlags is now
              just a deprecated alias for HyperAlg.
        Enum HyperCoords:
            - This is now a scoped enumeration, for better type safety.
              The old enum constants (e.g., HS_STANDARD) have been
              renamed as scoped enum values (e.g., HyperCoords::Standard).
              The old names have been kept as deprecated compile-time constants
              in the regina:: namespace.
        Enum HyperList, HyperListFlags:
            - The individual flags now live inside HyperList, which is now a
              scoped enumeration for better type safety.  In paticular, the
              enum constants (e.g., HS_VERTEX) have been renamed as scoped enum
              values (e.g., HyperList::Vertex).  The old constants have been
              kept as deprecated compile-time constants in the regina namespace.
            - Flags can still be combined bitwise; the resulting type is now
              just Flags<HyperList>, and this should all be happening
              automatically behind the scenes.  HyperListFlags is now
              just a deprecated alias for HyperList.
        Class Integer:
            - New routine hash(), which hashes the integer down to a size_t.
            - New routine str(), which is an alias for stringValue().
            - New class constant supportsInfinity, which is set to false.
            - Added a spaceship operator (<=>) for comparisons.
        Class IntOfBits<k>:
            - New type alias to simplify arithmetic when using IntOfSize<...>.
        Class Isomorphism<dim>:
            - New routine hash(), which uses the tight encoding.
        Class IsoSigPrintable<dim>:
            - No longer derives from Base64SigEncoding (which is now
              deprecated).
        Enum Language:
            - New enumeration that describes supported programming languages.
        Class LargeInteger:
            - New routine hash(), which hashes the integer down to a size_t.
            - New routine str(), which is an alias for stringValue().
            - New class constant supportsInfinity, which is set to true.
        Class Laurent<T>, Laurent2<T>:
            - New routine hash(), which uses the tight encoding.
            - Added a spaceship operator (<=>) for comparisons.
        Class LensSpace:
            - Added a spaceship operator (<=>) for aesthetic comparisons, which
              also adds comparison operators (<, <=, >, >=) to this class.
        Class LightweightSequence<T>:
            - Added a spaceship operator (<=>) for comparisons.  This has the
              effect of implementing all comparison operators, not just
              less-than (<) as before.
        Class Link:
            - New routine makeAlternating().
            - New routine seifertCircles().
            - New routines isConnected() and diagramComponents().
            - New routines insertLink() and moveContentsTo().
            - New routines countTrivialComponents() and pdAmbiguous(), to help
              understand the limitations of planar diagram codes.
            - New routine hash(), which uses the tight encoding.
            - New routines overForComponent() and underForComponent().
            - New variant of reverse() to reverse just one component of a
              multiple-component link.
            - New routine componentsByStrand().
            - Regarding Reidemeister moves:
              + The (check, perform) variants of r1(), r2() and r3() are
                deprecated.  You should now use these routines _without_ extra
                check/perform arguments: they will always check for and (if
                possible) perform the relevant moves.
              + New routines hasR1(), hasR2() and hasR3() for checking only.
              + New read-only routines withR1(), withR2() and withR3() that (if
                possible) return a new link with the relevant moves performed.
            - Extended knotSig(), rewrite() and simplifyExhaustive() to work
              with all link diagrams with fewer than 64 link components.
              It is now recommended to use sig() and fromSig() instead of
              knotSig() and fromKnotSig() since these names better reflect the
              scope of these routines.  The original names knotSig() and
              fromKnotSig() have been kept (and are _not_ deprecated).
            - Routine hasReducingPass() can now handle multiple-component links.
            - Added a variant of translate() that takes crossings instead of
              strand references.
            - Added an alias sig() for knotSig().
            - Renamed intelligentSimplify() to simplify().  The old name is
              kept as a deprecated alias.
            - Fixed a bug where calling resolve() would not clear out any
              cached link polynomials that had already been computed.
            - Overhaul of the internal change span classes, including a new
              inner class ChangeAndClearSpan.
            - Optimised so that computed topological properties (e.g., Jones
              and HOMFLY-PT polynomials) are preserved through operations that
              do not change the topology (e.g., Reidemeister moves).
            - Renamed dumpConstruction() to source(), and extended it to produce
              either C++ and Python code via an optional language argument.
              The old C++-only dumpConstruction() is kept but deprecated.
              Also fixed a problem where the C++ initialiser lists were empty
              (instead of containing a single 0) for zero-crossing components.
            - Routine selfFrame() now returns a boolean indicating whether
              anything changed.
            - Routine simplifyExhaustive() now ensures that any change to the
              link diagram happens on the calling thread.
        Class LockViolation:
            - New exception class used when the user attempts to change a
              locked simplex or facet.
        Class Manifold:
            - Added a spaceship operator (<=>) for aesthetic comparisons.
              This has the effect of implementing all comparison operators,
              not just less-than (<) as before.
        Class Matrix<T>:
            - Added a copy constructor that takes a matrix whose elements are
              of a different type.
            - Added destructive and non-destructive rank() functions.
            - New routines negateRow() and negateCol().
            - New routine initialised().
            - Renamed initialise() to fill(), to make it clear that this has
              nothing to do with initialised vs uninitialised matrices.
              The old name is kept but deprecated.
            - The ring template argument now defaults to true for matrices over
              native C++ floating-point types, and Python now has a new binding
              MatrixReal to represent the C++ type Matrix<double>.
        Class ModelLinkGraph:
            - New routines isSimple() and isConnected().
            - New routine generateAnyLink().
            - Routine generateMinimalLinks() now supports multiple-component
              links.
        Class ModelLinkGraphNode:
            - New routines loops(), bigons() and triangles().
        Enum NamedPermGroup:
            - This is now a scoped enumeration, for better type safety.
              The old enum constants (e.g., PERM_GROUP_TRIVIAL) have been
              renamed as scoped enum values (e.g., NamedPermGroup::Trivial).
              The old names have been kept as deprecated compile-time constants
              in the regina:: namespace.
        Class NativeInteger<bytes>:
            - New routine str().
            - Added a spaceship operator (<=>) for comparisons.
        Enum NiceType:
            - This is now a scoped enumeration, for better type safety.
              The old enum constants (e.g., NICE_INTRODUCE) have been
              renamed as scoped enum values (e.g., NiceType::INTRODUCE).
              The old names have been kept as deprecated compile-time constants
              in the regina:: namespace.
        Enum NormalAlg, NormalAlgFlags:
            - The individual flags now live inside NormalAlg, which is now a
              scoped enumeration for better type safety.  In paticular, the
              enum constants (e.g., NS_VERTEX_DD) have been renamed as scoped
              enum values (e.g., NormalAlg::VertexDD).  The old constants have
              been kept as deprecated compile-time constants in the regina
              namespace.
            - Flags can still be combined bitwise; the resulting type is now
              just Flags<NormalAlg>, and this should all be happening
              automatically behind the scenes.  NormalAlgFlags is now
              just a deprecated alias for NormalAlg.
        Enum NormalCoords:
            - This is now a scoped enumeration, for better type safety.
              The old enum constants (e.g., NS_STANDARD) have been
              renamed as scoped enum values (e.g., NormalCoords::Standard).
              The old names have been kept as deprecated compile-time constants
              in the regina:: namespace.
        Enum NormalList, NormalListFlags:
            - The individual flags now live inside NormalList, which is now a
              scoped enumeration for better type safety.  In paticular, the
              enum constants (e.g., NS_VERTEX) have been renamed as scoped enum
              values (e.g., NormalList::Vertex).  The old constants have been
              kept as deprecated compile-time constants in the regina namespace.
            - Flags can still be combined bitwise; the resulting type is now
              just Flags<NormalList>, and this should all be happening
              automatically behind the scenes.  NormalListFlags is now
              just a deprecated alias for NormalList.
        Class NormalSurface, NormalHypersurface:
            - Fixed a bug where, if a surface was a normalised triangle link
              but not a thin triangle link, then calling isThinTriangleLink()
              _before_ isNormalTriangleLink() would make the latter return
              an empty list of results.  Likewise with tetrahedron links in
              4-dimensional triangulations.
            - Fix a bug in components() when used on disconnected surfaces,
              where if it were called _after_ connectedness has already been
              established (i.e., after isOrientable(), isTwoSided(),
              isConnected(), or an earlier call to components()), then it would
              return the entire surface as a single component.
            - The vector constructors are now templated, so that you can pass a
              vector of some type other than regina::LargeInteger.
            - Added a spaceship operator (<=>) for comparisons.  This has the
              effect of implementing all comparison operators, not just
              less-than (<) as before.
        Class NormalSurfaces, NormalHypersurfaces:
            - The inner class VectorIterator no longer provides its
              iterator-related type aliases (value_type, etc.) as members,
              since these confused pybind11.  Instead you should access them
              through the C++ standard iterator library (e.g., via
              std::iterator_traits).  The old member type aliases have been
              removed completely.
        Enum NormalTransform:
            - This is now a scoped enumeration, for better type safety.  The
              old enum constants (e.g., NS_FILTER_DISJOINT) are now scoped
              enum values (e.g., NormalTransform::FilterDisjoint).
              The old names have been kept as deprecated compile-time constants
              in the regina:: namespace.
        Class Packet:
            - Renamed ChangeEventSpan to PacketChangeSpan, to make it clear
              that this only matters for objects held by packets.  The old
              name is kept as a deprecated alias.
            - New inner type alias PacketChangeGroup, to assist with readability
              when using a ChangeEventSpan for optimisation purposes only.
            - For Python users, added an alias makePacket() for make_packet().
            - The inner classes ChildIterator and SubtreeIterator no longer
              provides their iterator-related type aliases (value_type, etc.)
              as members, since these confused pybind11.  Instead you should
              access them through the C++ standard iterator library (e.g., via
              std::iterator_traits).  The old member type aliases have been
              removed completely.
        Class PacketData<Held>:
            - Renamed ChangeEventSpan to PacketChangeSpan, to make it clear
              that this only matters for objects held by packets.  The old
              name is kept as a deprecated alias.
            - New inner type alias PacketChangeGroup, to assist with readability
              when using a ChangeEventSpan for optimisation purposes only.
            - The inner ChangeEventSpan class has a new member function held().
        Enum PacketHeldBy:
            - This is now a scoped enumeration, for better type safety.
              The old enum constants (e.g., HELD_BY_PACKET) have been
              renamed as scoped enum values (e.g., PacketHeldBy::Packet).
              As this enumeration was for internal use, the old names have
              been removed completely.
        Enum PacketType:
            - This is now a scoped enumeration, for better type safety.
              The old enum constants (e.g., PACKET_TRIANGULATION3) have been
              renamed as scoped enum values (e.g., PacketType::Triangulation3).
              The old names have been kept as deprecated compile-time constants
              in the regina:: namespace.
        Class Perm<n>:
            - New routine hash().
            - New class constant degree.
            - Added an alias Perm<6>::cachedOrder(), for consistency with the
              other permutation classes Perm<2..15>.
            - Added a spaceship operator (<=>) for comparisons under the Sn
              ordering.  This has the effect of implementing all comparison
              operators, not just less-than (<) as before.
            - Sn and orderedSn now use the new public type PermSn<...> (see
              below), which now supports both iteration and array-like access.
            - For n > m, Perm<n>::Sm and Perm<n>::orderedSm are now deprecated,
              and they now use the new internal type PermSubSn<...> (see below).
              Likewise, the constants Sn_1 and nPerms_1 are now deprecated.
            - Classes Perm<2,3> now have a type alias Code2 (which is identical
              to Code), to help with generic programming.
        Enum PermCodeType:
            - This is now a scoped enumeration, for better type safety.
              The old enum constants (e.g., PERM_CODE_IMAGES) have been
              renamed as scoped enum values (e.g., PermCodeType::Images).
              The old names have been kept as deprecated compile-time constants
              in the regina:: namespace.
        Enum PermOrder:
            - New enumeration to represent different ways of ordering
              permutations.
        Class PermSn<n, order>:
            - New type to support Perm<n>::Sn and Perm<n>::orderedSn.  This is
              now a public type, and it now supports both iteration and
              array-like access.
        Class PermSubSn<n, m>:
            - New internal type to support Perm<n>::Sm where n > m.  This
              supports array-like access only, not iteration.
        Struct Unprotected:
            - New C++-only type that allows in-built safety checks to be
              disabled in some specific circumstances.
        Class Rational:
            - New function str().
            - Added a spaceship operator (<=>) for comparisons.
        Class Rotation3D:
            - New class to support floating-point 3-D geometry.
        Class SatAnnulus:
            - Routine attachLST() now checks its preconditions, and throws
              an exception if they fail.
        Class SatBlock:
            - Added a spaceship operator (<=>) for ordering.
              This has the effect of implementing all comparison operators,
              not just less-than (<) as before.
        Class Segment3D:
            - New class to support floating-point 3-D geometry.
        Struct SFSFibre:
            - Added a spaceship operator (<=>) for comparisons.  This has the
              effect of implementing all comparison operators, not just
              less-than (<) as before.
        Class SFSpace:
            - Added a spaceship operator (<=>) for aesthetic comparisons.
              This has the effect of implementing all comparison operators,
              not just less-than (<) as before.
            - SFSpace::ClassType has been renamed to SFSpace::Class, and is now
              a scoped enumeration for better type safety.  The old enum
              constants (e.g., SFSpace::o1) have been renamed as scoped enum
              values (e.g., SFSpace::Class::o1).  The old names have been kept
              as deprecated compile-time class constants of SFSpace.
        Class Simplex<dim>:
            - New routines lock(), lockFacet(), unlock(), unlockFacet(),
              unlockAll(), isLocked(), isFacetLocked(), and lockMask().
        Class SnapPeaTriangulation:
            - Construction from a SnapPea data file no longer crashes when the
              triangulation in the file has finite vertices (which may be seen
              if the file was created by some tool other than SnapPy).  The
              manifold will however be retriangulated (drilled and filled) upon
              creation since the SnapPea kernel requires an ideal triangulation.
            - The class enumerations SolutionType, CoverEnumerationType and
              CoverType have been renamed to Solution, CoverEnumeration and
              Cover, and are now scoped enumerations for better type safety.
              The old constants (e.g., SnapPeaTriangulation::geometric_solution)
              have been renamed as scoped enum values (e.g.,
              SnapPeaTriangulation::Solution::Geometric).  The old names have
              been kept as deprecated compile-time class constants of
              SnapPeaTriangulation.
        Class SpatialLink:
            - New packet class for specific embeddings of knots and links in
              the 3-sphere.  Currently this offers very limited features, but
              these should be expanded to become more useful over time.
        Enum SurfaceExport, SurfaceExportFields:
            - The individual flags now live inside SurfaceExport, which is now
              a scoped enumeration for better type safety.  In paticular, the
              enum constants (e.g., surfaceExportName) have been renamed
              as scoped enum values (e.g., SurfaceExport::Name).  The old
              constants have been kept as deprecated compile-time constants
              in the regina namespace.
            - Flags can still be combined bitwise; the resulting type is now
              just Flags<SurfaceExport>, and this should all be happening
              automatically behind the scenes.  SurfaceExportFields is now
              just a deprecated alias for SurfaceExport.
        Enum SurfaceFilterType:
            - This is now a scoped enumeration, for better type safety.  The
              old enum constants (e.g., NS_FILTER_PROPERTIES) have been renamed
              as scoped enum values (e.g., SurfaceFilterType::Properties).
              The old names have been kept as deprecated compile-time constants
              in the regina:: namespace.
        Class Tangle:
            - Regarding Reidemeister moves:
              + The (check, perform) variants of r1(), r2() are deprecated.
                You should now use these routines _without_ extra check/perform
                arguments: they will always check for and (if possible) perform
                the relevant moves.
              + New routines hasR1(), hasR2() for checking only.
              + New read-only routines withR1() and withR2() that (if possible)
                return a new link with the relevant moves performed.
            - Added a variant of translate() that takes crossings instead of
              strand references.
        Class TightEncodable<T>:
            - Now provides a hash() function also, based on the tight encoding.
        Class TopologyLockable, TopologyLock:
            - Split out the old Triangulation::TopologyLock machinery into
              new standalone classes, which are now used with Link as well.
        Class TreeBag:
            - Renamed type() and subtype() to niceType() and niceIndex()
              respectively.  Moreover, niceType() now returns a NiceType, not
              an int.  The old functions are kept but deprecated.
        Class TreeDecomposition:
            - Functions dot() and writeDot() now take an optional parameter to
              support dark mode.
        Enum TreeDecompositionAlg:
            - This is now a scoped enumeration, for better type safety.
              The old enum constants (e.g., TD_UPPER) have been
              renamed as scoped enum values (e.g., TreeDecompositionAlg::Upper).
              The old names have been kept as deprecated compile-time constants
              in the regina:: namespace.
        Enum TriangleType:
            - New scoped enumeration to replace the old non-scoped enumeration
              Triangle<3>::Type.  The new TriangleType enumeration is used for
              triangles within triangulations of all dimensions ≥ 3.
        Class Triangulation<dim>:
            - New routines hasLocks(), lockBoundary(), and unlockAll(), to
              work with locked top-dimensional simplices and their facets.
            - New routine reorderBFS(), which essentially makes the old
              Triangulation<3>::reorderTetrahedraBFS() available in all
              dimensions.
            - Regarding Pachner moves:
              + The (check, perform) variant of pachner() is deprecated.
                You should now call pachner() _without_ extra check/perform
                arguments: the function will always check for and (if possible)
                perform the relevant move.
              + New routine hasPachner() for checking only.
              + New read-only routine withPachner() that (if possible) returns
                a new triangulation with the relevant move performed.
            - Regarding 2-0 moves:
              + These moves are now available for triangulations of all
                dimensions, but only for facial dimensions ≤ max(2, dim-2).
              + The (check, perform) function twoZeroMove() is deprecated.
                You should now call move20() instead, which does _not_ take
                extra check/perform arguments: move20() will always check for
                and (if possible) perform the relevant move.
              + New routine has20() for checking only.
              + New read-only routine with20() that (if possible) returns
                a new triangulation with the relevant move performed.
            - Regarding boundary shelling moves:
              + These moves are now available for triangulations of all
                _standard_ dimensions (2, 3 and 4).
              + The (check, perform) variant of shellBoundary() is deprecated.
                You should now call shellBoundary() _without_ extra
                check/perform arguments: the function will always check for
                and (if possible) perform the relevant move.
              + New routine hasShellBoundary() for checking only.
              + New read-only routine withShellBoundary() that (if possible)
                returns a new triangulation with the relevant move performed.
            - New routine randomiseLabelling().
            - New routine hash(), which uses the tight encoding.
            - New routines dot() and writeDot().
            - New alias sig(), which is is identical to isoSig().
            - Extended translate() to support top-dimensional simplices (not
              just lower-dimensional faces), and added a variant of translate()
              that takes face embeddings instead of faces.
            - Renamed dumpConstruction() to source(), and extended it to produce
              either C++ and Python code via an optional language argument.
              The old C++-only dumpConstruction() is kept but deprecated.
            - Added a variant of insertTriangulation() that takes an rvalue
              reference (alongside the original which takes a const reference).
            - The two-argument copy constructor is now a three-argument
              copy constructor, giving an additional boolean option for
              whether to clone simplex/facet locks.
            - Replaced makeDoubleCover() with doubleCover(), which returns the
              result as a new triangulation.  The old routine is kept but
              deprecated.
            - Renamed simplifiedFundamentalGroup to setGroupPresentation().
              The old name is deprecated but kept for backwards compatibility.
            - Overhaul of the internal change span classes, including a new
              inner class ChangeAndClearSpan.
        Class Triangulation<3>:
            - New routines has44(), has21(), has02(), hasOpenBook(),
              hasCloseBook(), hasCollapseEdge().
            - New routines with44(), with21(), with02(), withOpenBook(),
              withCloseBook(), withCollapseEdge().
            - New routines isOneEfficient() and knowsOneEfficient().  For now,
              1-efficiency testing is only available for ideal triangulations.
            - Renamed intelligentSimplify() to simplify().  The old name is
              kept as a deprecated alias.
            - Routine puncture() now takes an optional triangle, not an
              optional tetrahedron.  The old version is kept but deprecated.
            - Routine insertLayeredSolidTorus() is now non-recursive, and
              throws an exception if its preconditions fail.
            - Routines layerOn(), pinchEdge(), puncture(), turaevViro() and
              turaevViroApprox() now throw an exception if their preconditions
              fail.
            - Routine reorderTetrahedraBFS() is now a deprecated alias for
              reorderBFS() (which is available in all dimensions).
            - Routine idealToFinite() no longer subdivides the triangulation
              if there are invalid edges but no vertices to truncate.
            - Routines hasStrictAngleStructure(), hasGeneralAngleStructure(),
              strictAngleStructure() and generalAngleStructure() have changed
              their behaviour for the empty triangulation: they now return the
              empty angle structure as a solution (since, strictly speaking,
              the empty structure is both strict and taut).
            - Fixed an issue with zeroTwoMove(edge, t0, t1) where: if the given
              edge was valid and boundary, and if t0 and/or t1 was exactly the
              edge degree, and if the routine was asked to check legality, then
              the move would be incorrectly reported as illegal.  (This was
              essentially harmless, since it effectively made the routine
              over-cautious by not performing moves that it could have, and
              since if the routine was _not_ asked to check legality then the
              move was still being performed correctly.)
            - Routine from SnapPea() can now take either a filename or file
              contents.  It can also now handle empty lines before the manifold
              name (SnapPy does not write these, but some other tools do).
            - Routines retriangulate() and simplifyExhaustive() no longer
              throw an exception when called on an empty triangulation.
            - Routine simplifyExhaustive() now ensures that any change to the
              triangulation happens on the calling thread.
        Class Triangulation<4>:
            - New routine simplifyUpDown(); thanks to Rhuaidi Burke.
            - New routines has44(), hasOpenBook(), hasCollapseEdge(),
              hasSnapEdge().
            - New routines with44(), withOpenBook(), withCollapseEdge(),
              withSnapEdge().
            - Renamed intelligentSimplify() to simplify().  The old name is
              kept as a deprecated alias.
            - Routines retriangulate() and simplifyExhaustive() no longer
              throw an exception when called on an empty triangulation.
            - Routine simplifyExhaustive() now ensures that any change to the
              triangulation happens on the calling thread.
        Class Vector<T>:
            - Added a copy constructor that takes a vector whose elements are
              of a different type.
            - Added support for tight encodings and decodings.
            - New routine hash(), which uses the tight encoding.
        Class Vector3D:
            - New class to support floating-point 3-D geometry.
        Class Vertex<3>:
            - Vertex<3>::LinkType has been renamed to Vertex<3>::Link, and is
              now a scoped enumeration for better type safety.  The old enum
              constants (e.g., Vertex<3>::SPHERE) have been renamed as scoped
              enum values (e.g., Vertex<3>::Link::Sphere).  The old names have
              been kept as deprecated compile-time class constants of Vertex<3>.
        Function binomMedium():
            - Now supports arguments n ≤ 61 (not n ≤ 29), and uses a return
              type large enough to support this (i.e., at least 64 bits).
            - Now supports k < 0 or k > n (returning 0 as expected).
            - Now throws an exception if n is outside the allowed range.
        Function binomSmall():
            - This is now consteval, which means it cannot be called at
              runtime.  As a result, Python users can no longer use this
              function at all: if you are in Python you should call
              binomMedium() instead.
        Function columnEchelonForm():
            - Cleaned up and relaxed the preconditions.
            - Now checks its preconditions and throws an exception if they fail.
        Function foreach_constexpr():
            - New pair of functions to provide compile-time loops over an
              arbitrary set of integers.
        Function gcdWithCoeffs():
            - Fixed an overflow error that occurred in the case b == LONG_MAX
              (and nowhere else), and highlighted in the docs that LONG_MIN
              may not be handled correctly (due to the inability to negate).
        Function modularInverse():
            - Now checks its preconditions and throws an exception if they fail.
            - Now explicitly allows (n,k) = (1,0); in the past this was
              supported but technically a violation of the preconditions.
            - Now takes arguments of type long (not unsigned long).
        Function preImageOfLattice():
            - Now checks some of its preconditions and throws an exception
              if they fail.
        Function reducedMod():
            - Now checks its preconditions and throws an exception if they fail.
        Function rowBasisAndOrthComp():
            - Now checks its preconditions and throws an exception if they fail.
        Functions simpler(), simplerThreeWay():
            - The old simpler() functions that compare 2x2 matrices are now
              deprecated (both the 2-argument and the 4-argument variants).
            - To replace them, there are new simplerThreeWay() functions that
              return a std::strong_ordering instead of a bool (likewise with
              both 2-argument and 4-argument variants).
        Function torsionAutInverse():
            - Now checks some of its preconditions and throws an exception
              if they fail.
        Macro ENABLE_MEMBER_FOR_REGINA_INTEGER:
            - This is deprecated, and is no longer used within Regina.  The
              suggested alternative is to use a static_assert to ensure that a
              member function is only instantiated with appropriate types.
        Constants is_cpp_integer_v<T>, is_unsigned_cpp_integer_v<T>:
            - New alternatives to using std::is_integeral_v<T> and
              std::is_unsigned_v<T> that allow for 128-bit integers also.
        Global array quadString:
            - These are now C++-style strings (std::string), not C-style
              strings (array of char).  For newer compilers, they are still
              inline constexpr, but for older compilers that do not support
              constexpr strings they are instead declared as inline const.
    PYTHON:
        - Updated the included pybind11 library from 2.10.0 to 2.13.6.
          This drops support for Python 3.6.
        - Improved the speed of iteration (specifically, throwing/catching
          StopIteration exceptions).
        - Rich flag types based on regina::Flags<...> (such as NormalAlg,
          CensusPurge, etc.) now support a bool() operator that tests for
          a non-empty flag set.
        - The underlying enum types for rich flags (e.g., NormalAlgFlags,
          CensusPurgeFlags, etc.) likewise now have a bool() operator that
          tests for a zero flag.  This is because zero flags play a special
          role here (they have no effect when ORed or XORed into a flag set).
        - All other enum types (i.e., those that are _not_ intended to be
          combined bitwise into flag sets) do not have a bool() operator,
          since their underying integer values are irrelevant.  All of their
          enum values will be treated as True by python.
    USER INTERFACE:
        - Now uses multithreading for those long computations that support it.
        - No longer reads the syntax highlighting theme from file; instead
          the theme is hard-coded into the executable.  This removes the
          build dependency on the Jansson JSON library.
        - The summary tabs for normal surfaces and hypersurfaces now split out
          separate counts for non-embedded (immersed and/or singular)
          surfaces and hypersurfaces.
    UTILITIES:
        regina-engine-config:
            - Made more robust, and removed obsolete options (--exec-prefix,
              and the option to set --prefix to a custom directory).
        regina-helper:
            - New command-line tool for performing miscellaneous tasks.
        tricensus:
            - Renamed option --tetrahedra to --top, with aliases --triangles,
              --tetrahedra and --pentachora.
            - New option --regina to output Regina data files (the default).
            - New option --dim3 for dimension 3 (the default).
            - Fixed a race condition with --threads where the number of
              triangulations reported on the console could be wrong (although
              the actual list of triangulations in the output file was correct).
        tricensus, retriangulate:
            - Ported the handling of command-line options from Popt to
              GNU getopt_long().  This removes the build dependency on Popt.
    TEST SUITE:
        - Ported the C++ test suite to use the GoogleTest framework (which is
          included with Regina's sources).  This removes the build dependency
          on CppUnit.

Version 7.3  [ 18 March, 2023 ]

    ENGINE:
        Class BitManipulator<T>:
            - Routines bits(), firstBit() and lastBit() are now constexpr.
        Class Component<4>:
            - Fix a bug where single-vertex boundary components were included
              in Triangulation<4>::boundaryComponents(), but were omitted from
              Component<4>::boundaryComponents().
        Class GroupExpression:
            - The string constructor now contracts terms like "aaaaBB" to become
              g0^4 g1^-2 (i.e., exponents will be used even if the input does
              not supply them).
            - The string constructor now takes the number of generators as an
              optional argument, and throws an exception if some generator in
              the string is out of range.
        Class GroupPresentation:
            - Routine enumerateCovers() now accepts indices ≤ 11, not ≤ 7.
            - The string constructor now contracts terms like "aaaaBB" to become
              g0^4 g1^-2 (i.e., exponents will be used even if the input does
              not supply them).
            - The string constructor now throws an exception if some relation
              contains a generator that is out of range.
            - Renamed simplifyWord() to simplifyAndConjugate(), to make it
              clear to the user that conjugation might take place.  The old
              name simplifyWord() has been removed completely.
            - Fixed a bug in the text-based recogniseGroup(), which could have
              reported the wrong monodromy for a group that was (correctly)
              recognised as an extension over Z.  This was a side-effect of
              the simplification bug in HomGroupPresentation (see below).
        Class HomGroupPresentation:
            - Fixed a bug in intelligentSimplify(), intelligentNielsen() and
              smallCancellation() where images/preimages of generators were
              potentially being conjugated.  See
              https://regina-normal.github.io/bugs.html for further discussion.
        Class Integer:
            - New python-only routine pythonValue().
        Class Perm<n>:
            - Extended the generic Perm<n> class to make its API as rich as the
              specialised classes for smaller n.  This means the generic class
              now supports ++ and < operators, pow(), order(), and
              isConjugacyMinimal().
            - Optimised several algorithms for the generic Perm<n> class
              that were originally quadratic in n.
            - The generic Perm<n> now offers the precomptuation-assisted
              operations cachedInverse().
            - New routines conjugate() and cachedConjugate(), to replace the
              three-way cachedComp() (which was designed for conjugation).
              The three-way cachedComp() is now deprecated; instead call
              cachedConjugate() if you are conjugating, or else call the
              two-way cachedComp() twice.
            - All Perm<n> classes now have precompute(), cachedInverse(),
              cachedComp(), cachedPow() and cachedOrder(), even for smaller n
              where these are unnecessary, to assist with writing generic code.
        Class PermClass<n>:
            - New class to describe a conjugacy class of permutations.
        Class PermGroup<n>:
            - New class to describe groups of permutations.
        Class SnapPeaTriangulation:
            - Fixed a buffer overflow in the SnapPea kernel, which was
              accessible via SnapPeaTriangulation::snapPea().
        Class Triangulation<dim>, TriangulationBase<dim>:
            - The copy constructor and copy assignment operator now clones
              skeletal objects as well, with the guarantee that they will use
              the same numbering and labelling as in the source triangulation.
        Class Triangulation<2>:
            - New routines isSphere() and isBall().

Version 7.2  [ 28 October, 2022 ]

    GENERAL:
        - Regina now has docstrings throughout its Python module.  These are
          extracted automatically from the hand-written C++ documentation, so
          you will still find C++ terminology.  Nevertheless, these are now
          available in Python for all of Regina's classes and functions.
        - Began moving to a more readable markdown format for documentation
          in the C++ headers.  A lot of work is already done here, but this is
          an ongoing project.  See also the new style guide for API docs in
          the Regina Handbook (in the new chapter on Contributing to Regina).
    ENGINE:
        Class DegreeLessThan, DegreeGreaterThan:
            - Deprecated, since these are one-liners that can be done using a
              lambda instead.  These classes will eventually be removed.
        Class Example<3>:
            - Renamed whiteheadLink() to whitehead().  The old name is kept
              as a deprecated alias.
        Class Example<4>:
            - Shrunk k3() to 54 pentachora (thanks again to Rhuaidi Burke).
        Class Face<dim, subdim>
            - Routines face<lowerdim> and faceMapping<lowerdim> now explicitly
              require 0 <= lowerdim < subdim (though this was always enforced
              in Python, and the only meaningful scenario in C++ that this
              could possibly rule out is the trivial case lowerdim == subdim).
        Class HyperEncoding:
            - New static function empty().
        Class ListView<...>:
            - Added equality operators (== and !=).
            - Added a specialisation for fixed-size C-style arrays:
              ListView<Element[n]>.
        Class ModelLinkGraph:
            - Routine flype() now throws an exception if the given arcs
              are not laid out on the plane in the expected manner.
            - Routine generateMinimalLinks() now throws an exception if its
              precondition is not met.
            - Routines plantri(), canonicalPlantri() and fromPlantri() can
              now work with graphs with up to 52 nodes (instead of 26).
              Beyond 26 nodes, Regina's format differs from plantri's own.
            - Routines plantri() and canonicalPlantri() now throw an
              exception if the graph has more than 52 nodes.
            - Routine fromPlantri() has dropped the precondition on the size
              of the graph, since this is explicitly checked.
        Class NormalEncoding:
            - New static function empty().
        Class NormalHypersurface:
            - New constructor to build the empty surface.
        Class NormalSurface:
            - New constructor to build the empty surface.
        Class Simplex<dim>:
            - Routines face<subdim> and faceMapping<subdim> now explicitly
              require 0 <= subdim < dim (though this was always enforced in
              Python, and other values of \a subdim would have always failed
              to compile in C++).
        Class Snapshottable<T>:
            - Routine isReadOnlySnapshot() is now public, not protected.
        Class TableView:
            - New class to help wrap read-only multi-dimensional arrays.
        Class TorusBundle:
            - The class constructors now throw an exception if the given
              monodromy does not have determinant ±1 (note that this has
              always a precondition).
        Class Triangulation<2>:
            - The trivial isValid() routine is now provided by the common
              base class TriangulationBase<2>, and is not reimplemented here.
        Class Triangulation<3>:
            - Renamed isHandlebody() to recogniseHandlebody().  There is no
              deprecated alias, since the issue here was users potentially
              misinterpreting the return type because of the function name.
            - The synonyms minimizeBoundary() and minimizeVertices() (which
              were convenience routines that called minimiseBoundary() and
              minimiseVertices() respectively) are now deprecated.  Going
              forward we will stick to just one style of spelling (British
              English, which Regina has always offered).
        Class Triangulation<dim>:
            - Renamed barycentricSubdivision() to subdivide().  The old
              name is kept as a deprecated alias.
            - Renamed fundamentalGroup() to group().  The old, more expressive
              name will be kept as a long-term alias (it is *not* deprecated).
        Function buildInfo():
            - New function that allows packagers to embed additional
              version/build-related information in the calculation engine.
        Function maxDim():
            - New constexpr function that indicates whether Regina was built
              with support for higher dimensions 9..15.
    PYTHON:
        - Updated the included pybind11 library from 2.8.1 to 2.10.0.
          This means we can now support Python 3.11, but no longer support
          Python 3.4 or 3.5.
        - Several classes that provide array-like access (__getitem__) now
          implement the special __len__() function also.  Note that this
          affects how objects are evaluated in a boolean context.  Affected
          classes: AngleStructures, Cyclotomic, FacetPairing<dim>,
          Isomorphism<dim>, ListView, Matrix2, NormalHypersurfaces,
          NormalSurfaces, Vector<T>.
        - A few omissions in the Python bindings were fixed.  Other than
          giving Python users access to more functions, two of these fixes
          mean a change in behaviour for Python users: these are the
          newly-added bindings for SnapPeaTriangulation::snapPea() and
          SnapPeaTriangulation::saveSnapPea().  Previously if Python users
          called these functions they would fall back to the inherited
          versions from Triangulation<3>, which behave differently.
        - A couple of errors in the Python bindings were also fixed:
          + Cyclotomic.negate() in Python was incorrectly bound to
            Cyclotomic::invert in C++;
          + regina.swap(BitmaskN, BitmaskN) in Python (for fixed-width
            bitmask types Bitmask8, Bitmask16, etc.) was incorrectly bound to
            regina::swap(Bitmask&, Bitmask&) in C++ (i.e., the swap function
            for the main Bitmask class).  Any attempt to call this function
            in Python would have resulted in undefined behaviour.
          See https://regina-normal.github.io/bugs.html for further discussion
          of how these issues might have affected you.
    USER INTERFACE:
        - Fixed a deadlock that occurs in the Windows GUI when opening two
          Python consoles in quick succession (e.g., by a double-click).
    UTILITIES:
        - Most command-line utilities now support -? / --help, as well as
          a new -v / --version option to show the current verson of Regina.
        - For regina-engine-config, the --version option now outputs more
          detailed version/build information, not just "X.Y".

Version 7.1  [ 30 September, 2022 ]

    GENERAL:
        - Regina now supports Python 3 only (not Python 2 or 3).
        - The GUI can now build against either Qt5 or Qt6.
        - Updated the bundled copy of Normaliz to version 3.9.3 (20 Apr 2022).
        - Removed all code that was deprecated in or before version 7.0.
        - Many native integer types (e.g., int, unsigned, long) have been
          changed, reflecting more natural and/or consistent choices.
          In particular, the types used for indices, sizes and/or lengths
          now more consistently use size_t (or ssize_t when needed), and
          the types used for "small" integers now more consistently use int
          instead of unsigned.  Note in particular that some types have
          changed from signed to unsigned, and vice versa.
    ENGINE:
        Class AbelianGroup:
            - New tightDecoding() routines.
        Class AngleStructures:
            - New operator [], which is identical to calling structure().
        Class BanEdge:
            - New ban constraint for use with the tree traversal classes.
        Class CallableArg<...>:
            - Now a public helper class in the main regina:: namespace.
            - Now behaves gracefully if the given index is out of range.
        Class Cut:
            - New class for describing graph-style cuts on triangulations or
              facet pairings.
        Class Edge<3>, Edge<4>:
            - Now specialised (instead of using the generic Face template).
            - New routine linkingSurface().
        Class Example<2>:
            - Both orientable() and nonOrientable() now promise minimal
              triangulations for small cases (0 and 0,1 punctures respectively).
              Thanks to Alex He for the once-punctured non-orientable code.
        Class Example<3>:
            - New routine handlebody(), thanks to Alex He.
        Class Example<4>:
            - New routine k3().
            - Reflected the result of cp2() so that it has intersection
              form [1], not [-1].
        Class FacetPairing<dim>:
            - New routine isConnected().
            - New routines canonical() and canonicalAll().
            - New routines for tight encodings and decodings.
            - In findAllPairings(), the action is no longer required to
              take the list of all automorphisms if it does not need them.
            - Renamed toTextRep() to textRep().  The old name is kept as
              a deprecated alias.
            - The IsoList type alias has changed from std::list to std::vector,
              for better performance.
        Class FacetPairing<3>:
            - Routine followChain() now uses ssize_t for the tetrahedron index.
              The old size_t version is still present but deprecated.
        Struct FacetSpec<dim>:
            - New routines for tight encodings and decodings.
        Class HilbertPrimal:
            - The header no longer includes the Normaliz headers (which
              Regina does not actually ship with its development files).
        Class Integer:
            - New tightDecoding() routines.
            - Now supports creation and assignment from long long (both
              signed and unsigned).
        Class IntersectionForm:
            - New class to compute invariants of intersection forms.
        Class Isomorphism<dim>:
            - Replaced apply() with the bracket operator.  The old apply()
              is now a deprecated alias.
            - Deprecated applyInPlace(), since this is no faster than
              calling tri = iso(tri).
            - Added bracket operators to apply an isomorphism to a
              FacetSpec or a FacetPairing.
            - Added pre/postincrement operators for iterating through
              all permutations of a given size.
            - New routines for tight encodings and decodings.
        Class LargeInteger:
            - New tightDecoding() routines.
            - Now supports creation and assignment from long long (both
              signed and unsigned).
        Class Laurent<T>, Laurent2<T>:
            - New tightDecoding() routines.
        Class Link:
            - New routines for tight encodings and decodings.
            - New function graph() that returns the model 4-valent planar graph.
            - Routines dtData(), gaussData(), jenkinsData() and pdData() now
              throw exceptions if the link is so large that the C++ int type
              is not large enough to hold the values being returned.
            - The Jones and HOMFLY-PT routines now throw exceptions if the
              link is so insanely large that strand IDs cannot fit into ints.
            - The Jones backtracking algorithm now supports 63 crossings on
              all platforms, even if the long type has only 32 bits.
        Class Matrix:
            - Routine det() now throws an exception if the matrix is not
              square (this is a precondition), and now returns 1 if the
              matrix is detected to be 0-by-0 (although such matrices are
              formally not supported by the Matrix class).
            - You can now multiply a matrix over type T with a matrix or vector
              over type U, where T and U are different types.
        Class ModelLinkGraph:
            - New constructor that takes a link to model.
        Class NormalEncoding:
            - New routines withoutTriangles(), withOctagons() and
              withoutOctagons().
        Class NormalHypersurface:
            - New operators * and *= for taking integer multiples.  The old
              doubleHypersurface() is now deprecated.
            - New routine scaleDown().
            - New routines isThinTriangleLink(), isThinTetrahedronLink(),
              isNormalEdgeLink(), isNormalTriangleLink() and
              isNormalTetrahedronLink().
        Class NormalHypersurfaces:
            - New operator [], which is identical to calling hypersurface().
        Class NormalSurface:
            - New operators * and *= for taking integer multiples.  The old
              doubleSurface() is now deprecated.
            - New routine scaleDown().
            - New routines isThinTriangleLink(), isNormalEdgeLink() and
              isNormalTriangleLink().
            - New routine removeOcts().
            - Routine cutAlong() can now work with almost normal surfaces
              (i.e., it can now handle octagons).
        Class NormalSurfaces:
            - New operator [], which is identical to calling surface().
        Class Packet:
            - Renamed insertChildFirst(), insertChildLast() and
              insertChildAfter() to prepend(), append() and insert().
              Also, some (but not all) of the preconditions for these functions
              are now explicitly tested, with exceptions thrown if they fail.
              The old function names have been kept as deprecated aliases.
        Class Perm<n>:
            - New routines for tight encodings and decodings.
        Type safe_tuple_element<...>:
            - New type alias that is like std::tuple_element<...> but
              with well-defined behaviour for an out-of-range index.
        Class SnaPeaTriangulation:
            - The Link constructor now throws an exception if the link is so
              large that SnapPea cannot handle it.
        Class Tetrahedron<4>:
            - Now specialised (instead of using the generic Face template).
            - New routine linkingSurface().
        Class TreeTraversal<...>, TreeEnumeration<...>, TautEnumeration<...>,
                TreeSingleSoln<...>:
            - Now supports ban constraints whose class constructors require
              additional arguments.  These additional arguments are passed to
              the TreeEnumeration/TautEnumeration/TreeSingleSoln constructor.
        Struct TightEncodable<T>:
            - New base class for classes that support tight encodings
              and decodings.
        Class Triangle<3>:
            - New routine linkingSurface().
        Class Triangle<4>:
            - Now specialised (instead of using the generic Face template).
            - New routine linkingSurface().
        Class Triangulation<dim>:
            - New suite of routines countBoundaryFaces().
            - New suite of public routines dualBoundaryMap() (these were
              previously private, and had a more complex interface).
            - New suite of routines dualToPrimal().
            - New routine pairing().
            - New routines for tight encodings and decodings.
            - New routine translate().
            - The join() routine now checks all its preconditions, and
              throws an exception if any precondition fails.
        Class Triangulation<3>:
            - New routines isHandlebody() and knowsHandlebody(), thanks to
              Alex He.
            - The Turaev-Viro routines now reserve the right to use a
              different algorithm if your chosen algorithm does not
              support the given parameters (r, parity).  Currently this
              only happens if you ask for ALG_TREEWIDTH and your value
              of r is so large that it cannot fit into a native C++ int.
            - New routines minimiseVertices() and hasMinimalVertices().
            - New routine hasMimimalBoundary().
            - Routine minimiseBoundary() now throws an exception if the
              triangulation is not valid.
            - Routine intelligentSimplify() now explicitly aims to reduce
              the number of vertices, as long as this does not increase
              the number of tetrahedra.
            - New routines longitudeCuts() and meridian().
            - Routines longitude() and meridianLongitude() now throw
              exceptions on error instead of returning null.
            - New routine linkingSurface().
        Class Triangulation<4>:
            - New routine intersectionForm().
            - New routine linkingSurface().
            - New optimisations that reduce the need for 3-sphere/3-ball
              recognition when modifying a triangulation.
        Class Vector:
            - Routine scaleDown() now returns the gcd that was used.
        Class Vertex<3>, Vertex<4>:
            - New routine linkingSurface().
        Function for_constexpr():
            - New routine to support compile-time for loops.
        Functions gcd(), lcm():
            - Deprecated in favour of the new C++17 std::gcd() and std::lcm().
        Functions select_constexpr(), select_constexpr_as_variant():
            - New routine to support compile-time selection (similar to a
              compile-time switch statement).
        Function tightDecoding():
            - New template function that reconstructs integers and booleans
              from tight encodings.
        Functions tightEncode(), tightEncoding():
            - Added a global function to encode booleans.
        Global constants maxSafeFactor<...> and minSafeFactor<...>:
            - Added to facilitate overflow checking with native integer
              operations.
    PYTHON:
        - For classes that have a bool() cast operator, this is now wrapped in
          Python using the special __bool__() function (i.e., Python will now
          cast such objects to bool in the same way).
        - Fixed a deadlock in the GUI with functions that used callbacks (e.g.,
          Triangulation3.retriangulate()).  These functions *did* work with
          command-line regina-python.  The issue in the GUI was due to an
          incompatibility with pybind11 and multiple Python subinterpreters.
    UTILITIES:
        tricensus:
            - Now supports multithreading via the new --threads option.
            - Now supports additional text-based output formats via the new
              options --canonical and --encodings.
            - Now supports enumerating subcomplexes of triangulations
              via the new option --allowinvalid.
            - The --genpairs option is now much less memory-hungry when the
              automorphism group is large (e.g., with many boundary facets).

Version 7.0  [ 19 December, 2021 ]

    GENERAL:
        - The file format has changed.  It is still XML-based, but older
          versions of Regina will not be able to read files created by
          Regina 7.0 or later.  Regina can of course still both read
          the old format (transparently) and write it (if asked).
        - The packet tree is now used purely for the GUI and for file I/O.
          Mathematical objects such as triangulations, links, surface lists,
          etc. are standalone, without the overhead of the full packet tree
          infrastructure (so no labels, tags, listeners, or parent/child
          relationships).  To use them with the full packet tree
          infrastructure, use a PacketOf<...> wrapper.
        - Normal surface/hypersurface lists and angle structure lists no
          longer need their triangulations to sit above them in the
          packet tree, and indeed their triangulations may change or
          even be deleted.  Lists will maintain a "snapshot" of the original
          triangulation if necessary.
        - All packet types are now managed exclusively by std::shared_ptr
          (a promise from the engine, but also a new requirement for the user).
          All non-packet types (including all mathematical objects, which are
          now standalone types) have full value semantics, supporting copy,
          move, swap and assignment operations wherever this makes sense.
        - Now requires C++17 (not C++14).
        - Updated the bundled copy of Normaliz to version 3.8.9 (26 Sep 2020).
        - Updated the SnapPea kernel to the one shipped with SnapPy 2.8.
        - Regina no longer needs boost to build. It still ships the
          Boost.Graph headers (link/graph.h and triangulation/graph.h), but
          these not compiled into Regina itself, and are not actively tested.
        - Major simplifications to the triangulation template class hierarchies.
          A consequence is that the API docs are much more usable, since
          doxygen can finally understand the code again.
        - All ready-made packages, and the default build configuration, now only
          support dimensions 2-8.  This is because dimensions 9-15 added an
          enormous amount of overhead (especially with Python) for features that
          almost nobody was using in practice.  If you need dimensions 9-15:
          (a) please drop Ben a note so he knows there is interest; and
          (b) you can build Regina from source with the cmake flag -DHIGHDIM=1.
          The old -DLOWDIMONLY=1 flag is no longer supported.
        - Removed all support for transversely oriented normal surfaces.
          These were originally hooked into the normal surface machinery
          as an "experimental" feature, but they are fundamentally different
          kinds of objects and this was never really the right place for them.
          They will return in a future version of Regina, with their own
          dedicated suite of classes instead.
        - Environment variables such as REGINA_HOME and REGINA_PYLIBDIR
          are more consistently used, and should need to be set less often.
        - All XML parsing code is now private to Regina's engine, and the
          corresponding xml* headers are no longer installed.
        - All callback functions now forward reference arguments correctly:
          there is no longer any need to pass via std::ref() or std::cref().
        - Removed REGINA_API and associated macros.
    ENGINE:
        Class AbelianGroup:
            - Added a move constructor and move assignment operator.
            - Added a presentation matrix constructor.
            - Added rank and rank-with-invariant-factors constructors.
            - Added member and global swap() functions.
            - Added tightEncode() and tightEncoding() to help with perfect
              hashing.
            - Replaced the old addTorsionElement() and addTorsionElements()
              with a simpler and much faster addTorsion().  The old routines
              are kept but deprecated, and are reimplemented using addTorsion().
            - The chain complex constructors now explicitly check that
              the two matrices have compatible dimensions, and throw an
              exception if this is not true.
        Enum AngleAlgFlags, Class AngleAlg:
            - New flags to specifiy angle structure enumeration algorithms.
        Class AngleStructure, AngleStructureVector:
            - Angle structures now hold a snapshot of the underlying
              triangulation at the time of creation.  The triangulation
              that was originally used can be safely modified or even deleted.
            - The internal vector representation now uses Integer, not
              LargeInteger.
            - The class AngleStructureVector has been removed completely.
              Just use Vector<Integer> instead.
            - Replaced rawVector() with vector(), which now returns a reference
              (not a pointer) and is now accessible through python.  The old
              rawVector() is kept but deprecated, and returns by reference also.
            - AngleStructure now has copy and move constructors, copy and move
              assignment, and member and global swap() functions.  The old
              clone() is now deprecated; use the copy constructor instead.
            - Added comparison operators == and !=.
            - Added operator < to impose a total order.
            - Changed triangulation() to return a reference, not a pointer.
            - Constructors now take their arguments by reference (and,
              for the vector constructor, optionally an rvalue reference).
            - Added variants of constructors that take a SnapshotRef of
              a triangulation instead of a triangulation.
        Class AngleStructures:
            - Angle structure lists now hold a snapshot of the underlying
              triangulation at the time of creation.  The triangulation
              that was originally used can be safely modified or even deleted.
            - Replaced enumerate() and enumerateTautDD() with a unified class
              constructor; this will not insert the new list into the packet
              tree, and will not start in a background thread.  The new class
              constructor allows you to choose your preferred enumeration
              algorithm via an AngleAlg argument.  The old enumerate() and
              enumerateTautDD() are kept as deprecated aliases, and now
              explicitly return packets (not "pure" AngleStructures objects).
            - Added copy/move construction and copy/move assignment.
            - Added member and global swap() functions.
            - Added begin() and end() for iteration through angle strutures.
            - Added comparison operators == and !=.
            - Changed triangulation() and surface() to return const references,
              not pointers.
            - Changed enumerate() and enumerateTautDD() to take the
              triangulation argument by reference, not by pointer.
            - When cloning a packet tree, a cloned angle structure list
              will now refer back to the original triangulation, not a
              clone of the original triangulation.
        Class ArcIterator:
            - Moved into link/graph.h, since this is not used anywhere
              outside the Boost Graph Library interface.
        Class Attachment:
            - New packet class that replaces and enhances the old PDF class.
        Class AugTriSolidTorus:
            - Class constants are now constexpr.
            - Routine augTorus() now returns a std::optional by const reference,
              not a pointer that could be null.
            - Routine isAugTriSolidTorus() is now called recognise(), and
              returns a std::unique_ptr instead of a raw pointer.
              The old name is kept as a deprecated alias.
            - Added copy construction and copy assignment.
            - Added member and global swap() functions.
            - Added comparison operators == and !=.
            - Routine edgeGroupRoles() now returns a Perm<3>, not a Perm<4>
              that always maps 3 to 3.
            - Deprecated clone().  Just use the copy constructor instead.
        Class BanConstraintBase, BanNone, BanBoundary, BanTorusBoundary:
            - All methods are now public, not protected.
            - The init() routines are removed; instead these are now
              rolled into the class constructors, which all now take a
              single LPInitialTableaux as argument.
            - Added comparison operators == and !=.
            - Now derive from ShortOutput.
            - BanNone no longer derives from BanConstraintBase; instead this is
              intended as a trivial drop-in replacement.
        Class Base64SigEncoding:
            - New helper class that provides code common to isomorphism
              signatures and knot signatures.
        Class BitManipulator and related classes:
            - The class constants ...::specialised are now constexpr bools,
              not enum values.
        Class Bitmask, Bitmask1, Bitmask2:
            - Added compile-time constant fixedSize.
            - Added != to complement the already-existing == operator.
              Also, Bitmask can now compare bitmasks of different lengths,
              though the behaviour here has some important caveats; see the
              documentation for details.
            - Bitmask now has a move constructor, move assignment, and
              member and global swap() functions.
        Class BitmaskLen8, BitmaskLen16, BitmaskLen32, BitmaskLen64:
            - Deprecated.  Just use Bitmask1<uint8_t>, etc.
        Class BlockedSFS, BlockedSFSLoop, BlockedSFSPair, BlockedSFSTriple:
            - Routines isBlockedSFS...() are now called recognise(), take their
              triangulation arguments by const reference (not pointer), and
              return a std::unique_ptr instead of a raw pointer.
              The old names are kept as deprecated aliases.
            - Added copy/move construction and copy/move assignment.
            - Added member and global swap() functions.
            - Added comparison operators == and !=.
            - Changed BlockedSFS::isPluggedIBundle() to take no arguments,
              and instead return a std::optional<std::string>.
        Class BoolSet:
            - Almost everything in this class is now constexpr.
            - The class constants sNone, sTrue, sFalse, sBoth are deprecated.
              Just use BoolSet(), true, false, or BoolSet(true, true).
            - Most routines that took a (const BoolSet&) now just take a
              BoolSet by value.
            - New routines stringCode() and setStringCode().
            - Routine setByteCode() now detects invalid codes, and
              returns a boolean accordingly.
        Class BoundaryComponent<dim>:
            - Routines faces(), facets(), and the aliases vertices(), edges(),
              etc. no longer return a const reference to a std::vector, but
              instead return a lightweight ListView object by value.
              C++ users should just use auto, and Python users are unaffected.
              See the analagous Triangulation<dim> changes for further details.
            - Routine build() now returns by const reference (not const
              pointer), and behaves correctly in the presence of pinched faces
              (which only appear in invalid triangulations).
            - Simplified the class hierarchy; BoundaryComponentFaceInterface,
              BoundaryComponentStorage, BoundaryComponentFaceStorage,
              WeakFaceList and WeakFaceListSuite are all gone.
            - New compile-time constant dimension.
            - Dimension 3 is no longer specialised: all dimensions now share
              the same generic code.
            - Higher dimension (dim >= 5) can now access: isReal(), isIdeal(),
              isInvalidVertex() (which always return true, false, false
              respectively); face<dim-1>(), faces<dim-1>(), countFaces<dim-1>();
              and countFaces<dim-2>().
        Class BoundaryComponent<4>:
            - All of the changes listed for BoundaryComponent<dim> above.
            - Added eulerChar().
        Class CensusDB:
            - Added member and global swap() functions.
            - Added comparision operators == and !=.
        Class Census, CensusHit, CensusHits, CensusHitIterator:
            - CensusHit objects can now be passed around by value: they
              now have copy/move construction and assignment, local and
              global swap() functions, and comparison (== and !=) operators.
            - The CensusHits and CensusHitIterator classes are removed
              completely.  Instead, Census::lookup() now returns a std::list
              of CensusHit objects.
            - CensusHit has no next() function.
            - CensusHit::db() now returns by reference, not pointer.
            - CensusDB::lookup() now takes a callback action to perform
              on each hit, not a CensusHits pointer.
        Enum CensusPurgeFlags, Class CensusPurge:
            - A proper flags class for the purge constants that used to live
              within GluingPerms<3>.  Now these flags are more carefully typed.
            - Moved out of GluingPerms<3> and into Regina's main namespace.
        Class Component<dim>:
            - Routines simplices(), boundaryComponents(), faces(), and the
              aliases vertices(), edges(), etc. no longer return a
              const reference to a std::vector, but instead return a
              lightweight ListView object by value.
              C++ users should just use auto, and Python users are unaffected.
              See the analagous Triangulation<dim> changes for further details.
            - New compile-time constant dimension.
            - Routine countFaces() (for those dimensions where it exists)
              now supports the case subdim == dim.
        Class Container:
            - Added a trivial copy constructor and copy assignment operator.
            - Added trivial member and global swap() functions.
        Class CrossingIterator:
            - Moved into link/graph.h, since this is not used anywhere
              outside the Boost Graph Library interface.
        Class Cusp:
            - These objects can now be passed around by value; their memory
              locations are not intended to uniquely identify a cusp.
            - Added a copy constructor and copy assignment operator.
            - Added equality testing operators == and !=.
        Class Cyclotomic:
            - Added member and global swap() functions.
            - Changed polynomial() to return by value, not by pointer.
            - Added a constructor that takes coefficients via an iterator pair.
        Class DiscType:
            - Almost everything in this class is now constexpr.
            - The class constant NONE is deprecated.  Just use DiscType().
            - Added a bool() operator that tests for a null disc type.
        Class DiscSpecIterator:
            - This is now a template class, templated upon the
              DiscSetSurface / DiscSetSurfaceData type that it works with.
        Class DiscSetSurface, DiscSetSurfaceData:
            - Merged into a single class DiscSetSurfaceDataImpl, with
              appropriate typedefs for DiscSetSurface and DiscSetSurfaceData.
            - Added copy/move construction and copy/move assignment.
            - Added member and global swap() functions.
            - Added comparison operators == and !=.
            - Function adjacentDisc() now returns an optional pair by value,
              instead of taking output variables by reference and
              returning newly allocated pointers that could be null.
        Class DiscSetTet, DiscSetTetData:
            - The destructors are no longer virtual.  Classes that own
              DiscSetTetData objects now need to know the specific subclass.
            - DiscSetTetData has a new typedef Data, and the old typedef
              DataPtr is now deprecated.
            - Added copy construction and copy assignment.
            - Added move construction, move assignment, and member/global
              swap() functions to DiscSetTetData.
            - Added comparison operators == and !=.
            - DiscSetTet::discFromArc() now returns a std::pair instead
              of taking output variables by reference.
        Class DoubleDescription:
            - Renamed enumerateExtremalRays() to enumerate().  The old name
              is removed completely.
            - Can now output to either of Regina's arbitrary precision
              integer types, not only LargeInteger.
            - The main enumeration routine no longer takes an output iterator;
              instead it takes a callable object (e.g., a lambda).
            - The main enumeration now returns each ray by rvalue reference,
              not by pointer to a newly allocated object.
        Class EnableIf<condition, T, defaultValue>:
            - Added to support data members that only appear for some
              template parameters (such as validity and link orientability
              for triangulation faces).
        Class EnumConstraints:
            - This has been removed completely, in favour of the new class
              ValidityConstraints.
        Class Example<dim>, ExampleLink, ExampleSnapPea:
            - All examples now return by value, not by newly allocated pointer.
        Class Example<3>:
            - All of the changes from Example<dim> described above.
            - Renamed poincareHomologySphere() to poincare().  The old name
              is kept but deprecated.
            - Added sfsOverSphere() and layeredLoop().
        Class Example<4>:
            - Added cp2(), s2xs2() and s2xs2Twisted(); thanks to Rhuaidi Burke.
        Class Face<dim, subdim>:
            - New compile-time constants allowsNonOrientableLinks and
              allowsInvalidFaces.
            - Simplified the class hierarchy; FaceOrientability, FaceValidity,
              FaceListHolder and FaceStorage are all now gone.
            - New compile-time constants dimension and subdimension.
            - For those faces that have a buildLink() function, this now
              returns by const reference instead of const pointer.
              Also, buildLinkDetail() has been renamed buildLinkInclusion();
              the old name is removed entirely.  This now returns just an
              isomorphism by value: the triangulation should be fetched via
              buildLink(), and the labelling option is gone.
            - New routine embeddings(), as a more readable alternative to
              iterating over the face itself.
        Class FaceEmbedding<dim, subdim>:
            - Local copies of these objects can now happily outlive their
              underlying faces.  This is because they now carry their entire
              embedding permutations with them.  This change actually shrinks
              the object size in Regina's standard dimensions, and it also
              speeds up calls to vertices(), but it does marginally slow
              down calls to face().
            - The equality/inequality tests have changed meaning.  They are
              stronger in that not just the face *numbers* need to be the same,
              but the entire embedding permutations returned by vertices()
              need to be the same.  They are weaker in that only the simplex
              numbers are compared, not the simplex pointers (so you can
              now meaningfully compare objects from different triangulations).
            - The old (simplex, face number) constructors are removed, with new
              (simplex, embedding permutation) constructors to replace them.
            - For orientable components of triangulations, the sign of the
              vertices() permutations now matches the orientation of the
              corresponding simplex (with some necessary exceptions for
              (dim-1)-faces).
        Class FaceNumbering<dim, subdim>:
            - Everything in this class is now constexpr.
            - New class constants lexNumbering and oppositeDim.
            - Simplified the underlying web of template specialisations.
        Class FacePair:
            - New routines commonEdge() and oppositeEdge().
            - Increment/decrement operators now insist that the face
              pair is not past-the-end/before-the-start respectively.
        Class FacetPairing<dim>, FacetPairingBase<dim>:
            - Added a copy assignment operator.
            - Added move constructors and move assignment operators.
            - Added member swap(), and for FacetPairing<dim> a global swap().
            - Function fromTextRep() now returns by value (not pointer), and
              throws an exception on error (instead of returning null).
            - Added comparison operators == and !=.
            - Type IsoList now stores isomorphisms by value, not by pointer.
            - Routine findAutomorphisms() now returns a list by value, instead
              of filling a given list.
            - Routine findAllPairings() now uses a type-safe template-based
              mechanism for its callback function, instead of a function
              pointer with void* arguments.  Moreover, it no longer receives
              an extra (null, null) call once the enumeration has finished.
            - New constructor that reads a text representation from an
              input stream.
        Class FailedPrecondition:
            - New exception class.
        Class FaithfulAssignment:
            - New type trait to identify which of Regina's integer types
              can be losslessly assigned to which others.
        Class FileError:
            - New exception class.
        Enum FileFormat:
            - New enumeration to indicate broad classes of interoperable
              XML file formats.
        Class FileInfo:
            - Added a move constructor and move assignment operator.
            - Added member and global swap() functions.
            - Added comparison operators == and !=.
            - Class constant TYPE_XML is now constexpr.
            - Routine identify() now returns a std::optional<FileInfo>,
              not a newly allocated pointer that could be null.
            - Added format() and formatDescription() and completely removed
              type(), typeDescription() and TYPE_XML, since there is now more
              than one generation of XML file format.
        Class FuncDelete, FuncNew, FuncNewCopyPtr, FuncNewCopyRef,
                FuncNewCopyClonePtr:
            - Removed completely, since C++ provides good alternatives nowadays.
        Class GlobalDirs:
            - Added deduceDirs() as an alternative to setDirs().  This new
              routine also supports running directly from the source tree, and
              respects environment variables REGINA_HOME and REGINA_PYLIBDIR.
            - Removed pythonLibs(), since nothing has been installed to
              this path since Regina 5.0.
        Class GluingPerms<dim>:
            - Added a move constructor and copy/move assignment operators.
            - Added member and global swap() functions.
            - Added comparison operators == and !=.
            - Added a type alias Index, which is now used instead of int
              to properly represent permutation indices in higher dimensions.
            - Routine facetPairing() now returns by reference, not pointer.
            - Routines facetPairing() and gluingPerm() are renamed to pairing()
              and perm(); the old names are kept as deprecated aliases.
            - The input stream constructor now throws an InvalidInput
              exception upon error.  The inputError() routine has been removed.
            - All previously-protected functions are now public: this
              includes permIndex(), gluingToIndex(), indexToGluing(), and the
              FacetPairing constructor.
            - The destuctor and dumpData() are no longer virtual.
            - Routine triangulate() now returns by value, not pointer.
            - The read-only versions of permIndex() now return by value,
              not by const reference.
            - New static routine fromData().
        Class GluingPermSearcher<dim> and subclasses:
            - No longer derived from GluingPerms<dim>, which means that
              none of the previously-inherited functions are available.
            - Significant reorganisation of the API for enumerating
              permuatation sets; this includes:
                * The callback function is passed to runSearch() or
                  partialSearch(), not the class constructor or other static
                  construction routines;
                * The callback function and its arguments now use a type-safe
                  template mechanism, not function pointers and void pointers;
                * The callback function now receives its permutation by
                  reference, and using the parent class GluingPerms<dim>;
                * The callback function no longer receives an extra null call
                  once the enumeration has finished;
                * The search manager now copies (or moves, if possible) the
                  given facet pairing, and so no longer relies on the original
                  facet pairing existing for the lifetime of the search;
                * The runSearch() routine no longer takes a depth argument;
                  instead there is a new partialSearch() routine for that.
                * Several other arguments are now passed by reference or
                  by value, not by pointer.
            - Several class constants are now constexpr.
            - The input stream constructor now throws an InvalidInput
              exception upon error.  The inputError() routine has been removed.
            - Routine bestSearcher() now returns a std::unique_ptr.
            - Routine readTaggedData(std::iostream&) has been renamed to
              fromTaggedData(), returns a std::unique_ptr, and throws an
              exception on error instead of returning null.
            - Added string-based functions taggedData(), data(), and
              fromTaggedData(const std::string&).
            - Derives from ShortOutput.
            - Renamed public constants ...::dataTag_ to ...::dataTag.
            - Renamed completePermSet() to isComplete().  The old name
              is kept as a deprecated alias.
            - Moved GluingPermSearcher<3>::PurgeFlags to the more carefully
              typed regina::CensusPurge and regina::CensusPurgeFlags.
              The old name is kept as a deprecated type alias.
        Class GraphLoop, GraphPair, GraphTriple:
            - Constructors now take Seifert fibred spaces either by
              const reference (which copy) or by rvalue reference (which move),
              not by pointer (which used to transfer ownership).
            - Added move constructors and move assignment operators.
            - Added member and global swap() functions.
            - Constructors now check some preconditions and throw exceptions if
              they fail (these checks were previously done during homology()).
            - Added comparison operators == and !=.
        Class GroupExpression:
            - Added move constructors and move assignment operators.
            - Added a constructor that takes a single term, or a single
              generator/exponent pair.
            - Changed the string constructor to throw an exception on error;
              the old optional validity reporting argument is now removed.
            - Added a C-style string constructor.
            - Deprecated addStringFirst() and addStringLast(); just use
              addTermsFirst(string) and addTermsLast(string) instead.
            - New variant of substitute() that can replace all generators
              simultaneously.
            - Functions inverse() and power() now return by value, not pointer.
            - Functions addTermsFirst() and addTermsLast() now take the
              GroupExpression argument by value, not by const reference.
            - Added member and global swap() functions.
            - Renamed toTeX() to tex().  The old name is kept but deprecated.
            - Added more customisation options to writeTextShort(), and
              deprecated writeText() which is now redundant.
            - Now offers utf8() with UTF-8 exponents, as well as str(bool)
              and utf8(bool) that offer the choice of numbered or alphabetic
              generators.
        Class GroupPresentation:
            - New routines enumerateCovers(), incidence() and gap().
            - Added move constructors and move assignment operators.
            - New constructor to create free groups.
            - The vector-of-strings constructor now throws an exception
              on error, instead of silently removing the invalid relation.
            - Functions abelianisation() and markedAbelianisation() now
              return groups by value (which can then be moved from).
            - New routine abelianRank().
            - New routine relations().
            - Function addRelation() now takes its argument by value.
            - Added member and global swap() functions.
            - Added comparison operators == and !=.
            - Functions intelligentSimplify(), smallCancellation(),
              intelligentNielsen(), homologicalAlignment() and prettyRewriting()
              now return a std::optional<HomGroupPresentation>, not a bool
              (but this can be cast to a bool to give the previous behaviour).
              The corresponding ...Detail() functions are now deprecated
              aliases, and return this same std::optional<HomGroupPresentation>
              instead of a std::unique_ptr<HomGroupPresentation>.  The C++
              syntax should be largely unaffected, and the Python behaviour
              (returns None if there is no homomorphism) should remain the same.
            - Renamed toTeX() to tex().  The old name is kept but deprecated.
            - The short text output from str() is now identical to compact().
            - Other major cleanup and reorganisation under the hood.
        Class Handlebody:
            - This class now only represents orientable handlebodies.
              The old support for non-orientable handlebodies was incomplete
              and was not being used anywhere within Regina.
            - The constructor now takes only one argument (the old orientability
              argument is gone).
            - Renamed handles() to genus().  The old name is kept as a
              deprecated alias.
            - Deprecated isOrientable(), which now always returns true.
            - Added member and global swap() functions.
        Class HasReturnType:
            - Removed completely.
        Class HilbertCD, HilbertDual, HilbertPrimal:
            - Renamed enumerateHilbertBasis() to enumerate().  The old name
              is removed completely.
            - Can now output to either of Regina's arbitrary precision
              integer types, not only LargeInteger.
            - The main enumeration routine no longer takes an output iterator;
              instead it takes a callable object (e.g., a lambda).
            - The main enumeration now returns each basis element by
              rvalue reference, not by pointer to a newly allocated object.
        Class HomGroupPresentation:
            - Added a move constructor.
            - Added copy assignment and move assignment operators.
            - Added operator * for composition; the old composeWith() is
              now deprecated.
            - Added member and global swap() functions.
            - Renamed range() to codomain(), since this is what it actually is.
            - All functions that used to return a std::unique_ptr<X> now
              just return an X by value (which can then be moved from).
            - Constructors that used to take a domain, range and map(s) by
              reference now take these arguments by value.
            - The evaluate() and invEvaluate() functions now run in linear
              time, not quadratic time, and take their arguments by value.
            - Fixed an issue where intelligentSimplify(), intelligentNielsen()
              and smallCancellation() would always return true, regardless
              of what happened.  All three routines now return true if and
              only if either presentatation and/or the map has changed.
        Class HomMarkedAbelianGroup:
            - Added a move constructor.
            - Added copy assignment and move assignment operators.
            - Added member and global swap() functions.
            - Renamed range() to codomain(), since this is what it actually is.
            - Functions image(), kernel() and cokernel() now return a simpler
              AbelianGroup, not a MarkedAbelianGroup.
            - New routine summary().
            - All functions that used to return a std::unique_ptr<X> now
              just return an X by value (which can then be moved from).
            - Constructors that used to take (const MarkedAbelianGroup&) and
              (const MatrixInt&) arguments now take MarkedAbelianGroup and
              MatrixInt arguments by value.
            - The composition operator (*) now has an overload whose argument
              is an rvalue reference.
            - Now uses the mathematical class regina::Vector<Integer> instead of
              the non-mathematical class std::vector<Integer> for all arguments
              and return values.
            - All functions that used to return empty vectors on error now
              throw exceptions instead.
            - Routine writeReducedMatrix() is now deprecated; instead this
              information is output via writeTextLong() / detail().
        Class HomologicalData:
            - Now supports copy/move construction and copy/move assignment.
            - Added member and global swap() functions.
            - Some routines related to the torsion linking form can now throw
              exceptions.  This will only happen if an internal
              rational-to-double conversion fails; previously these
              routines just silently did the wrong thing.
            - The header for this class has moved from triangulation/ into
              triangulation/dim3/.
        Class HyperEncoding:
            - New class to describe how the internal integer vector is encoded.
        Class HyperInfo:
            - This used to be a template class full of compile-time constants.
              It is now a non-templated class filled with static functions,
              which are also constexpr (so you can still use them at
              compile time if needed, but you can now use them at runtime also).
            - Much of the functionality that HyperInfo<coords> used to provide
              is now accessible through HyperEncoding(coords).  This
              HyperInfo class has been stripped down to just provide
              "human-readable name" functions.
        Class Integer, LargeInteger:
            - The constructor that takes a NativeInteger is no longer explicit.
            - The constructors Integer(LargeInteger) and LargeInteger(Integer)
              are likewise no longer explicit.
            - Added move constructors and move assignment operators.
            - Added a global swap() to complement the member swap().
            - Added tightEncode() and tightEncoding() to help with perfect
              hashing.
            - The string constructors and assignment operators now recognise
              "inf" as infinity.  Also, these routines all now throw exceptions
              if the input string is invalid: the old bool pointer argument to
              the string constructors for testing validity is no longer present.
            - Added a variant of gcdWithCoeffs() that returns a tuple
              instead of using reference arguments.
            - Changed divisionAlg() to return a pair instead of using
              reference arguments.  The old version is kept but deprecated.
            - New routine safeLongValue(), which is like longValue() but
              throws an exception on overflow.
        Class InvalidArgument, InvalidInput:
            - New exception classes.
        Class Isomorphism<dim>, IsomorphismBase<dim>:
            - Added member and global swap() functions to Isomorphism<dim>.
            - Removed the IsomorphismBase<dim> base class; all functionality
              now lives directly within Isomorphism<dim>.
            - Added comparison operators == and !=.
            - Added composition operator (*) and inverse().
            - Functions apply() and applyInPlace() now take their
              arguments by reference, not pointer, and throw exceptions in some
              cases if input requirements are not met.  Moreover, apply() now
              returns by value, not by newly allocated pointer.
        Class IsoSigPrintable<dim>, IsoSigClassic<dim>,
                IsoSigDegrees<dim, subdim>, IsoSigEdgeDegree<dim>,
                IsoSigRidgeDegree<dim>:
            - New types and encodings for working with isomorphism signatures.
        Class IsReginaArbitraryPrecisionInteger:
            - New type trait to identify Regina's arbitrary precision integer
              types.
        Class L31Pillow:
            - Removed completely.  This one-off triangulation is instead
              rolled into the TrivialTri class.
        Class Laurent, Laurent2:
            - Added member and global swap() functions.
            - Added invertX(), and (for Laurent2 only) invertY().
            - Added operators < > <= >= to order polynomials using a
              well-defined (but unimportant) total order.
            - Added tightEncode() and tightEncoding() to help with perfect
              hashing.
            - Added a constructor for Laurent2 that takes coefficients via an
              iterator pair.
        Class LayeredChain:
            - Added copy assignment operator.
            - Added member and global swap() functions.
            - Add comparison operators == and !=.
        Class LayeredChainPair:
            - Routine isLayeredChainPair() is now called recognise(), and
              returns a std::unique_ptr instead of a raw pointer.
              The old name is kept as a deprecated alias.
            - Added copy construction and copy assignment.
            - Added member and global swap() functions.
            - Add comparison operators == and !=.
            - Deprecated clone().  Just use the copy constructor instead.
            - Routine chain() now returns by reference, not by pointer.
        Class LayeredLensSpace:
            - Routine isLayeredLensSpace() is now called recognise(), and
              returns a std::unique_ptr instead of a raw pointer.
              The old name is kept as a deprecated alias.
            - Added copy construction and copy assignment.
            - Added member and global swap() functions.
            - Add comparison operators == and !=.
            - Deprecated clone().  Just use the copy constructor instead.
        Class LayeredLoop:
            - Routine isLayeredLoop() is now called recognise(), and
              returns a std::unique_ptr instead of a raw pointer.
              The old name is kept as a deprecated alias.
            - Added copy construction and copy assignment.
            - Added member and global swap() functions.
            - Add comparison operators == and !=.
            - Deprecated clone().  Just use the copy constructor instead.
        Class LayeredSolidTorus:
            - Routines isLayeredSolidTorus(), formsLayeredSolidTorusBase()
              and formsLayeredSolidTorusTop() are now called recognise(),
              recogniseFromBase() and recogniseFromTop(), and now return a
              std::unique_ptr instead of a raw pointer.
              The old names are kept as deprecated aliases.
            - Added copy construction and copy assignment.
            - Added member and global swap() functions.
            - Added comparison operators == and !=.
            - Deprecated clone().  Just use the copy constructor instead.
            - Routine transform() now takes its arguments by reference.
            - Routine flatten() no longer takes a triangulation argument
              (since this was redundant), and now returns by value.
            - All access to the underlying triangulation is now const only.
        Class LayeredTorusBundle:
            - Routine coreIso() returns by const reference, not by pointer.
            - Routine isLayeredTorusBundle() is now called recognise(), takes
              its triangulation argument by const reference (not pointer), and
              returns a std::unique_ptr instead of a raw pointer.
              The old name is kept as a deprecated alias.
            - Added copy construction and copy assignment.
            - Added member and global swap() functions.
            - Added comparison operators == and !=.
        Class Layering:
            - Added copy construction and copy assignment.
            - Added comparison operators == and !=.
            - All access to the underlying triangulation is now const only.
        Class LensSpace:
            - Added member and global swap() functions.
        Class LessDeref:
            - Removed completely.  Just use a lamba if you need to.
        Class LightweightSequence<T>:
            - Added member and global swap() functions.
            - Added a constructor that takes a combination of elements
              and iterator pairs.
            - Replaced the old SubsequenceCompareFirstPtr with the new
              SubsequenceCompareFirst, which is significantly redesigned,
              and which now works with containers whose keys are sequences,
              not pointers to sequences.  The old class is removed completely.
            - Removed the inner class Less.
        Class Link:
            - New routines writheOfComponent() and selfFrame().
            - New routine group().
            - New routines pd(), pdData(), pd(std::ostream&) and fromPD() to
              work with planar diagram codes.  The "magic" constructor that
              takes a string can now also work with planar diagram codes.
            - New routines gaussData(), orientedGaussData(), jenkinsData(),
              dtData(), and fromJenkins(Iterator, Iterator) for working with
              knot/link codes in machine-readable format.
            - Routines gauss(), orientedGauss(), dt() and knotSig() now throw
              exceptions if the link is not supported (e.g., it has zero or
              multiple components), instead of returning the empty string.
            - Routine fromData() now returns by value, and throws an exception
              on error (it used to return a newly allocated pointer that was
              null on error).
            - The "magic" string contructor likewise now throws an exception
              on error (instead of constructing an empty link).
            - Added a variant of fromData() that takes iterator pairs,
              which allows the data to be constructed at runtime.
            - New routine brief(std::ostream&) to complement brief().
            - New alias fromSig(), which is is identical to fromKnotSig().
            - Added comparison operators == and !=.
            - Class constants for Jones / HOMFLY-PT variable strings are
              now constexpr.
            - Renamed swapContents() to swap(); the old name is now a
              deprecated alias.  Also added a global regina::swap(Link&, Link&).
            - Overhauled rewrite() to be faster, more generic, and support
              actions that take a knot signature as well as a full knot
              diagram.  This function is now also available through Python,
              and can take a pure Python function as its action argument.
              It no longer runs in the background (even if a progress tracker
              is passed), and it now requires as a precondition that the link
              has precisely one component (throwing an exception otherwise).
            - Routine simplifyExhaustive() no longer runs in the background
              (even if a progress tracker is passed), and it now throws an
              exception if the link has multiple components.
            - Routine useTreeDecomposition() now takes its argument by
              value, not by const reference.
            - Routine writePACE() no longer begins its output with a "c ..."
              line, since links no longer have labels.
            - Routines complement() and parallel() now return by value,
              not pointer.
            - Routines bracket(), jones(), homfly(), homflyAZ() and homflyLM()
              now always run in the current thread, even if a progress
              tracker was passed.
            - New static routine homflyAZtoLM().
            - New routines crossings() and components().
        Class ListOnCall:
            - Removed, since this class was not thread-safe and did not add
              anything non-trivial.
        Class ListView:
            - New lightweight objects for basic read-only access to lists.
        Class LPConstraintBase and all subclasses:
            - Changed nConstraints from an enum value to a static constexpr int.
            - Simplified the way in which coefficients are stored.  The old
              Coefficients structures are gone, replaced by a new Coefficient
              type alias and a new octAdjustment constant.  Coefficients
              are now stored directly within LPCol via the field LPCol::extra.
            - Changed addRows() to take an initial tableaux instead of a
              triangulation and column permutation.
            - The verify() routines now take their arguments by reference,
              not by pointer.
        Class LPConstraintEuler, LPConstraintEulerPositive:
            - LPConstraintEuler has been renamed to LPConstraintEulerPositive.
              The old name is kept as a deprecated typedef.
        Class LPConstraintEulerZero:
            - New constraint to use with normal surface enumeration that
              fixes Euler characteristic to be zero.
        Class LPData:
            - Routine reserve() now takes the tableaux by reference.
            - Routine extractSolution() now returns its vector by value,
              instead of using a reference argument.
            - Now derives from Output.  The old dump() is now deprecated,
              in favour of the usual Output routines.
        Class LPInitialTableaux:
            - The constraintsBroken() routines are gone; instead the class
              constructor throws an exception on error.
            - The enumeration constructor argument now defaults to true.
            - Now derives from Output.
        Class LPMatrix:
            - Now derives from Output.  The old dump() is now deprecated,
              in favour of the usual Output routines.
            - Added comparison operators == and !=.
        Class LPSystem:
            - New class to translate coordinate systems into a layout
              for LPInitialTableaux.
        Class Manifold:
            - Routines construct() and homology() now return by value, not by
              pointer, and throw exceptions on error instead of returning null.
            - The alias homologyH1() is now deprecated.
            - Renamed TeXName() to texName().  The old name is kept but
              deprecated.
        Class MarkedAbelianGroup:
            - New move constructor.
            - New copy assignment and move assignment operators.
            - Added member and global swap() functions.
            - Added comparison operators == and !=.  The old equalTo() is
              now a deprecated alias.
            - The chain complex constructors now explicitly check that
              the two matrices have compatible dimensions, and throw an
              exception if this is not true.
            - Now uses the mathematical class regina::Vector<Integer> instead of
              the non-mathematical class std::vector<Integer> for all arguments
              and return values.
            - All functions that used to return empty vectors on error now
              throw exceptions instead.
            - All functions that used to return a std::unique_ptr<X> now
              just return an X by value (which can then be moved from).
            - New function unmarked() that returns a plain AbelianGroup.
            - Constructors that used to take (const MatrixInt&) arguments
              now take a MatrixInt by value.
            - Removed isChainComplex(), since this should always be true
              by the constructor preconditions.  If you need to test this
              for debugging purposes, just check (M*N).isZero().
            - Renamed several functions: M() to m(), N() to n(), rankCC() to
              ccRank(), boundaryMap() to boundaryOf(), minNumberOfGenerators()
              to snfRank(), minNumberCycleGens() to cycleRank(), and
              writeAsBoundary() to asBoundary().
              The old names are kept as deprecated aliases.
        Class MarkedVector:
            - New convenience routine clear_destructive().
            - New typedefs value_type, reference and const_reference.
            - New global swap() to complement the existing member swap().
            - Granted access to the reserve() member function.
        Class Matrix:
            - New routine transpose().
            - New routines rowEchelonForm() and columnEchelonForm() for
              matrices over Regina's integer types (including MatrixInt).
            - New operator * for multiplying a matrix by a vector.
            - New routines combRows() and combCols().
            - New constructor that takes the side length of a square matrix.
            - New constructor that takes a hard-coded list of entries
              via a C++11 initialiser list.  The old python-only
              initialise([...]) is now deprecated in favour of this constructor.
            - New default constructor that leaves the matrix in an
              uninitialised state.
            - Added member and global swap() functions.
            - Several row and column operations now take an extra optional
              parameter to operate on only part of the row/column.
            - Renamed swapColumns() to swapCols().  The old name is kept
              as a deprecated alias.
            - Routine swapRows() is now constant time.
            - The type Matrix<bool> is now wrapped in Python under the name
              MatrixBool.
            - Routine writeMatrix() is now deprecated, since it is
              identical to writeTextLong().
            - Replaced the type alias Coefficient with the standard container
              type alias value_type.  Coefficient is now deprecated.
        Class Matrix2:
            - Added member and global swap() functions.
            - Re-engineered to use std::array internally.  This means
              that the row access functions change their return type
              (but the syntax for the user should stay the same).
              All functions that take a long[2][2] array are now deprecated.
        Class MaxAdmissible:
            - Function enumerate() now returns by value, not by pointer.
        Class ModelLinkGraph:
            - Added a copy assignment operator.
            - Added a move constructor and move assignment operator.
            - Renamed swapContents() to swap(); the old name is now a
              deprecated alias.  Also added a global
              regina::swap(ModelLinkGraph&, ModelLinkGraph&).
            - Added comparison operators == and !=.
            - Routine generateMinimalLinks() now uses a type-safe template-based
              mechanism for its callback function, instead of a function
              pointer with void* arguments, and the callback now takes its
              link by rvalue (not pointer).  Moreover, it no longer receives
              an extra null call once the enumeration has finished.
            - Routines fromPlantri() and flype() now return by value (not
              pointer), and throw exceptions on error instead of returning null.
            - New routine nodes().
        Class ModelLinkGraphCells:
            - New typedef ArcIterator, which is returned by begin() and end().
            - New routine arcs().
        Class NativeInteger<...>:
            - New do-nothing routines isInfinite() and tryReduce(), for
              compatibility with Integer and LargeInteger.
            - Added a global swap() to complement the member swap().
            - Changed divisionAlg() to return a pair instead of using
              reference arguments.  The old version is kept but deprecated.
        Class NewFunction<...>:
            - Removed completely.
        Class NNativeLong:
            - Renamed to NativeLong.  The old name is a deprecated typedef.
        Class NormalEncoding:
            - New class to describe how the internal integer vector is encoded.
        Class NormalInfo:
            - This used to be a template class full of compile-time constants.
              It is now a non-templated class filled with static functions,
              which are also constexpr (so you can still use them at
              compile time if needed, but you can now use them at runtime also).
            - Much of the functionality that NormalInfo<coords> used to provide
              is now accessible through NormalEncoding(coords).  This
              NormalInfo class has been stripped down to just provide
              "human-readable name" functions.
        Class NormalHypersurface:
            - Normal surfaces now hold a snapshot of the underlying
              triangulation at the time of creation.  The triangulation
              that was originally used can be safely modified or even deleted.
            - Replaced rawVector() with vector(), which now returns a
              Vector<LargeInteger> by reference (not a Vector by pointer).
              The old name is kept but deprecated.
            - Added copy and move constructors, copy and move assignment
              operators, and member and global swap() functions.  The old
              clone() now is deprecated; use the copy constructor instead.
            - Changed triangulation() to return a reference, not a pointer.
            - Changed doubleHypersurface() to return by value, not by pointer.
            - Constructors now take their arguments by reference (and,
              for the vector constructors, optionally an rvalue reference).
            - Added variants of constructors that take a SnapshotRef of
              a triangulation instead of a triangulation.
            - New routine encoding(), which explains how to interpret
              the internal integer vector.
            - New routine reconstructTetrahedra(), which now makes this
              functionality available to the outside world.
            - Renamed sameSurface() to operator ==, and added operator !=.
              The old routine sameSurface() is kept but deprecated.
            - Added operator < to impose a total order.
            - Removed countCoords() completely, since its meaning is
              amgibuous as to whether it refers to the original
              coordinate system or the current internal encoding.
              Just use vector().size() instead.
            - New operator +.  At last!  Crucially, this operator can combine
              hypersurfaces that use different coordinate systems.
            - Routine triangulate() now returns by value, not pointer.
            - Routine writeRawVector() is deprecated (and unnecessary).
        Class NormalHypersurfaces:
            - Normal hypersurface lists now hold a snapshot of the underlying
              triangulation at the time of creation.  The triangulation
              that was originally used can be safely modified or even deleted.
            - Now supports enumeration in prism coordinates (HS_PRISM).
            - Replaced enumerate() with a class constructor; this will throw an
              exception on error (instead of returning null), will not insert
              the new list into the packet tree, and will never start in a
              background thread.  The old enumerate() function is kept as a
              deprecated alias, but (a) it now explicitly returns a packet
              (not a "pure" NormalHypersurfaces object), and (b) Python users
              can no longer use it with a progress tracker.
            - Added copy/move construction and copy/move assignment.
            - Added member and global swap() functions.
            - Added begin() and end() for iteration through hypersurfaces.
            - Added comparison operators == and !=.
            - Changed triangulation() and hypersurface() to return
              const references, not pointers.
            - Changed enumerate() to take the triangulation argument by
              reference, not by pointer.
            - Changed sort() so the comparison function must now take
              two hypersurfaces by reference, not by pointer.
            - New function allowsNonCompact().
            - When cloning a packet tree, a cloned normal hypersurface list
              will now refer back to the original triangulation, not a
              clone of the original triangulation.
        Class NormalSurface:
            - Normal surfaces now hold a snapshot of the underlying
              triangulation at the time of creation.  The triangulation
              that was originally used can be safely modified or even deleted.
            - Replaced rawVector() with vector(), which now returns a
              Vector<LargeInteger> by reference (not a Vector by pointer).
              The old name is kept but deprecated.
            - Added copy and move constructors, copy and move assignment
              operators, and member and global swap() functions.  The old
              clone() now is deprecated; use the copy constructor instead.
            - Changed triangulation() to return a reference, not a pointer.
            - Changed boundaryIntersections() to return by value (not by
              pointer), and to throw an exception on error.
            - Changed doubleSurface() to return by value, not by pointer.
            - Constructors now take their arguments by reference (and,
              for the vector constructors, optionally an rvalue reference).
            - Added variants of constructors that take a SnapshotRef of
              a triangulation instead of a triangulation.
            - Removed systemAllowsOriented(), orientedTriangles() and
              orientedQuads() completely, since TONS are now handled by a
              completely different collection of classes.
            - Changed isCentral() to return size_t, not LargeInteger.
            - Routine disjoint() no longer requires both surfaces to use
              the same coordinate system.
            - New routine encoding(), which explains how to interpret
              the internal integer vector.
            - New routine reconstructTriangles(), which now makes this
              functionality available to the outside world.
            - Renamed sameSurface() to operator ==, and added operator !=.
              The old routine sameSurface() is kept but deprecated.
            - Added operator < to impose a total order.
            - Removed countCoords() completely, since its meaning is
              amgibuous as to whether it refers to the original
              coordinate system or the current internal encoding.
              Just use vector().size() instead.
            - Replaced systemAllowsAlmostNormal() and systemAllowsSpun() with
              new functions couldBeAlmostNormal() and couldBeNonCompact(), again
              to avoid ambiguities between the original coordinate system used
              for enumeration versus the current vector encoding being used.
              The old functions are removed completely.
            - New routine hasMultipleOctDiscs(), which has been moved from the
              old NormalSurfaceVector class.
            - New operator +.  At last!  Crucially, this operator can combine
              surfaces that use different coordinate systems.
            - New routine components().
            - Routines crush() and cutAlong() now return by value, not pointer.
            - Routine writeRawVector() is deprecated (and unnecessary).
        Class NormalSurfaces:
            - Normal surface lists now hold a snapshot of the underlying
              triangulation at the time of creation.  The triangulation
              that was originally used can be safely modified or even deleted.
            - Replaced enumerate() with a class constructor; this will throw an
              exception on error (instead of returning null), will not insert
              the new list into the packet tree, and will never start in a
              background thread.  The old enumerate() function is kept as a
              deprecated alias, but (a) it now explicitly returns a packet
              (not a "pure" NormalSurfaces object), and (b) Python users can
              no longer use it with a progress tracker.
            - Added copy/move construction and copy/move assignment.
            - Added member and global swap() functions.
            - Replaced quadToStandard(), quadOctToStandardAN(),
              standardToQuad(), standardANToQuadOct(), filterForDisjointPairs(),
              filterForLocallyCompatiblePairs() and
              filterForPotentiallyIncompressible() with a single class
              constructor that takes a NormalTransform; this will throw an
              exception on error (instead of returning null), and will not
              insert the new list into the packet tree.  The old functions
              are kept as deprecated aliases.
            - Added a class constructor that takes a SurfaceFilter.
            - Added begin() and end() for iteration through surfaces.
            - Added comparison operators == and !=.
            - Changed triangulation() and surface() to return const references,
              not pointers.
            - Changed enumerate() to take the triangulation argument by
              reference, not by pointer.
            - Changed sort() so the comparison function must now take
              two surfaces by reference, not by pointer.
            - Routine filterForDisjointPairs() no longer requires all surfaces
              to use the same coordinate system.
            - Removed allowsOriented() completely, since TONS are now
              handled by a completely different collection of classes.
            - Renamed allowsSpun() to allowsNonCompact(); the old name
              is kept as a deprecated alias.
            - Routines saveCSVEdgeWeight() and saveCSVStandard() now take the
              optional fields argument using the new type SurfaceExport.
            - When cloning a packet tree, a cloned normal surface list
              will now refer back to the original triangulation, not a
              clone of the original triangulation.
            - Deprecated writeAllSurfaces(); just use writeTextLong() or
              detail() instead.
        Class NormalSurfaceVector, NormalHypersurfaceVector:
            - Removed completely.  Normal surfaces/hypersurfaces now hold
              their coordinates using a plain Vector<LargeInteger>.
        Enum NormalTransform:
            - New enumeration to support conversions and filters.
        Class NoSolution:
            - New exception class.
        Class NotImplemented:
            - New exception class.
        Class Packet:
            - Packets are now managed exclusively by std::shared_ptr.
              Creating a new packet *without* wrapping it in a std::shared_ptr
              is no longer allowed.  To convert an existing raw packet pointer
              into a std::shared_ptr, use shared_from_this().  The old
              safeDelete() is now removed.
            - Inner class ChangeEventSpan's constructor now takes its
              argument by reference.
            - Routines dependsOnParent() and isPacketEditable() are
              deprecated, and now always return false and true respectively.
            - Routines save() and writeXMLFile() now take an optional
              XML file format argument.
            - Iteration routines begin(), end(), children(), descendants()
              now come in const and non-const versions.  The corresponding
              iterator / iteration classes ChildIterator, SubtreeIterator,
              PacketChildren, PacketDescendants are now templated according
              to constness, all dereference iterators now return packets by
              reference instead of by pointer, and all iterators can now
              be tested for dereferencability by casting to bool.
            - Functions firstTreePacket(type) and nextTreePacket(type) now
              take type as a PacketType, not a string.  The old functions
              are removed completely, because the typeName() string is
              not guaranteed to stay constant between releases.
            - Removed the "tree insertion constructor", which was never used.
            - New function hasParent().
            - Renamed isGrandparentOf() to isAncestorOf().  The old name
              is kept as a deprecated alias.
            - Changed levelsDownTo() and levelsUpTo() to throw an exception if
              the ancestor/descendant precondition fails, instead of crashing.
            - Renamed clone() to cloneAsSibling(), since this is not
              just a plain copy operation and it will not always succeed.
              The old clone() name is removed completely.
            - All member functions that used to return a raw Packet pointer
              return a shared_ptr instead.
            - All member functions that used to take a raw Packet pointer
              now take this either by shared_ptr or const reference.
        Class PacketChildren, PacketDescendants:
            - Added comparison operators == and !=.
        Class PacketData<Held>, PacketOf<Held>:
            - New template classes to support the new "wrapped" packet types.
        Class PacketInfo:
            - This used to be a template class.  It is now a non-templated
              class, and has been stripped down to just a single static name()
              function.  This function is constexpr, so you can still use it
              at compile time if needed, but you can now use it at runtime also.
        Class PacketListener:
            - New routine isListening().
            - Renamed unregisterFromAllPackets() to unlisten().  The old
              name is kept as a deprecated alias.
            - Renamed packetToBeDestroyed() to packetBeingDestroyed(), since
              it is called when the destructor is already in progress.  The old
              name is kept and marked final, to ensure it is not reimplemented.
            - Callbacks childToBeRemoved() and childWasRemoved() are no longer
              called from either the child or parent destructors.
            - All callbacks now take their packets by reference, not pointer.
              The old versions are again kept and marked as final, to ensure
              they are not reimplemented.
        Enum PacketType:
            - New constant PACKET_NONE.
            - Renamed PACKET_PDF to PACKET_ATTACHMENT.  The old name is
              kept as a deprecated alias.
        Class PDF:
            - This has been renamed to Attachment, and expanded to support any
              kind of file attachment (not just PDF documents).  The old
              class name PDF is kept as a deprecated type alias.
            - Added a copy constructor and a copy assignment operator.
            - Added member and global swap() functions.
            - Added a filename() routine.
            - The binary data constructor and the non-trivial reset() routine
              both now require an additional filename argument.
            - Renamed savePDF() to save(), with the old name kept as a
              deprecated alias.
        Class Perm<n>:
            - Constant arrays invS2, invS3, ... have been removed completely.
              Calling perm.inverse() directly is just as fast.  If you really
              needed invSn[i], use Sn[i].inverse().SnIndex() instead.
            - Replaced lookup tables S1, S2, S3, ..., orderedS2, orderedS3, ...
              with lightweight objects whose square bracket operators compute
              and/or look up the relevant permutations on the fly.
            - The C-style array constructors are now deprecated, and
              std::array constructors have been added in their place.
            - Renamed preImageOf() to pre().  The old name is kept as a
              deprecated alias.
            - Now all n (not just small n) have static members Sn and orderedSn
              and member functions SnIndex() and orderedSnIndex().
            - New static routine rot().
            - New class constant codeType.
            - For all classes that support packed image sequences in any form
              (n >= 4), added type ImagePack; constants imageBits, imageMask;
              and routines imagePack(), fromImagePack(), isImagePack().  For
              n >= 8 these are aliases for the permutation code routines; for
              n = 4..7 they are aliases for the first-generation code routines.
            - Almost everything in the permutation classes is now constexpr.
            - Routines index() and atIndex() are now deprecated.
              Use orderedSnIndex() and orderedSn[...] instead.
        Class Perm<2>, Perm<3>:
            - New (and trivial) routine isConjugacyMinimal().
            - New ++ and < operators.
            - New routines pow() and order().
            - Perm<3> gains a six-argument constructor, similar to those
              in Perm<4..6>.
        Class Perm<4>:
            - All of the changes listed for Perm<n> above.
            - New routine isConjugacyMinimal().
            - New ++ and < operators.
            - New routines pow() and order().
            - New routine pairs() which returnes the induced permutation
              on six pairs of elements.
            - New constant imageBits for consistency with higher order
              permutation classes.
            - Added a new typedef Code2; this is identical to Code, but
              it allows you to express more clearly in your source code
              which generation of code is being used.
            - Renamed Code to Code1, to clearly indicate that this is an old
              code type; the old typedef Code is still present but deprecated.
            - Renamed permCode(), setPermCode(), fromPermCode(), isPermCode()
              to permCode1(), setPermCode1(), fromPermCode1(), isPermCode1().
              The old names are now deprecated.
        Class Perm<5>, Perm<6>, Perm<7>:
            - All of the changes listed for Perm<n> above.
            - New routine isConjugacyMinimal().
            - New ++ and < operators.
            - New routines pow() and order().
            - Changed the internal representation; as a result there are new
              routines permCode2(), fromPermCode2(), setPermCode2() and
              isPermCode2(), and a new type Code2.  The old first-generation
              codes (used by permCode(), fromPermCode(), setPermCode() and
              isPermCode()) are slower to work with, and should be avoided.
            - Renamed Code to Code1, to clearly indicate that this is an old
              code type; the old typedef Code is still present but deprecated.
            - Renamed permCode(), setPermCode(), fromPermCode(), isPermCode()
              to permCode1(), setPermCode1(), fromPermCode1(), isPermCode1().
              The old names are now deprecated.
            - Several operations are now considerably faster than before
              (in particular, composition and inverses).
            - Perm<6,7> now gain most of the extra functionality that Perm<2..5>
              already had over the generic higher-order Perm<n> class.
            - Perm<6> also gains functions precompute(), cachedComp() and
              cachedPow() for users to generate and use lookup tables of
              products at runtime.
            - Perm<7> likewise gains precompute(), cachedComp(), cachedPow()
              and cachedOrder().
        Class PillowTwoSphere:
            - Routine formsPillowTwoSphere() is now called recognise(), and
              returns a std::unique_ptr instead of a raw pointer.
              The old name is kept as a deprecated alias.
            - Added copy construction and copy assignment.
            - Added comparison operators == and !=.
            - Deprecated clone().  Just use the copy constructor instead.
        Class PluggedTorusBundle:
            - Routine isPluggedTorusBundle() is now called recognise(), takes
              its triangulation argument by const reference (not pointer), and
              returns a std::unique_ptr instead of a raw pointer.
              The old name is kept as a deprecated alias.
            - Added copy/move construction and copy/move assignment.
            - Added member and global swap() functions.
            - Added comparison operators == and !=.
        Class PlugTriSolidTorus:
            - Class constants are now constexpr.
            - Routine chain() now returns a std::optional by const reference,
              not by pointer that could be null.
            - Routine isPlugTriSolidTorus() is now called recognise(), and
              returns a std::unique_ptr instead of a raw pointer.
              The old name is kept as a deprecated alias.
            - Added copy construction and copy assignment.
            - Added member and global swap() functions.
            - Added comparison operators == and !=.
            - Deprecated clone().  Just use the copy constructor instead.
        Class Polynomial:
            - Added member and global swap() functions.
            - Changed divisionAlg() to return a pair instead of using
              reference arguments.  The old version is kept but deprecated.
        Class ProgressTracker, ProgressTrackerOpen:
            - Now derives from ShortOutput.
            - Many member functions are now const.
        Class Property<...>:
            - Removed completely.  Use either std::optional<...> or
              std::unique_ptr<...> instead (according to your storage policy).
            - Added a move constructor and move assignment operator.
            - Added a global swap() to complement the member swap().
            - Removed the StoreConstPtr storage policy, which was never used.
        Class Qitmask1, Qitmask2:
            - Added != operator to complement the already-existing == operator.
            - Routines get() and set() now use values of type uint8_t, not char.
        Class QitmaskLen8, QitmaskLen16, QitmaskLen32, QitmaskLen64:
            - Deprecated.  Just use Qitmask1<uint8_t>, etc.
        Class Ray:
            - All of the old Ray functionality is now merged into
              Vector<LargeInteger>, and you should use that class directly.
              The name Ray is kept as a deprecated typedef.
        Class Rational:
            - Added a move constructor and move assignment operator.
            - Added a global swap() to complement the member swap().
            - Routine doubleApprox() now throws an exception on error
              instead of using an extra bool* argument.  The python-only
              doubleApproxCheck() is now deprecated.
            - Renamed TeX() to tex().  The old name is kept but deprecated.
        Class ReginaException:
            - New exception base class.
        Class Returns, ReturnsTraits:
            - Removed completely.
        Class SafePtr, SafePointeeBase:
            - Removed completely.
        Class SatAnnulus:
            - Added comparison operators == and !=.
            - Routines transform() and image() now take their arguments by
              reference.
            - Routine isAdjacent() now returns a tuple, instead of using
              a mix of return values and pointer arguments for output.
            - All access to the underlying triangulation is now const only.
            - Removed the member attachLST(), since SatAnnulus now allows
              only const access to the underlying triangulation.  Instead
              this is now a static member function, which takes (non-const)
              tetrahedra and permutations individually.
        Class SatBlock and subclasses:
            - The nextBlock output argument for nextBoundaryAnnulus()
              now sends back a const pointer.
            - Routine transform() now takes its arguments by reference.
            - All copy constructors and clone() functions are now either
              protected or private.
            - All insertBlock() routines have been replaced with safer model()
              routines that return a SatBlockModel by value.
            - Removed SatBlock::isBlock(), and made all subclass isBlock...()
              functions private (and with new names).  This functionality is
              now accessible through SatRegion::beginsRegion() instead.
            - Modifying routines transform() and setAdjacent() are now
              protected and private respectively.
            - Routine nextBoundaryAnnulus() now returns a tuple, instead
              of using several reference arguments for output.
            - Renamed nAnnuli() to countAnnuli().  The old name is kept
              as a deprecated alias.
            - Added comparison operators == and !=, which are customised for
              each subclass.
            - Routine SatLST::roles() now returns a Perm<3>, not a Perm<4>
              that always maps 3 to 3.
            - All access to the underlying triangulation is now const only.
        Class SatBlockModel:
            - New class to replace SatBlockStarter.
        Class SatBlockSpec:
            - This is now a full class, with read-only access functions
              to its data members which are now private.
            - This class now owns its SatBlock, and will take responsibility
              for deleting it.
            - Due to the change in ownership semantics, this class is no
              longer copyable; however, it is now movable and swappable.
            - This class is also no longer constructible (except for the
              new move constructor): only SatRegion is permitted to create a
              SatBlockSpec with arbitrary content.
            - Now derives from ShortOutput.
        Class SatBlockStarter:
            - Removed completely, and replaced with the new class SatBlockModel.
        Class SatBlockStarterSet:
            - Removed completely, and replaced with a hard-coded list
              that is private to the SatRegion class.
        Class SatBlockStarterSearcher:
            - Removed completely.  Instead use the new, simpler and more
              flexible routine SatRegion::find().
        Class SatBlockStarterSet:
            - Now requires a (lightweight) object to work with instead
              of using static routines only.  This makes the class
              suitable for use with C++11 range-based for loops.
            - This class is now thread-safe.
        Class SatLST:
            - Routine lst() now returns by reference, not pointer.
        Class SatRegion:
            - Routine createSFS() now returns by value, and throws an exception
              in the (rare) cases where it cannot determine the answer.
            - Changed the two versions boundaryAnnulus() into a single
              function that returns tuple instead of using reference arguments.
              The old functions are removed completely.
            - Added move construction, and move assignment.
            - New static routine find(), which replaces the old class
              SatBlockStarterSearcher.
            - New static routine beginsRegion(), which replaces the old
              SatBlock::isBlock().
            - Routine expand() is now private, since all publicly accessible
              functions that construct regions will expand them automatically.
            - New routine blockAbbrs() that returns the output of
              writeBlockAbbrs() in string format.
            - Added comparison operators == and !=.
            - Renamed numberOfBlocks() and numberOfBoundaryAnnuli() to
              countBlocks() and countBoundaryAnnuli(); the old names are
              kept as deprecated aliases.
            - All access to the underlying triangulation is now const only.
        Class Script:
            - Added a copy constructor and a copy assignment operator.
            - Added member and global swap() functions.
            - Added comparison operators == and !=.
            - Routines addVariable(), addVariableName() and setVariableValue()
              now take their value arguments by std::weak_ptr, and support a
              default argument representing a null variable.
            - Scripts no longer notify their listeners when a variable value
              is destroyed or changes its packet label (but in the former case
              they still correctly reset the variable value to null).
            - New routines listenVariables() and unlistenVariables().
        Class SFSAlt, SFSAltSet:
            - Removed the old SFSAltSet class; replaced this with a new SFSAlt
              class with a static altSet() function that returns a std::vector.
        Class SFSpace:
            - Added move constructors and move assignment operators.
            - Added member and global swap() functions.
            - Routine isLensSpace() now returns a std::optional by value,
              not a newly created pointer that could be null.
            - Routine insertFibre() now throws an exception if alpha is zero.
        Class ShortArray:
            - New class that is essentially a variable-but-bounded sized
              std::array.
        Class SigCensus:
            - New typedef SigIsoList to replace the old global SigIsoList.
            - The old global formSigCensus() is now a static member function
              formCensus(), which uses a type-safe template-based mechanism
              for callbacks instead of function pointers with void* arguments.
            - Function run() is now private.  The only way to access
              this class is through the static routine formCensus().
        Class SigIsoList:
            - Renamed to SigCensus::IsoList.  The old name has been kept
              as a deprecated typedef.
        Class Signature:
            - Added a copy assignment operator.
            - Added move constructors and move assignment operators.
            - Added member and global swap() functions.
            - Added comparison operators == and !=.
            - Replaced the old parse() with a new string-based constructor.
              The parse() function is deprecated, but it has also changed:
              it now returns by value (not pointer), and throws an exception
              on error instead of returning null.
            - Function triangulate() now returns by value.
            - Function cycleCmp() is now a private member function (it was
              very specialised).
            - New function str() that takes extra arguments to customise
              the output, in the same manner as writeCycles().
        Class SigPartialIsomorphism:
            - Added a copy assignment operator.
            - Added move constructors and move assignment operators.
            - Added member and global swap() functions.
            - Added comparison operators == and !=.
            - Function compareWith() now takes the other isomorphism by
              reference, not by pointer; added function compareWithIdentity()
              to implement the (undocumented) previous behaviour when
              the other isomorphism was null.
        Class SimpleSurfaceBundle:
            - Class constants are now constexpr.
            - Added member and global swap() functions.
        Class Simplex<dim>:
            - In orientable components of triangulations, the signs of each
              faceMapping() permutation now match the simplex orientation
              (with some necessary exceptions for (dim-1)-faces).
            - Simplified the class hierarchy; SimplexFaces and
              SimplexFacesSuite are both gone.
            - New compile-time constants dimension and subdimension.
        Class SnapPeaCensusManifold:
            - Class constants for the census sections are now constexpr.
            - Added member and global swap() functions.
        Class SnapPeaCensusTri:
            - Class constants for the census sections are now constexpr.
            - Routine isSmallSnapPeaCensusTri() is now called recognise(), and
              returns a std::unique_ptr instead of a raw pointer.
              The old name is kept as a deprecated alias.
            - Added copy construction and copy assignment.
            - Added member and global swap() functions.
            - Deprecated clone().  Just use the copy constructor instead.
        Class SnapPeaException, SnapPeaFatalError, SnapPeaMemoryFull:
            - The base class SnapPeaException is removed; instead the
              other classes inherit from standard C++ exception types,
              and return meaningful error messages via what().
            - Most member functions are now explicitly marked as noexcept.
        Class SnapPeaUnsolvedCase:
            - New exception class used when Regina needs to convert a clean
              SnapPea returned-with-error into an exception.
        Class SnapPeaTriangulation:
            - Routine cusp() now returns a const reference, and users are
              encouraged to copy this if they wish to keep the information.
              Cusps are not meant to be uniquely identified by Cusp pointers.
            - New routine cusps().
            - New constructor that takes a link and builds its complement.
            - The filename-or-contents constructor now throws an exception on
              error, instead of creating a null SnapPea triangulation.
            - Now supports move construction and copy/move assignment.
            - Added member and global swap() functions.
            - Added comparison operators == and !=.
            - The snapPea() export routines now throw an exception if the
              triangulation is null, instead of producing empty output.
            - New routine nullify().
            - Added new routine enumerateCovers(), which combines SnapPea's
              find_representations() and construct_cover().
            - Changed gluingEquations() and gluingEquationsRect() to return a
              MatrixInt by value, not by pointer.
            - Changed homologyFilled() and fundGroupFilled() to return by
              const reference (not by pointer), and to throw exceptions
              when preconditions are not met (instead of returning null).
            - Replaced the two versions of volume() with separate functions
              volume() and volumeWithPrecision() (which was already what
              the Python interface offered).  Also, these routines now
              throw exceptions in the case of a null triangulation instead of
              silently returning zero volume.
            - Changed slopeEquations() to return by value (not by pointer),
              and to throw an exception if the triangulation is null.
            - Routines gluingEquations(), gluingEquationsRect(),
              fundGroupFilled() and homologyFilled() now have a precondition
              that this must not be a null SnapPea triangulation (instead of
              the old behaviour of returning a null pointer).
            - Changed canonise() and protoCanonise() to return by value
              (not pointer), and to throw exceptions on error.
            - Replaced the old filledTriangulation() (which used a polymorphic
              return type) with filledPartial() and filledAll() (whose return
              types are known at compile time).
            - New constructor that takes raw SnapPea kernel data.
        Class SnappedBall:
            - Routine formsBall() is now called recognise(), and
              returns a std::unique_ptr instead of a raw pointer.
              The old name is kept as a deprecated alias.
            - Added copy construction and copy assignment.
            - Added member and global swap() functions.
            - Added comparison operators == and !=.
            - Deprecated clone().  Just use the copy constructor instead.
        Class SnappedTwoSphere:
            - Routine formsSnappedTwoSphere() is now called recognise(), and
              returns a std::unique_ptr instead of a raw pointer.
              The old name is kept as a deprecated alias.
            - The variant of recognise() that took a pair of snapped balls
              now takes these balls by reference, not pointer.  Likewise,
              snappedBall() now returns by reference, not pointer.
            - Added copy construction and copy assignment.
            - Added comparison operators == and !=.
            - Deprecated clone().  Just use the copy constructor instead.
        Class Snapshot, SnapshotRef, Snapshottable, SnapshotWriteError:
            - A new suite of classes for taking snapshots of a large
              object at a fixed moment in time.
        Class SFSpace:
            - Renamed classType enumeration to ClassType.  The old name
              is kept as a deprecated alias.
        Class SpiralSolidTorus:
            - Routine formsSpiralSolidTorus() is now called recognise(), and
              returns a std::unique_ptr instead of a raw pointer.
              The old name is kept as a deprecated alias.
            - Added copy and move construction, and copy and move assignment.
            - Added member and global swap() functions.
            - Add comparison operators == and !=.
            - Routines makeCanonical() and isCanonical() now take no
              arguments (the old triangulation argument was redundant).
            - Deprecated clone().  Just use the copy constructor instead.
        Class StandardTriangulation:
            - Routine isStandardTriangulation() is now called recognise(),
              and now returns a std::unique_ptr.  Also, the triangulation
              variant now takes its argument by const reference, not pointer.
              The old name is kept as a deprecated alias.
            - Routines homology() and homologyH1() now return by value, and
              throw an exception on error instead of returning null.
              Also, the alias homologyH1() is now deprecated.
            - Routine manifold() now returns a std::unique_ptr.
            - Renamed TeXName() to texName().  The old name is kept but
              deprecated.
        Class SurfaceExport:
            - A proper flags class for the normal surface CSV export constants,
              built from the SurfaceExportFields enumeration type.
        Class SurfaceFilter:
            - This is now an abstract base class.  If you need a filter
              that accepts everything, use a default-constructed
              SurfaceFilterProperties filter instead.
        Class SurfaceFilterCombination:
            - Added a copy assignment operator.
            - Added member and global swap() functions.
            - Added comparison operators == and !=.
        Class SurfaceFilterInfo<...>:
            - Removed completely.
        Class SurfaceFilterProperties:
            - Added a copy assignment operator.
            - Added member and global swap() functions.
            - Added comparison operators == and !=.
            - Routines that took a (const BoolSet&) now just take a
              BoolSet by value.
        Enum SurfaceFilterType:
            - Renamed the constant NS_FILTER_DEFAULT to
              NS_FILTER_LEGACY_DEFAULT, since the corresponding class
              SurfaceFilter is now an abstract base class.
        Class Tangle:
            - Added a copy assignment operator.
            - Added a move constructor and move assignment operator.
            - Renamed swapContents() to swap(); the old name is now a deprecated
              alias.  Also added a global regina::swap(Tangle&, Tangle&).
            - Added comparison operators == and !=.
            - Routines numClosure and denClosure() now return by value,
              not pointer.
            - Added brief() output routines.
            - Routine fromOrientedGauss() now returns by value (not pointer),
              and throws an exception on error (instead of returning null).
            - New routine crossings().
        Class Text:
            - Added a copy constructor and a copy assignment operator.
            - Added member and global swap() functions.
            - Added comparison operators == and !=.
            - The std::string constructor and assignment operator now
              take a string by value, allowing for more efficient moves.
        Class TorusBundle:
            - Added member and global swap() functions.
            - Added comparison operators == and !=.
        Class TreeDecomposition:
            - Added a move constructor and move/copy assignment operators.
            - Added member and global swap() functions.
            - Added comparison operators == and !=.
            - Changed the "raw graph" constructor from taking a raw C-style
              array to take either a Matrix<bool> or a std::vector of rows.
              The old constructor is removed completely.
            - The fromPACE() routines now return by value (not pointer),
              and throw an exception on error instead of (returning null)
        Class TreeTraversal, TreeEnumeration, TreeSingleSoln, TautEnumeration:
            - Removed the verify() routines, since this is basically just a
              single matrix multiplication.
            - Changed buildStructure() and buildSurface() to return by value,
              not by newly allocated pointer.  Now throws an exception (instead
              of returning null) if the coordinate preconditions are not met.
            - Constructors now take a NormalEncoding, not a NormalCoords, and
              will now happily accept any valid encoding.
            - The constraintsBroken() routines are gone; instead the class
              constructor throws an exception on error.
            - TreeEnumeration::run() and TautEnumeration::run() now use a
              type-safe template-based mechanism for callbacks instead of
              function pointers with void* arguments.  Moreover, the
              true/false behaviour of the callback has been inverted for
              consistency with other callback functions throughout Regina.
            - All writeTypes(), writeSurface() and writeStructure() functions
              (which are intended as drop-in callbacks) no longer have a
              void pointer argument, and now return false instead of true
              according to the new callback requirements described above.
            - New routine typeString() to complement dumpTypes().
            - Now derives from ShortOutput.
            - Renamed nVisited() and nSolns() to visited() and solutions().
              The old names have been removed completely.
        Class Triangulation<dim>:
            - Now supports move construction and copy/move assignment.
            - Routine fromIsoSig() now returns by value (not pointer), and
              throws an exception on error (instead of returning null).
            - All "magic" string contructors likewise now throw exceptions
              on error (instead of constructing empty triangulations).
            - New alias fromSig(), which is is identical to fromIsoSig().
            - Added comparison operators == and != to replace isIdenticalTo(),
              which is now a deprecated alias.
            - Routine simplices(), faces(), components(), boundaryComponents(),
              and the aliases vertices(), edges(), etc. no longer return a
              const reference to a std::vector or FaceList.  Instead they
              return a lightweight ListView object by value: its full type is
              undefined (so you should use auto), and it supports at least the
              same operations and functions as the old FaceList (except
              there is no Iterator typedef - use iterator or auto instead).
              C++ users who only ever used simplices(), faces(), etc. as a
              temporary (as was recommended) should be unaffected, and the
              Python behaviour of these functions is completely unchanged.
              The old names are kept as deprecated aliases.
            - New routines newSimplices<k>() and newSimplices(k), along
              with dimension-specific aliases newTriangles(), newTetrahedra()
              and newPentachora().  The templated versions of these functions
              can be used with structured binding.
            - New suite of homology(), markedHomology() and boundaryMap()
              routines, templated by dimension.  The old homologyH1() and
              (where relevant) homologyH2() routines are now deprecated aliases
              for homology<1>() and homology<2>().  The new homology() routines
              return by value, and throw exceptions if preconditions are not
              met.
            - Routine splitIntoComponents() is replaced with a new routine
              triangulateComponents() with different behaviour: it does not
              insert the results into the packet tree or assign packet labels.
              The old splitIntoComponents() has been removed completely,
              since it relied on triangulations living in the packet tree.
            - Routines findAllIsomorphisms() and findAllSubcomplexesIn()
              no longer take an output iterator; instead they take a callback
              action and an argument list.  Python supports both this new
              callback form as well as the old form that returned a Python
              list of isomorphisms.
            - Renamed swapContents() to swap(); the old name is now a
              deprecated alias.  Also added a global
              regina::swap(Triangulation<dim>&, Triangulation<dim>&).
            - Routine isoSig() now supports different signature types and
              encodings (but not different decodings), via new template
              parameters.  It also no longer takes an optional relabelling
              pointer; instead there is a new function isoSigDetail() for
              returning this.
            - Functions isIsomorphicTo() and isContainedIn() now return a
              std::optional<Isomorphism>, not a std::unique_ptr<Isomorphism>.
              The C++ syntax should be largely unaffected, and the Python
              behaviour (returns None if there is no isomorphism) is the same.
            - Simplified the class hierarchy; BoundaryComponentCalculator,
              EulerCalculator, FaceCalculator, FaceList and PachnerHelper are
              now gone, and there are a lot fewer regina::alias classes.
            - FaceListSuite is gone, now merged into TriangulationBase.
            - The inner TopologyLock class now takes its argument by reference.
            - Routine countFaces() now supports the case subdim == dim.
            - Add variants of countFaces(), faces() and face() that take
              the face dimension at runtime (this was already available
              in Python, but is now also available in C++).
            - Removed all of the old iterator typedefs (SimplexIterator,
              VertexIterator, EdgeIterator, etc.).  Just use auto or
              (if necessary) decltype(...) instead.
        Class Triangulation<3>:
            - All of the changes listed for Triangulation<dim> above.
            - New constructor that takes a link and builds its complement.
            - New routine generalAngleStructure().
            - Routine connectedSumDecomposition() is replaced with a new routine
              summands() with different behaviour: it does not insert the
              results into the packet tree or assign packet labels, and it
              throws on error.  The old connectedSumDecomposition() has been
              removed completely, since it relied on triangulations living
              in the packet tree.
            - Routine makeZeroEfficient() has been removed completely, since
              it relied on triangulations living in the packet tree.  Instead
              call summands(), which now formally guarantees 0-efficiency.
            - Overhauled retriangulate() to be faster, more generic, and
              support actions that take an isomorphism signature as well as
              a full triangluation.  This function is now also available
              through Python, and can take a pure Python function as its
              action argument.  It no longer runs in the background (even if a
              progress tracker is passed), and it now throws an exception
              if the triangulation has multiple components.
            - Routine simplifyExhaustive() no longer runs in the background
              (even if a progress tracker is passed), and it now throws an
              exception if the triangulation has multiple components.
            - Renamed hasNonTrivialSphereOrDisc() and
              hasOctagonalAlmostNormalSphere() to nonTrivialSphereOrDisc() and
              octagonalAlmostNormalSphere().  These routines now also return a
              std::optional<NormalSurface>, not a newly allocated pointer
              that may be null.
            - Renamed findStrictAngleStructure() to strictAngleStructure();
              moreover, this now returns by const reference if a solution
              exists and throws an exception otherwise.
            - Renamed isThreeSphere() and knowsThreeSphere() to isSphere() and
              knowsSphere().  The old names are kept as deprecated aliases.
            - For consistency with the new generic homology() routines,
              homologyRel(), homologyBdry() and homologyH2Z2() now throw
              exceptions if the validity precondition is not met.
            - New routines inAnyPacket() and isSnapPea().
            - Functions snapPea() and saveSnapPea() are no longer virtual.
            - New static routine fromGluings().  This replaces the old
              insertConstruction(), which is now deprecated.
            - Function enterTextTriangulation() returns by value, not pointer.
            - Routine fromSnapPea() now returns by value (not pointer), and
              throws an exception on error (instead of returning null).
            - Routine rehydrate() now returns by value, not pointer; also,
              both rehydrate() and insertRehydration() now throw exceptions on
              error instead of indicating this through return values.
            - Routines dehydrate(), snapPea(), recogniser() and recognizer()
              now throw an exception if the triangulation is not supported,
              instead of returning empty output.
            - Routine turaevViro() now always runs in the current thread,
              even if a progress tracker was passed.
            - Both turaevViro() and turaevViroApprox() now use ALG_TREEWIDTH
              as their default algorithm.  You can access the old algorithm
              by passing ALG_BACKTRACK.
            - Routine connectedSumWith() now adds fewer tetrahedra (thanks
              to Adele Jackson).
            - New suite of zeroTwoMove() routines, thanks to Alex He.
            - Calling pinchEdge() on an oriented triangulation now preserves
              the orientation.
            - Changed maximalForestInSkeleton() to return by value
              instead of returning through a reference argument.
            - Changed maximalForestInBoundary() to return the edge set by
              value, and to not return the vertex set at all (since this
              is just all boundary vertices).
            - Routines insertLayeredLoop(), insertLayeredLensSpace(),
              insertAugTriSolidTorus() and insertSFSOverSphere() are all
              deprecated.  Use the routines from Example<3> instead.
            - Routine insertRehydration() is deprecated.  Use rehydrate()
              instead.
            - Routine enterTextTriangulation() is now deprecated; this
              is a relic from Regina's ancient past.
        Class Triangulation<4>:
            - All of the changes listed for Triangulation<dim> above.
            - Overhauled retriangulate() to be faster, more generic, and
              support actions that take an isomorphism signature as well as
              a full triangluation.  This function is now also available
              through Python, and can take a pure Python function as its
              action argument.  It no longer runs in the background (even if a
              progress tracker is passed), and it now throws an exception
              if the triangulation has multiple components.
            - Routine simplifyExhaustive() no longer runs in the background
              (even if a progress tracker is passed), and it now throws an
              exception if the triangulation has multiple components.
            - New routines fourFourMove() and snapEdge(), thanks to Alex He.
        Class TrieSet:
            - This is no longer a template class (though its member
              functions are still templated on the bitmask type).
            - Added move/copy constructors and move/copy assignment operators.
            - Added member and global swap() functions.
            - Added short and detailed output functions.
            - Added comparison operators == and !=.
        Class TriSolidTorus:
            - Routine formsTriSolidTorus() is now called recognise(), and
              returns a std::unique_ptr instead of a raw pointer.
              The old name is kept as a deprecated alias.
            - Added copy construction and copy assignment.
            - Added member and global swap() functions.
            - Added comparison operators == and !=.
            - Deprecated clone().  Just use the copy constructor instead.
            - Changed isAnnulusSelfIdentified() to return a std::optional,
              instead of returning the permutation via a pointer argument.
        Class Tritmask1, Tritmask2, TritmaskLen{8,16,32,64}:
            - Removed completely.  These classes were not being used anywhere
              within Regina, and did not support tritmasks of arbitrary length.
        Class TrivialTri:
            - Added a new triangulation L31_PILLOW, to replace the old
              L31Pillow class.
            - Class constants are now constexpr.
            - Routine isTrivialTriangulation() is now called recognise(), and
              returns a std::unique_ptr instead of a raw pointer.
              The old name is kept as a deprecated alias.
            - Added copy construction and copy assignment.
            - Added member and global swap() functions.
            - Added comparison operators == and !=.
            - Deprecated clone().  Just use the copy constructor instead.
        Class TxICore:
            - Renamed TeXName() to texName().  The old name is kept but
              deprecated.
            - Added comparison operators == and !=.
        Class TxIDiagonalCore, TxIParallelCore:
            - Added move/copy constructors and move/copy assignment operators.
            - Added member and global swap() functions.
        Class TypeTrie:
            - Added move/copy constructors and move/copy assignment operators.
            - Added member and global swap() functions.
            - Added short and detailed output functions.
            - Added comparison operators == and !=.
        Class UnsolvedCase:
            - New exception class.
        Class ValidityConstraints:
            - This is a new, completely re-engineered class that replaces the
              old EnumConstraints.  It is easier to use within enumeration
              algorithms, and it carries significantly less overhead.
        Class Vector:
            - New operator !=.  Also, both == and != can now compare vectors
              of different sizes (which are always considered non-equal).
            - New constructors that take iterator ranges and initialiser lists.
            - New move constructor and move assignment operator.
            - The copy assignment operator can now work with vectors of
              different sizes.
            - New binary +, - and scalar * operators.
            - New routine isZero().
            - New routine scaleDown() for vectors over Regina's integer classes.
            - New typedef Element.
            - New static routine unit().
            - Provides the standard str() and detail() output functions.
            - Added a non-const operator[]; the old setElement() is now
              deprecated.
            - Operators +=, -=, *= now return a reference, as they should.
            - The class Vector<Integer> is now available in python, via
              the typedef VectorInt (in a similar way to MatrixInt).
            - Deprecated class constants zero, one and minusOne; just use
              0, 1 and -1 instead.
            - Added member and global swap() functions.
            - Added begin() and end() functions to support iteration.
            - Now explicitly supports zero-length vectors.
            - Added the standard container type aliases value_type, reference,
              const_reference, iterator and const_iterator.  Element is now
              deprecated; use value_type instead.
        Class VectorInt, VectorLarge:
            - New typedefs for Vector<Integer> and Vector<LargeInteger>, for
              compatibility with MatrixInt.
        Class Vertex<3>:
            - Renamed link() to linkType().  There is no deprecated alias,
              because this rename is designed to clear the way for a
              different routine to be called link() in the future.
              Anyone who used link() before will need to update their code now.
        Class XMLCallback:
            - The state constants have now been rolled into a State enum type.
        Function allowsNonOrientableLinks(), allowsInvalidFaces():
            - Removed these global functions (which were never available in
              python). Use Face<dim, subdim>::allowsNonOrientableLinks
              and Face<dim, subdim>::allowsInvalidFaces instead.
        Function basicTokenise():
            - Rewritten to return the list of tokens as a std::vector.
              The old version has been kept also but is now deprecated.
        Function binomSmall(), binomMedium():
            - Both these functions are now inline and constexpr.
        Function clonePtr():
            - Removed completely: C++ has evolved a lot since 2007 and
              these functions no longer make sense to keep around.
        Function duplicate():
            - Removed completely; just use strdup() instead.
        Function faceOppositeEdge<dim>():
            - These functions are now constexpr.
        Function forCoords():
            - Removed completely.  See the new NormalEncoding / HyperEncoding
              and the redesigned NormalInfo / HyperInfo classes for details.
        Function forFilter():
            - Removed completely.
        Function forPacket():
            - Removed completely.
        Function formSigCensus:
            - Replaced with SigCensus::formCensus(), which also uses a
              type-safe template-based mechanism for callbacks instead of a
              function pointer with a single void* argument.  The old function
              is removed completely.
        Function gcdWithCoeffs():
            - Changed this to return a tuple instead of using reference
              arguments.  The old version is kept but deprecated.
        Function makeAngleEquations():
            - Now takes a const reference (not a const pointer), and returns
              a MatrixInt by value (not by newly allocated pointer).
        Function makeEmbeddedConstraints():
            - Now takes a const reference (not a const pointer), and returns an
              EnumConstraints by value (not by newly allocated pointer).
        Function makeMatchingEquations():
            - Now takes a const reference (not a const pointer), returns
              by value instead of pointer, and throws an exception on
              error instead of returning null.
        Function make_packet():
            - A new suite of overload functions for converting mathematical
              objects of type Held into wrapped packets of type PacketOf<Held>.
        Function makeZeroVector():
            - Removed completely.
        Function preImageOfLattice():
            - Now returns a MatrixInt by value.
        Function readOrb():
            - Like the other import functions in foreign, this routine returns
              a packet; this means that the return type has changed from
              Triangulation<3> to PacketOf<Triangulation<3>>.
            - Now returns a shared_ptr instead of a raw pointer.
        Function readDehydrationList():
            - Now returns a shared_ptr instead of a raw pointer.
        Function readSigList(), readIsoSigList():
            - The old readIsoSigList() is now deprecated, in favour of a new
              template function readSigList() that can work with knots and
              also triangulations of any dimension.  The old readIsoSigList()
              has been kept as a deprecated alias.
            - Now returns a shared_ptr instead of a raw pointer.
        Function resUsage():
            - New function that fetches the same as writeResUsage(), but
              returns it directly instead of writing to an output stream.
        Function smithNormalForm(), metricalSmithNormalForm():
            - The change of basis matrices no longer need to have the correct
              size (and may even be uninitialised) before they are passed in.
            - The change of basis matrices are now passed by reference, which
              means for metricalSmithNormalForm() they are no longer optional.
        Function static_packet_cast(), static_triangulation3_cast():
            - A new suite of functions for converting between general Packet
              pointers and pointers to non-packet objects.
        Function stringToToken()
            - Replaced the two overloads with a single function that
              takes a std::string by value, for better move optimisation.
        Function tightEncode(), tightEncoding():
            - New global function to help with perfect hashes of different
              types of integers.
        Function torsionAutInverse():
            - Now returns a MatrixInt by value.
        Function valueOf():
            - The Integer / LargeInteger variants are deprecated.  Just use the
              (Large)Integer assignment operator inside a try/catch block.
        Global constants base64Table, base64Spare:
            - Added to support the base64 encoding/decoding routines.
        Global constant packetTypeHolds<T>:
            - Added to support compile-time conversion from types held by
              packet wrappers to the corresponding packet type constants.
        Global arrays quadSeparating, quadMeeting, quadDefn, quadPartner,
                quadString:
            - These are all now inline constexpr.
        Global arrays triDiscArcs, quadDiscArcs, octDiscArcs:
            - These are all now inline constexpr.
            - For C++ users, these are no longer macros; instead they are
              once again genuine 2-D arrays.  Unfortunately this change is not
              backward compatible: you must now use foo[i][j], not foo(i,j).
              Python users are unaffected.
        Macro ENABLE_MEMBER_FOR_REGINA_INTEGER:
            - New macro for conditionally enabling or disabling member
              functions in template classes.
        Macro REGINA_PACKET:
            - No longer takes an initial class argument.
        Header packet/packetregistry.h, packet/packetregistry-impl.h:
            - Removed completely.
        Header surfaces/*:
            - Moved to surface/*.  The old headers are kept but deprecated.
        Header surface/coordregistry.h, surface/coordregistry-impl.h:
            - Removed completely.
        Header surface/filterregistry.h, surface/filterregistry-impl.h:
            - Removed completely.
        Header triangulation/homologicaldata.h:
            - Moved to triangulation/dim3/homologicaldata.h.
        Header utilities/memutils.h:
            - Removed completely.
        Header utilities/property.h:
            - Removed completely.
        Header utilities/ptrutils.h:
            - Removed completely.
        Header utilities/registryutils.h:
            - Removed completely.
    PYTHON:
        - Almost all of Regina's C++ interface is now accessible to Python.
          Essentially what remains unwrapped is that which makes no sense to
          wrap: direct interaction with C++ input/output streams, and code
          that is heavily templated using custom types as template arguments.
        - Almost all classes now provide a useful __repr__(), and many classes
          now have a more informative __str__().
        - For most classes, == and != now compare by value.  The one case
          where this becomes problematic is for packets, where you might
          still need to test whether two Python wrappers refer to the same
          underlying C++ object; for this you can now use Packet.samePacket().
        - Updated the included pybind11 library from 2.6.1 to 2.8.1.
        - Wrapped Perm<n>::SnIndex() for n=2,3,4,5; this alias has been present
          in C++ for a long time but was somehow never wrapped in Python.
        - All regina functions that used to throw std::invalid_argument on
          error now throw regina::InvalidArgument instead.
        - Removed wrappings for all C++ functions that took an output stream,
          where this was assumed to be std::cout in Python
          (e.g., Link::writePACE(std::ostream&).  Python users should just use
          the string versions of these functions instead (e.g., Link::pace()).
    USER INTERFACES:
        - Incorporated many of the mathematical changes described above.
        - Removed the View/Edit action from the toolbar, since you might as
          well just double-click on the packet instead.
        - Gave some of the standard system icons (open, save, close, etc.)
          a long-awaited refresh.
    UTILITIES:
        dgt:
            - New utility for building triangulations from framed links.
              Thanks to Rhuaidi Burke.
        regconvert:
            - Added options -2 and -3 to support the old (second-generation)
              and new (third-generation) file formats.
        retriangulate:
            - Now works with knots as well as 3/4-manifold triangulations.
    TEST SUITE:
        - The command-line utilities now have their own dedicated tests (in
          addition to the engine and python tests which were already present).

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/