|
Regina 7.3 Calculation Engine
|
Overall structure of the calculation engine. More...
Classes | |
| struct | regina::Output< T, supportsUtf8 > |
| A common base class for objects that write human-readable text output. More... | |
| struct | regina::ShortOutput< T, supportsUtf8 > |
| A common base class for objects that provide short text output only. More... | |
| struct | regina::OutputBase< T > |
| Provides a type alias to help identify where in the class hierarchy the output functions T::str() and T::detail() are implemented. More... | |
Enumerations | |
| enum | regina::Algorithm { regina::ALG_DEFAULT = 0 , regina::ALG_BACKTRACK = 1 , regina::ALG_TREEWIDTH = 2 , regina::ALG_NAIVE = 3 } |
| Represents various classes of algorithms that Regina can use for computations. More... | |
Functions | |
| const char * | regina::versionString () |
| Returns the full version number of this calculation engine. More... | |
| int | regina::versionMajor () |
| Returns the major version number of this calculation engine. More... | |
| int | regina::versionMinor () |
| Returns the minor version number of this calculation engine. More... | |
| const char * | regina::buildInfo () |
| Returns any additional information about this specific build of Regina. More... | |
| bool | regina::versionUsesUTF8 (const char *version) |
| Did the given version of Regina consistently use UTF-8 in its data files? More... | |
| const char * | regina::versionSnapPy () |
| Returns the version of SnapPy whose underlying SnapPea kernel is built into Regina. More... | |
| const char * | regina::versionSnapPea () |
| An alias for versionSnapPy(), which returns the version of SnapPy whose underlying SnapPea kernel is built into Regina. More... | |
| bool | regina::hasInt128 () |
| Does this particular build of Regina support native 128-bit arithmetic? More... | |
| int | regina::politeThreads () |
| A suggestion for user interfaces as to how many threads should be used for parallel computations. More... | |
| int | regina::testEngine (int value) |
| Tests to see if an interface can successfully communicate with the underlying C++ calculation engine. More... | |
| template<class T , bool supportsUtf8> | |
| std::ostream & | regina::operator<< (std::ostream &out, const Output< T, supportsUtf8 > &object) |
| Writes the short text representation of the given object to the given output stream. More... | |
| constexpr bool | regina::standardDim (int dim) |
| Indicates whether the given dimension is one of Regina's standard dimensions. More... | |
| constexpr int | regina::maxDim () |
| Indicates that largest dimension of triangulation that Regina can work with. More... | |
Overall structure of the calculation engine.
| enum regina::Algorithm |
Represents various classes of algorithms that Regina can use for computations.
A function that takes an Algorithm argument need not support all types of algorithm - if an unsupported algorithm is passed then Regina will fall back to ALG_DEFAULT.
This enumeration type does not allow constants to be combined using the OR operator.
For some computations where the user can exert more fine-grained control over the underlying algorithm, a more specialised enumeration type is used instead. For example, see the NormalSurfaces class constructor, which uses the specialised algorithm types NormalAlg and NormalAlgFlags.
| const char * regina::buildInfo | ( | ) |
Returns any additional information about this specific build of Regina.
For instance, an official download from the Regina website might return "Official macOS build", and a package from the official Debian servers might return "Debian package build".
This information is supplied at build time by passing the option -DBUILD_INFO=... to CMake.
If no such information was supplied at build time, then this string will be empty.
| bool regina::hasInt128 | ( | ) |
Does this particular build of Regina support native 128-bit arithmetic?
On those platforms that do support native 128-bit arithmetic, some expensive algorithms (in particular for normal surface enumeration) are optimised to run significantly faster in some cases.
true if and only if this build supports native 128-bit arithmetic.
|
constexpr |
Indicates that largest dimension of triangulation that Regina can work with.
If Regina was built with the REGINA_HIGHDIM option, then this will be 15; otherwise it will be 8 (the default for ordinary builds).
| std::ostream & regina::operator<< | ( | std::ostream & | out, |
| const Output< T, supportsUtf8 > & | object | ||
| ) |
Writes the short text representation of the given object to the given output stream.
This is equivalent to calling out << object.str().
| out | the output stream to which to write. |
| object | the object to write. |
| int regina::politeThreads | ( | ) |
A suggestion for user interfaces as to how many threads should be used for parallel computations.
The current implementation returns approximately half the number of cores available on the machine.
|
constexpr |
Indicates whether the given dimension is one of Regina's standard dimensions.
Standard dimensions offer significantly richer functionality for triangulations than generic dimensions.
| dim | the dimension in question. |
true if and only if dim is one of Regina's standard dimensions. | int regina::testEngine | ( | int | value | ) |
Tests to see if an interface can successfully communicate with the underlying C++ calculation engine.
This routine simply uses the engine to return the same value that is passed to it; it can be used to test whether communications between the interface and the C++ engine are working properly.
| value | any integer; this same integer will be returned. |
| int regina::versionMajor | ( | ) |
Returns the major version number of this calculation engine.
For instance, version 2.3.1 would have major version 2.
| int regina::versionMinor | ( | ) |
Returns the minor version number of this calculation engine.
For instance, version 2.3.1 would have minor version 3.
| const char * regina::versionSnapPea | ( | ) |
An alias for versionSnapPy(), which returns the version of SnapPy whose underlying SnapPea kernel is built into Regina.
See versionSnapPy() for details.
| const char * regina::versionSnapPy | ( | ) |
Returns the version of SnapPy whose underlying SnapPea kernel is built into Regina.
The SnapPea kernel is now maintained by the larger SnapPy project, and Regina sources its version of the SnapPea kernel from one of the recent SnapPy releases. See http://snappy.computop.org/ for details.
In Regina, you can access the SnapPea kernel through the SnapPeaTriangulation class.
| const char * regina::versionString | ( | ) |
Returns the full version number of this calculation engine.
For instance, version 2.3.1 would have full version "2.3.1".
| bool regina::versionUsesUTF8 | ( | const char * | version | ) |
Did the given version of Regina consistently use UTF-8 in its data files?
In Regina versions 4.4 and below, no particular attention was paid to character encodings. As a result, the GUI typically stored data in LATIN1 (the default at the time for the Qt libraries).
As of Regina 4.5, all strings are now stored in UTF-8 where possible.
This routine allows programs to determine which regime a particular version of Regina belongs to. This can be useful when working with Regina data files on a low-level basis.
Any whitespace in the version string will confuse the result, and the return value will be undefined.
As a special case, an empty string is treated as belonging to the UTF-8 regime.
| version | a version string from some release of Regina, such as "4.2". This must not contain any whitespace padding. |
true if the given version uses UTF-8 consistently, or false if the given version is an older version that did not pay attention to character encodings.