|
Regina 7.4 Calculation Engine
|
Underlying mathematical gruntwork. More...
Classes | |
| struct | regina::Vector3D< Real > |
| Represents a vector in real three-dimensional space. More... | |
| struct | regina::Segment3D< Real > |
| Represents a line segment in 3-dimensional space, defined by its two endpoints u and v. More... | |
| class | regina::Matrix3D< Real > |
| Represents a linear transformation in three-dimensional space, as represented by a real 3-by-3 matrix. More... | |
| class | regina::Rotation3D< Real > |
| Represents a rotation about the origin in real three-dimensional space. More... | |
| class | regina::Arrow |
| Represents a multivariate polynomial of the type used by arrow polynomials of links. More... | |
| class | regina::Cyclotomic |
| Represents an element of a cyclotomic field. More... | |
| struct | regina::InfinityBase< withInfinity > |
| Internal base classes for use with IntegerBase, templated on whether we should support infinity as an allowed value. More... | |
| class | regina::IntegerBase< bool > |
| Represents an arbitrary precision integer. More... | |
| class | regina::NativeInteger< int > |
| A wrapper class for a native, fixed-precision integer type of the given size. More... | |
| class | regina::Laurent< T > |
| Represents a single-variable Laurent polynomial with coefficients of type T. More... | |
| class | regina::Laurent2< T > |
| Represents a Laurent polynomial in the two variables x, y with coefficients of type T. More... | |
| class | regina::Matrix< typename > |
| Represents a matrix of elements of the given type T. More... | |
| class | regina::Matrix2 |
| Represents a 2-by-2 integer matrix. More... | |
| class | regina::Perm< n > |
| Represents a permutation of {0,1,...,n-1}. More... | |
| class | regina::PermClass< n > |
| Represents a conjugacy class of permutations on n elements. More... | |
| class | regina::PermGroup< n, cached > |
| Represents a group of permutations on n elements. More... | |
| struct | regina::PermSn< n, order, codeType > |
| A lightweight array-like object that supports fast lookup and iteration for permutations on n objects. More... | |
| struct | regina::detail::PermSubSn< n, m, order > |
A lightweight array-like object that indexes smaller permutations within larger permutation groups; that is, it embeds the group S_m inside S_n for some n > m. More... | |
| class | regina::Polynomial< T > |
| Represents a single-variable polynomial with coefficients of type T. More... | |
| class | regina::Primes |
| A helper class for finding primes and factorising integers. More... | |
| class | regina::Rational |
| Represents an arbitrary precision rational number. More... | |
| struct | regina::RingTraits< T > |
| A helper class that instructs Regina how to do mathematical operations with objects from any ring type T. More... | |
| class | regina::Perm< 2 > |
| Represents a permutation of {0,1}. More... | |
| class | regina::Perm< 3 > |
| Represents a permutation of {0,1,2}. More... | |
| class | regina::Perm< 4 > |
| Represents a permutation of {0,1,2,3}. More... | |
| class | regina::Perm< 5 > |
| Represents a permutation of {0,1,2,3,4}. More... | |
| class | regina::Perm< 6 > |
| Represents a permutation of {0,1,2,3,4,5}. More... | |
| class | regina::Perm< 7 > |
| Represents a permutation of {0,1,2,3,4,5,6}. More... | |
| class | regina::Vector< T > |
| An optimised vector class of elements from a given ring T. More... | |
Macros | |
| #define | mpz_cmp_si_cpp(z, si) |
| An internal copy of the GMP signed comparison optimisations. | |
Typedefs | |
| using | regina::LargeInteger = IntegerBase<true> |
| LargeInteger is a type alias for IntegerBase<true>, which offers arbitrary precision integers with support for infinity. | |
| using | regina::Integer = IntegerBase<false> |
| Integer is a type alias for IntegerBase<false>, which offers arbitrary precision integers without support for infinity. | |
| using | regina::NativeLong = NativeInteger<sizeof(long)> |
| NativeLong is a type alias for the NativeInteger template class whose underlying integer type is a native long. | |
| using | regina::MatrixInt = Matrix<Integer> |
| A matrix of arbitrary-precision integers. | |
| using | regina::MatrixBool = Matrix<bool> |
| A matrix of booleans. | |
| using | regina::VectorInt = Vector<Integer> |
| A vector of arbitrary-precision integers. | |
| using | regina::VectorLarge = Vector<LargeInteger> |
| A vector of arbitrary-precision integers that allows infinite elements. | |
Enumerations | |
| enum class | regina::PermCodeType { regina::PermCodeType::Images = 1 , regina::PermCodeType::Index = 2 } |
| Represents the different kinds of internal permutation codes that are used in Regina's various Perm<n> template classes. More... | |
Functions | |
| template<typename Real > | |
| std::ostream & | regina::operator<< (std::ostream &out, const Vector3D< Real > &v) |
| Writes the given vector to the given output stream. | |
| template<typename Real > | |
| std::ostream & | regina::operator<< (std::ostream &out, const Segment3D< Real > &s) |
| Writes the given line segment to the given output stream. | |
| template<typename Real > | |
| std::ostream & | regina::operator<< (std::ostream &out, const Matrix3D< Real > &m) |
| Writes the given matrix to the given output stream. | |
| template<typename Real > | |
| std::ostream & | regina::operator<< (std::ostream &out, const Rotation3D< Real > &rot) |
| Writes the given rotation to the given output stream. | |
| void | regina::swap (Arrow &a, Arrow &b) noexcept |
| Swaps the contents of the given polynomials. | |
| Arrow | regina::operator* (Arrow poly, const Integer &scalar) |
| Multiplies the given polynomial by the given integer constant. | |
| Arrow | regina::operator* (const Integer &scalar, Arrow poly) |
| Multiplies the given polynomial by the given integer constant. | |
| Arrow | regina::operator* (Arrow arrow, const Laurent< Integer > &laurent) |
Multiplies the given arrow polynomial by the given Laurent polynomial in A. | |
| Arrow | regina::operator* (const Laurent< Integer > &laurent, Arrow arrow) |
Multiplies the given arrow polynomial by the given Laurent polynomial in A. | |
| Arrow | regina::operator+ (const Arrow &lhs, const Arrow &rhs) |
| Adds the two given polynomials. | |
| Arrow | regina::operator+ (Arrow &&lhs, const Arrow &rhs) |
| Adds the two given polynomials. | |
| Arrow | regina::operator+ (const Arrow &lhs, Arrow &&rhs) |
| Adds the two given polynomials. | |
| Arrow | regina::operator+ (Arrow &&lhs, Arrow &&rhs) |
| Adds the two given polynomials. | |
| Arrow | regina::operator- (Arrow arg) |
| Returns the negative of the given polynomial. | |
| Arrow | regina::operator- (const Arrow &lhs, const Arrow &rhs) |
| Subtracts the two given polynomials. | |
| Arrow | regina::operator- (Arrow &&lhs, const Arrow &rhs) |
| Subtracts the two given polynomials. | |
| Arrow | regina::operator- (const Arrow &lhs, Arrow &&rhs) |
| Subtracts the two given polynomials. | |
| Arrow | regina::operator- (Arrow &&lhs, Arrow &&rhs) |
| Subtracts the two given polynomials. | |
| Arrow | regina::operator* (const Arrow &lhs, const Arrow &rhs) |
| Multiplies the two given polynomials. | |
| consteval int | regina::binomSmall (int n, int k) |
| Returns the binomial coefficient n choose k in constant time for small arguments (n ≤ 16). | |
| constexpr int_fast64_t | regina::binomMedium (int n, int k) |
| Returns the binomial coefficient n choose k in linear time for medium-sized arguments (n ≤ 61). | |
| void | regina::swap (Cyclotomic &a, Cyclotomic &b) noexcept |
| Swaps the contents of the given field elements. | |
| Cyclotomic | regina::operator* (Cyclotomic elt, const Rational &scalar) |
| Multiplies the given field element by the given rational. | |
| Cyclotomic | regina::operator* (const Rational &scalar, Cyclotomic elt) |
| Multiplies the given field element by the given rational. | |
| Cyclotomic | regina::operator/ (Cyclotomic elt, const Rational &scalar) |
| Divides the given field element by the given rational. | |
| Cyclotomic | regina::operator+ (const Cyclotomic &lhs, const Cyclotomic &rhs) |
| Adds the two given cyclotomic field elements. | |
| Cyclotomic | regina::operator+ (Cyclotomic &&lhs, const Cyclotomic &rhs) |
| Adds the two given cyclotomic field elements. | |
| Cyclotomic | regina::operator+ (const Cyclotomic &lhs, Cyclotomic &&rhs) |
| Adds the two given cyclotomic field elements. | |
| Cyclotomic | regina::operator+ (Cyclotomic &&lhs, Cyclotomic &&rhs) |
| Adds the two given cyclotomic field elements. | |
| Cyclotomic | regina::operator- (Cyclotomic arg) |
| Returns the negative of the given field element. | |
| Cyclotomic | regina::operator- (const Cyclotomic &lhs, const Cyclotomic &rhs) |
| Subtracts the two given cyclotomic field elements. | |
| Cyclotomic | regina::operator- (Cyclotomic &&lhs, const Cyclotomic &rhs) |
| Subtracts the two given cyclotomic field elements. | |
| Cyclotomic | regina::operator- (const Cyclotomic &lhs, Cyclotomic &&rhs) |
| Subtracts the two given cyclotomic field elements. | |
| Cyclotomic | regina::operator- (Cyclotomic &&lhs, Cyclotomic &&rhs) |
| Subtracts the two given cyclotomic field elements. | |
| Cyclotomic | regina::operator* (const Cyclotomic &lhs, const Cyclotomic &rhs) |
| Multiplies the two given cyclotomic field elements. | |
| Cyclotomic | regina::operator/ (const Cyclotomic &lhs, const Cyclotomic &rhs) |
| Divides the two given cyclotomic field elements. | |
| template<bool withInfinity> | |
| void | regina::swap (IntegerBase< withInfinity > &a, IntegerBase< withInfinity > &b) noexcept |
| Swaps the contents of the given integers. | |
| template<bool withInfinity> | |
| std::ostream & | regina::operator<< (std::ostream &out, const IntegerBase< withInfinity > &i) |
| Writes the given integer to the given output stream. | |
| template<bool withInfinity> | |
| IntegerBase< withInfinity > | regina::operator+ (long lhs, const IntegerBase< withInfinity > &rhs) |
| Adds the given native integer to the given large integer. | |
| template<bool withInfinity> | |
| IntegerBase< withInfinity > | regina::operator* (long lhs, const IntegerBase< withInfinity > &rhs) |
| Multiplies the given native integer with the given large integer. | |
| template<bool withInfinity> | |
| void | regina::tightEncode (std::ostream &out, IntegerBase< withInfinity > value) |
| Writes the tight encoding of the given arbitrary precision integer to the given output stream. | |
| template<bool withInfinity> | |
| std::string | regina::tightEncoding (IntegerBase< withInfinity > value) |
| Returns the tight encoding of the given arbitrary precision integer. | |
| template<int bytes> | |
| void | regina::swap (NativeInteger< bytes > &a, NativeInteger< bytes > &b) noexcept |
| Swaps the contents of the given integers. | |
| template<int bytes> | |
| std::ostream & | regina::operator<< (std::ostream &out, const NativeInteger< bytes > &i) |
| Writes the given integer to the given output stream. | |
| template<typename T > | |
| void | regina::swap (Laurent< T > &a, Laurent< T > &b) noexcept |
| Swaps the contents of the given polynomials. | |
| template<typename T > | |
| Laurent< T > | regina::operator* (Laurent< T > poly, const typename Laurent< T >::Coefficient &scalar) |
| Multiplies the given polynomial by the given scalar constant. | |
| template<typename T > | |
| Laurent< T > | regina::operator* (const typename Laurent< T >::Coefficient &scalar, Laurent< T > poly) |
| Multiplies the given polynomial by the given scalar constant. | |
| template<typename T > | |
| Laurent< T > | regina::operator/ (Laurent< T > poly, const typename Laurent< T >::Coefficient &scalar) |
| Divides the given polynomial by the given scalar constant. | |
| template<typename T > | |
| Laurent< T > | regina::operator+ (const Laurent< T > &lhs, const Laurent< T > &rhs) |
| Adds the two given polynomials. | |
| template<typename T > | |
| Laurent< T > | regina::operator+ (Laurent< T > &&lhs, const Laurent< T > &rhs) |
| Adds the two given polynomials. | |
| template<typename T > | |
| Laurent< T > | regina::operator+ (const Laurent< T > &lhs, Laurent< T > &&rhs) |
| Adds the two given polynomials. | |
| template<typename T > | |
| Laurent< T > | regina::operator+ (Laurent< T > &&lhs, Laurent< T > &&rhs) |
| Adds the two given polynomials. | |
| template<typename T > | |
| Laurent< T > | regina::operator- (Laurent< T > arg) |
| Returns the negative of the given polynomial. | |
| template<typename T > | |
| Laurent< T > | regina::operator- (const Laurent< T > &lhs, const Laurent< T > &rhs) |
| Subtracts the two given polynomials. | |
| template<typename T > | |
| Laurent< T > | regina::operator- (Laurent< T > &&lhs, const Laurent< T > &rhs) |
| Subtracts the two given polynomials. | |
| template<typename T > | |
| Laurent< T > | regina::operator- (const Laurent< T > &lhs, Laurent< T > &&rhs) |
| Subtracts the two given polynomials. | |
| template<typename T > | |
| Laurent< T > | regina::operator- (Laurent< T > &&lhs, Laurent< T > &&rhs) |
| Subtracts the two given polynomials. | |
| template<typename T > | |
| Laurent< T > | regina::operator* (const Laurent< T > &lhs, const Laurent< T > &rhs) |
| Multiplies the two given polynomials. | |
| template<typename T > | |
| void | regina::swap (Laurent2< T > &a, Laurent2< T > &b) noexcept |
| Swaps the contents of the given polynomials. | |
| template<typename T > | |
| Laurent2< T > | regina::operator* (Laurent2< T > poly, const typename Laurent2< T >::Coefficient &scalar) |
| Multiplies the given polynomial by the given scalar constant. | |
| template<typename T > | |
| Laurent2< T > | regina::operator* (const typename Laurent2< T >::Coefficient &scalar, Laurent2< T > poly) |
| Multiplies the given polynomial by the given scalar constant. | |
| template<typename T > | |
| Laurent2< T > | regina::operator/ (Laurent2< T > poly, const typename Laurent2< T >::Coefficient &scalar) |
| Divides the given polynomial by the given scalar constant. | |
| template<typename T > | |
| Laurent2< T > | regina::operator+ (const Laurent2< T > &lhs, const Laurent2< T > &rhs) |
| Adds the two given polynomials. | |
| template<typename T > | |
| Laurent2< T > | regina::operator+ (Laurent2< T > &&lhs, const Laurent2< T > &rhs) |
| Adds the two given polynomials. | |
| template<typename T > | |
| Laurent2< T > | regina::operator+ (const Laurent2< T > &lhs, Laurent2< T > &&rhs) |
| Adds the two given polynomials. | |
| template<typename T > | |
| Laurent2< T > | regina::operator+ (Laurent2< T > &&lhs, Laurent2< T > &&rhs) |
| Adds the two given polynomials. | |
| template<typename T > | |
| Laurent2< T > | regina::operator- (Laurent2< T > arg) |
| Returns the negative of the given polynomial. | |
| template<typename T > | |
| Laurent2< T > | regina::operator- (const Laurent2< T > &lhs, const Laurent2< T > &rhs) |
| Subtracts the two given polynomials. | |
| template<typename T > | |
| Laurent2< T > | regina::operator- (Laurent2< T > &&lhs, const Laurent2< T > &rhs) |
| Subtracts the two given polynomials. | |
| template<typename T > | |
| Laurent2< T > | regina::operator- (const Laurent2< T > &lhs, Laurent2< T > &&rhs) |
| Subtracts the two given polynomials. | |
| template<typename T > | |
| Laurent2< T > | regina::operator- (Laurent2< T > &&lhs, Laurent2< T > &&rhs) |
| Subtracts the two given polynomials. | |
| template<typename T > | |
| Laurent2< T > | regina::operator* (const Laurent2< T > &lhs, const Laurent2< T > &rhs) |
| Multiplies the two given polynomials. | |
| template<typename T > | |
| void | regina::swap (Matrix< T > &a, Matrix< T > &b) noexcept |
| Swaps the contents of the given matrices. | |
| void | regina::swap (Matrix2 &a, Matrix2 &b) noexcept |
| Swaps the contents of the two given matrices. | |
| std::ostream & | regina::operator<< (std::ostream &out, const Matrix2 &mat) |
| Writes the given matrix to the given output stream. | |
| std::strong_ordering | regina::simplerThreeWay (const Matrix2 &m1, const Matrix2 &m2) |
| Compare two matrices to determine which is more aesthetically pleasing. | |
| bool | regina::simpler (const Matrix2 &m1, const Matrix2 &m2) |
| Deprecated routine that determines whether the first given matrix is more aesthetically pleasing than the second. | |
| std::strong_ordering | regina::simplerThreeWay (const Matrix2 &pair1first, const Matrix2 &pair1second, const Matrix2 &pair2first, const Matrix2 &pair2second) |
| Compares two ordered pairs of matrices to determine which pair is more aesthetically pleasing. | |
| bool | regina::simpler (const Matrix2 &pair1first, const Matrix2 &pair1second, const Matrix2 &pair2first, const Matrix2 &pair2second) |
| Deprecated routine that determines whether the first given pair of matrices is more aesthetically pleasing than the second pair. | |
| void | regina::smithNormalForm (MatrixInt &matrix) |
| Transforms the given integer matrix into Smith normal form. | |
| void | regina::smithNormalForm (MatrixInt &matrix, MatrixInt &rowSpaceBasis, MatrixInt &rowSpaceBasisInv, MatrixInt &colSpaceBasis, MatrixInt &colSpaceBasisInv) |
| A Smith normal form algorithm that also returns change of basis matrices. | |
| void | regina::metricalSmithNormalForm (MatrixInt &matrix, MatrixInt &rowSpaceBasis, MatrixInt &rowSpaceBasisInv, MatrixInt &colSpaceBasis, MatrixInt &colSpaceBasisInv) |
| An alternative Smith normal form algorithm that also returns change of basis matrices. | |
| size_t | regina::rowBasis (MatrixInt &matrix) |
| Find a basis for the row space of the given matrix. | |
| size_t | regina::rowBasisAndOrthComp (MatrixInt &input, MatrixInt &complement) |
| Finds a basis for the row space of the given matrix, as well as an "incremental" basis for its orthogonal complement. | |
| void | regina::columnEchelonForm (MatrixInt &M, MatrixInt &R, MatrixInt &Ri, const std::vector< size_t > &rowList) |
| Transforms a given matrix into column echelon form with respect to a collection of rows. | |
| MatrixInt | regina::preImageOfLattice (const MatrixInt &hom, const std::vector< Integer > &sublattice) |
| Given a homomorphism from Z^n to Z^k and a sublattice of Z^k, compute the preimage of this sublattice under this homomorphism. | |
| MatrixInt | regina::torsionAutInverse (const MatrixInt &input, const std::vector< Integer > &invF) |
| Given an automorphism of an abelian group, this procedure computes the inverse automorphism. | |
| long | regina::reducedMod (long k, long modBase) |
| Reduces k modulo modBase to give the smallest possible absolute value. | |
| long | regina::gcd (long a, long b) |
| Deprecated routine that calculates the greatest common divisor of two signed integers. | |
| std::tuple< long, long, long > | regina::gcdWithCoeffs (long a, long b) |
| Calculates the greatest common divisor of two given integers and finds the smallest coefficients with which these integers combine to give their gcd. | |
| long | regina::lcm (long a, long b) |
| Deprecated routine that calculates the lowest common multiple of two signed integers. | |
| long | regina::modularInverse (long n, long k) |
| Calculates the multiplicative inverse of one integer modulo another. | |
| constexpr char | regina::digit (int i) |
| Returns the character used to express the integer i in a permutation. | |
| constexpr int64_t | regina::factorial (int n) |
| Returns the factorial of n. | |
| template<int n> | |
| std::ostream & | regina::operator<< (std::ostream &out, const Perm< n > &p) |
| Writes a string representation of the given permutation to the given output stream. | |
| template<int n> | |
| std::ostream & | regina::operator<< (std::ostream &out, const PermClass< n > &c) |
| Writes a string representation of the given conjugacy class of permutations to the given output stream. | |
| template<typename T > | |
| void | regina::swap (Polynomial< T > &a, Polynomial< T > &b) noexcept |
| Swaps the contents of the given polynomials. | |
| template<typename T > | |
| Polynomial< T > | regina::operator* (Polynomial< T > poly, const typename Polynomial< T >::Coefficient &scalar) |
| Multiplies the given polynomial by the given scalar constant. | |
| template<typename T > | |
| Polynomial< T > | regina::operator* (const typename Polynomial< T >::Coefficient &scalar, Polynomial< T > poly) |
| Multiplies the given polynomial by the given scalar constant. | |
| template<typename T > | |
| Polynomial< T > | regina::operator/ (Polynomial< T > poly, const typename Polynomial< T >::Coefficient &scalar) |
| Divides the given polynomial by the given scalar constant. | |
| template<typename T > | |
| Polynomial< T > | regina::operator+ (const Polynomial< T > &lhs, const Polynomial< T > &rhs) |
| Adds the two given polynomials. | |
| template<typename T > | |
| Polynomial< T > | regina::operator+ (Polynomial< T > &&lhs, const Polynomial< T > &rhs) |
| Adds the two given polynomials. | |
| template<typename T > | |
| Polynomial< T > | regina::operator+ (const Polynomial< T > &lhs, Polynomial< T > &&rhs) |
| Adds the two given polynomials. | |
| template<typename T > | |
| Polynomial< T > | regina::operator+ (Polynomial< T > &&lhs, Polynomial< T > &&rhs) |
| Adds the two given polynomials. | |
| template<typename T > | |
| Polynomial< T > | regina::operator- (Polynomial< T > arg) |
| Returns the negative of the given polynomial. | |
| template<typename T > | |
| Polynomial< T > | regina::operator- (const Polynomial< T > &lhs, const Polynomial< T > &rhs) |
| Subtracts the two given polynomials. | |
| template<typename T > | |
| Polynomial< T > | regina::operator- (Polynomial< T > &&lhs, const Polynomial< T > &rhs) |
| Subtracts the two given polynomials. | |
| template<typename T > | |
| Polynomial< T > | regina::operator- (const Polynomial< T > &lhs, Polynomial< T > &&rhs) |
| Subtracts the two given polynomials. | |
| template<typename T > | |
| Polynomial< T > | regina::operator- (Polynomial< T > &&lhs, Polynomial< T > &&rhs) |
| Subtracts the two given polynomials. | |
| template<typename T > | |
| Polynomial< T > | regina::operator* (const Polynomial< T > &lhs, const Polynomial< T > &rhs) |
| Multiplies the two given polynomials. | |
| template<typename T > | |
| Polynomial< T > | regina::operator/ (Polynomial< T > lhs, const Polynomial< T > &rhs) |
| Divides the two given polynomials. | |
| void | regina::swap (Rational &a, Rational &b) noexcept |
| Swaps the contents of the given rationals. | |
| std::ostream & | regina::operator<< (std::ostream &out, const Rational &rat) |
| Writes the given rational to the given output stream. | |
| template<typename T > | |
| void | regina::swap (Vector< T > &a, Vector< T > &b) noexcept |
| Swaps the contents of the given vectors. | |
| template<class T > | |
| std::ostream & | regina::operator<< (std::ostream &out, const Vector< T > &vector) |
| Writes the given vector to the given output stream. | |
Variables | |
| constexpr int | regina::detail::binomSmall_ [17][17] |
| A lookup table that stores (n choose k) for all n ≤ 16. | |
Underlying mathematical gruntwork.
| #define mpz_cmp_si_cpp | ( | z, | |
| si ) |
An internal copy of the GMP signed comparison optimisations.
This macro should not be used outside this class.
By making our own copy of such optimisation macros we can use C++-style casts instead of C-style casts and avoid noisy compiler warnings. I'd love a better way of doing this.
| using regina::Integer = IntegerBase<false> |
Integer is a type alias for IntegerBase<false>, which offers arbitrary precision integers without support for infinity.
| using regina::LargeInteger = IntegerBase<true> |
LargeInteger is a type alias for IntegerBase<true>, which offers arbitrary precision integers with support for infinity.
| using regina::MatrixBool = Matrix<bool> |
A matrix of booleans.
This is used in a handful of places in Regina to represent incidence or adjacency matrices.
| typedef Matrix< Integer > regina::MatrixInt = Matrix<Integer> |
A matrix of arbitrary-precision integers.
This is the most common class used by Regina when running algebraic algorithms over integer matrices. Since the underlying type is Regina's Integer class, calculations will be exact regardless of how large the integers become.
| using regina::NativeLong = NativeInteger<sizeof(long)> |
NativeLong is a type alias for the NativeInteger template class whose underlying integer type is a native long.
| using regina::VectorInt = Vector<Integer> |
A vector of arbitrary-precision integers.
This is the underlying vector class that Regina uses to store angle structures.
| using regina::VectorLarge = Vector<LargeInteger> |
A vector of arbitrary-precision integers that allows infinite elements.
This is the underlying vector class that Regina uses to store normal surfaces and hypersurfaces.
|
strong |
Represents the different kinds of internal permutation codes that are used in Regina's various Perm<n> template classes.
See the Perm<n> class notes for more information on exactly how these codes are constructed. The class constant Perm<n>::codeType indicates which type of code is used for which n.
| Enumerator | |
|---|---|
| Images | This is a permutation code that packs the images of 0,...,n-1 into a single native integer using a handful of bits per image. Such codes are easier to manipulate on an element-by-element basis. Codes of this type can always be queried using Perm<n>::permCode(), and permutations can be recreated from them using Perm<n>::fromPermCode(). |
| Index | This is a permutation code that stores the index into the full permutation group S_n. Such codes typically require fewer bytes and are packed together, making them ideal for working with lookup tables. Codes of this type can be queried using Perm<n>::SnIndex(), and permutations can be recreated from them by indexing into Perm<n>::Sn.
|
|
inlineconstexpr |
Returns the binomial coefficient n choose k in linear time for medium-sized arguments (n ≤ 61).
This routine computes the binomial coefficient using the standard formula. It works entirely with native integers of a large enough size; the constraint n ≤ 61 is designed to avoid overflow (since all intermediate results are guaranteed to stay below 2^63).
If n ≤ 16 then this routine will use the same constant-time lookup as binomSmall() (i.e., there is no penalty for calling this routine with very small arguments).
If k is outside the usual range (i.e., k is negative or greater than n), then this routine will return 0.
| InvalidArgument | The argument n is negative or greater than 61. |
| n | the parameter n in (n choose k); this must be between 0 and 61 inclusive. |
| k | the parameter k in (n choose k). |
|
inlineconsteval |
Returns the binomial coefficient n choose k in constant time for small arguments (n ≤ 16).
This routine is very fast, since it uses a constant-time lookup. The trade-off is that it can only be used for n ≤ 16.
consteval which means it cannot be used at runtime, and therefore cannot be used in Python at all. Python users should call binomMedium() instead, which will be just as fast for arguments n ≤ 16.| n | the parameter n in (n choose k); this must be between 0 and 16 inclusive. |
| k | the parameter k in (n choose k); this must be between 0 and n inclusive. |
| void regina::columnEchelonForm | ( | MatrixInt & | M, |
| MatrixInt & | R, | ||
| MatrixInt & | Ri, | ||
| const std::vector< size_t > & | rowList ) |
Transforms a given matrix into column echelon form with respect to a collection of rows.
The transformation will perform only column operations.
Given the matrix M and the list rowList of rows from M, this algorithm puts M in column echelon form with respect to the rows in rowList. The only purpose of rowList is to clarify and/or weaken precisely what is meant by "column echelon form"; all rows of M are affected by the resulting column operations that take place.
This routine also returns the corresponding change of coordinate matrices R and Ri:
R * Ri as the algorithm runs.original_M * R = final_M and final_M * Ri = original_M.Our convention is that a matrix is in column echelon form if:
By a "zero column" here we simply mean "zero for every row in \a rowList". Likewise, by "first non-zero entry" we mean "first row in \a rowList with a non-zero entry".
In a pinch, you can also use this routine to compute the inverse of an invertible square matrix.
If you just wish to reduce the matrix, you do not care about the order of rows, and you do not want the change-of-basis matrices, then you should call MatrixInt::columnEchelonForm() instead, which is simpler but also more streamlined.
| InvalidArgument | Either `R.columns() ≠ M.columns()`, and/or Ri.rows() ≠ M.columns(). |
| M | the matrix to reduce. |
| R | used to return the row-reduction matrix, as described above. |
| Ri | used to return the inverse of R. |
| rowList | the rows to pay attention to. This list must contain distinct integers, all between 0 and M.rows()-1 inclusive (though it need not contain all of these integers). The integers may appear in any order (though changing the order will change the resulting column echelon form). For a "classical" column echelon form, this would be the list of all rows: 0,...,(M.rows()-1). |
|
inlineconstexpr |
Returns the character used to express the integer i in a permutation.
| i | the integer to represent; this must be between 0 and 35 inclusive. |
|
inlineconstexpr |
Returns the factorial of n.
| n | any non-negative integer; this must be at most 20 (since otherwise the factorial will overflow). |
| long regina::gcd | ( | long | a, |
| long | b ) |
Deprecated routine that calculates the greatest common divisor of two signed integers.
This routine is not recursive.
Although the arguments may be negative, the result is guaranteed to be non-negative. As a special case, gcd(0,0) is considered to be zero.
| a | one of the two integers to work with. |
| b | the other integer with which to work. |
| std::tuple< long, long, long > regina::gcdWithCoeffs | ( | long | a, |
| long | b ) |
Calculates the greatest common divisor of two given integers and finds the smallest coefficients with which these integers combine to give their gcd.
This routine is not recursive.
Note that the given integers need not be non-negative. However, the gcd returned is guaranteed to be non-negative. As a special case, gcd(0,0) is considered to be zero.
If d is the gcd of a and b, then this routine returns the tuple (d, u, v), where u and v are coefficients for which:
u⋅a + v⋅b = d;-|a|/d < v⋅sign(b) ≤ 0 < u⋅sign(a) ≤ |b|/d.In the special case where one of the given integers is zero, the corresponding coefficient will also be zero and the other coefficient will be 1 or -1 so that u⋅a + v⋅b = d still holds. If both given integers are zero, both of the coefficients will be set to zero.
long.| a | the first integer to compute the gcd of. |
| b | the second integer to compute the gcd of. |
| long regina::lcm | ( | long | a, |
| long | b ) |
Deprecated routine that calculates the lowest common multiple of two signed integers.
Although the arguments may be negative, the result is guaranteed to be non-negative.
If either of the arguments is zero, the return value will also be zero.
Regarding possible overflow: This routine does not create any temporary integers that are larger in magnitude than the final LCM.
| a | one of the two integers to work with. |
| b | the other integer with which to work. |
| void regina::metricalSmithNormalForm | ( | MatrixInt & | matrix, |
| MatrixInt & | rowSpaceBasis, | ||
| MatrixInt & | rowSpaceBasisInv, | ||
| MatrixInt & | colSpaceBasis, | ||
| MatrixInt & | colSpaceBasisInv ) |
An alternative Smith normal form algorithm that also returns change of basis matrices.
This routine may be preferable for extremely large matrices. This is a variant of Hafner-McCurley and Havas-Holt-Rees's description of pivoting methods.
The only input argument is matrix. The four remaining arguments (the change of basis matrices) will be refilled. All five arguments are used to return information as follows.
Let M be the initial value of matrix, and let S be the Smith normal form of M. After this routine exits:
colSpaceBasis * M * rowSpaceBasis = S;colSpaceBasisInv * S * rowSpaceBasisInv = M;colSpaceBasis * colSpaceBasisInv and rowSpaceBasis * rowSpaceBasisInv are both identity matrices.Thus, one obtains the Smith normal form the original matrix by multiplying on the left by ColSpaceBasis and on the right by RowSpaceBasis.
The matrices rowSpaceBasis and rowSpaceBasisInv that are passed may be of any size, or they may even be uninitialised; upon return they will both be square with side length matrix.columns(). Likewise, the matrices colSpaceBasis and colSpaceBasisInv that are passed may be of any size or may be uninitialised; upon return they will both be square with side length matrix.rows().
| matrix | the original matrix to put into Smith Normal Form (this need not be square). When the algorithm terminates, this matrix is in its Smith Normal Form. |
| rowSpaceBasis | used to return a change of basis matrix (see above for details). |
| rowSpaceBasisInv | used to return the inverse of rowSpaceBasis. |
| colSpaceBasis | used to return a change of basis matrix (see above for details). |
| colSpaceBasisInv | used to return the inverse of colSpaceBasis. |
| long regina::modularInverse | ( | long | n, |
| long | k ) |
Calculates the multiplicative inverse of one integer modulo another.
Specifically, this computes the inverse of k modulo n, and returns a result between 0 and n - 1 inclusive.
Note that n == 1 is allowed, and will return 0 for any k.
| InvalidArgument | Either n is zero or negative, or the given arguments are not coprime. |
| n | the modular base in which to work. |
| k | the number whose multiplicative inverse should be found. |
k * v == 1 (mod n). Multiplies the given arrow polynomial by the given Laurent polynomial in A.
| arrow | the arrow polynomial to multiply by. |
| laurent | the Laurent polynomial to multiply by; this will be treated as a Laurent polynomial in the ordinary variable A. |
Multiplies the given polynomial by the given integer constant.
| poly | the polynomial to multiply by. |
| scalar | the scalar factor to multiply by. |
Multiplies the two given polynomials.
| lhs | the first polynomial to multiply. |
| rhs | the second polynomial to multiply. |
| Cyclotomic regina::operator* | ( | const Cyclotomic & | lhs, |
| const Cyclotomic & | rhs ) |
Multiplies the two given cyclotomic field elements.
| lhs | the first field element to multiply. |
| rhs | the second field element to multiply. |
Multiplies the given polynomial by the given integer constant.
| scalar | the scalar factor to multiply by. |
| poly | the polynomial to multiply by. |
|
inline |
Multiplies the two given polynomials.
The two polynomials need not have the same range of non-zero coefficients.
| lhs | the first polynomial to multiply. |
| rhs | the second polynomial to multiply. |
Multiplies the given arrow polynomial by the given Laurent polynomial in A.
| laurent | the Laurent polynomial to multiply by; this will be treated as a Laurent polynomial in the ordinary variable A. |
| arrow | the arrow polynomial to multiply by. |
| Laurent< T > regina::operator* | ( | const Laurent< T > & | lhs, |
| const Laurent< T > & | rhs ) |
Multiplies the two given polynomials.
| lhs | the first polynomial to multiply. |
| rhs | the second polynomial to multiply. |
| Polynomial< T > regina::operator* | ( | const Polynomial< T > & | lhs, |
| const Polynomial< T > & | rhs ) |
Multiplies the two given polynomials.
| lhs | the first polynomial to multiply. |
| rhs | the second polynomial to multiply. |
|
inline |
Multiplies the given field element by the given rational.
| scalar | the rational to multiply by. |
| elt | the field element to multiply by. |
|
inline |
Multiplies the given polynomial by the given scalar constant.
The scalar is simply of type T; we use the identical type Laurent2<T>::Coefficient here to assist with C++ template type matching.
| scalar | the scalar to multiply by. |
| poly | the polynomial to multiply by. |
|
inline |
Multiplies the given polynomial by the given scalar constant.
The scalar is simply of type T; we use the identical type Laurent<T>::Coefficient here to assist with C++ template type matching.
| scalar | the scalar to multiply by. |
| poly | the polynomial to multiply by. |
|
inline |
Multiplies the given polynomial by the given scalar constant.
The scalar is simply of type T; we use the identical type Polynomial<T>::Coefficient here to assist with C++ template type matching.
| scalar | the scalar to multiply by. |
| poly | the polynomial to multiply by. |
|
inline |
Multiplies the given field element by the given rational.
| elt | the field element to multiply by. |
| scalar | the rational to multiply by. |
|
inline |
Multiplies the given polynomial by the given scalar constant.
The scalar is simply of type T; we use the identical type Laurent2<T>::Coefficient here to assist with C++ template type matching.
| poly | the polynomial to multiply by. |
| scalar | the scalar to multiply by. |
|
inline |
Multiplies the given polynomial by the given scalar constant.
The scalar is simply of type T; we use the identical type Laurent<T>::Coefficient here to assist with C++ template type matching.
| poly | the polynomial to multiply by. |
| scalar | the scalar to multiply by. |
|
inline |
Multiplies the given native integer with the given large integer.
If the large integer is infinite, the result will also be infinity.
| lhs | the native integer to multiply. |
| rhs | the large integer to multiply. |
|
inline |
Multiplies the given polynomial by the given scalar constant.
The scalar is simply of type T; we use the identical type Polynomial<T>::Coefficient here to assist with C++ template type matching.
| poly | the polynomial to multiply by. |
| scalar | the scalar to multiply by. |
Adds the two given polynomials.
| lhs | the first polynomial to add. |
| rhs | the second polynomial to add. |
Adds the two given polynomials.
| lhs | the first polynomial to add. |
| rhs | the second polynomial to add. |
Adds the two given polynomials.
| lhs | the first polynomial to add. |
| rhs | the second polynomial to add. |
Adds the two given polynomials.
| lhs | the first polynomial to add. |
| rhs | the second polynomial to add. |
|
inline |
Adds the two given cyclotomic field elements.
| lhs | the first field element to add. |
| rhs | the second field element to add. |
|
inline |
Adds the two given cyclotomic field elements.
| lhs | the first field element to add. |
| rhs | the second field element to add. |
|
inline |
Adds the two given polynomials.
The two polynomials need not have the same range of non-zero coefficients.
| lhs | the first polynomial to add. |
| rhs | the second polynomial to add. |
|
inline |
Adds the two given polynomials.
The two polynomials need not have the same range of non-zero coefficients.
| lhs | the first polynomial to add. |
| rhs | the second polynomial to add. |
| Laurent< T > regina::operator+ | ( | const Laurent< T > & | lhs, |
| const Laurent< T > & | rhs ) |
Adds the two given polynomials.
This operator + is sometimes faster than using +=, since it has more flexibility to avoid an internal deep copy.
| lhs | the first polynomial to add. |
| rhs | the second polynomial to add. |
|
inline |
Adds the two given polynomials.
This operator + is sometimes faster than using +=, since it has more flexibility to avoid an internal deep copy.
| lhs | the first polynomial to add. |
| rhs | the second polynomial to add. |
| Polynomial< T > regina::operator+ | ( | const Polynomial< T > & | lhs, |
| const Polynomial< T > & | rhs ) |
Adds the two given polynomials.
This operator + is sometimes faster than using +=, since it has more flexibility to avoid an internal deep copy.
| lhs | the first polynomial to add. |
| rhs | the second polynomial to add. |
|
inline |
Adds the two given polynomials.
This operator + is sometimes faster than using +=, since it has more flexibility to avoid an internal deep copy.
| lhs | the first polynomial to add. |
| rhs | the second polynomial to add. |
|
inline |
Adds the two given cyclotomic field elements.
| lhs | the first field element to add. |
| rhs | the second field element to add. |
|
inline |
Adds the two given cyclotomic field elements.
| lhs | the first field element to add. |
| rhs | the second field element to add. |
|
inline |
Adds the two given polynomials.
The two polynomials need not have the same range of non-zero coefficients.
| lhs | the first polynomial to add. |
| rhs | the second polynomial to add. |
|
inline |
Adds the two given polynomials.
The two polynomials need not have the same range of non-zero coefficients.
| lhs | the first polynomial to add. |
| rhs | the second polynomial to add. |
|
inline |
Adds the two given polynomials.
This operator + is sometimes faster than using +=, since it has more flexibility to avoid an internal deep copy.
| lhs | the first polynomial to add. |
| rhs | the second polynomial to add. |
|
inline |
Adds the two given polynomials.
This operator + is sometimes faster than using +=, since it has more flexibility to avoid an internal deep copy.
| lhs | the first polynomial to add. |
| rhs | the second polynomial to add. |
|
inline |
Adds the given native integer to the given large integer.
If the large integer is infinite, the result will also be infinity.
| lhs | the native integer to add. |
| rhs | the large integer to add. |
|
inline |
Adds the two given polynomials.
This operator + is sometimes faster than using +=, since it has more flexibility to avoid an internal deep copy.
| lhs | the first polynomial to add. |
| rhs | the second polynomial to add. |
|
inline |
Adds the two given polynomials.
This operator + is sometimes faster than using +=, since it has more flexibility to avoid an internal deep copy.
| lhs | the first polynomial to add. |
| rhs | the second polynomial to add. |
Subtracts the two given polynomials.
| lhs | the polynomial to sutract rhs from. |
| rhs | the polynomial to subtract from lhs. |
Subtracts the two given polynomials.
| lhs | the polynomial to sutract rhs from. |
| rhs | the polynomial to subtract from lhs. |
Returns the negative of the given polynomial.
| arg | the polynomial to negate. |
Subtracts the two given polynomials.
| lhs | the polynomial to sutract rhs from. |
| rhs | the polynomial to subtract from lhs. |
Subtracts the two given polynomials.
| lhs | the polynomial to sutract rhs from. |
| rhs | the polynomial to subtract from lhs. |
|
inline |
Subtracts the two given cyclotomic field elements.
| lhs | the field element to subtract from. |
| rhs | the field element to subtract. |
|
inline |
Subtracts the two given cyclotomic field elements.
| lhs | the field element to subtract from. |
| rhs | the field element to subtract. |
|
inline |
Subtracts the two given polynomials.
The two polynomials need not have the same range of non-zero coefficients.
| lhs | the polynomial to subtract from. |
| rhs | the polynomial to subtract. |
|
inline |
Subtracts the two given polynomials.
The two polynomials need not have the same range of non-zero coefficients.
| lhs | the polynomial to subtract from. |
| rhs | the polynomial to subtract. |
| Laurent< T > regina::operator- | ( | const Laurent< T > & | lhs, |
| const Laurent< T > & | rhs ) |
Subtracts the two given polynomials.
This operator - is sometimes faster than using -=, since it has more flexibility to avoid an internal deep copy.
| lhs | the polynomial to sutract rhs from. |
| rhs | the polynomial to subtract from lhs. |
| Laurent< T > regina::operator- | ( | const Laurent< T > & | lhs, |
| Laurent< T > && | rhs ) |
Subtracts the two given polynomials.
This operator - is sometimes faster than using -=, since it has more flexibility to avoid an internal deep copy.
| lhs | the polynomial to sutract rhs from. |
| rhs | the polynomial to subtract from lhs. |
| Polynomial< T > regina::operator- | ( | const Polynomial< T > & | lhs, |
| const Polynomial< T > & | rhs ) |
Subtracts the two given polynomials.
This operator - is sometimes faster than using -=, since it has more flexibility to avoid an internal deep copy.
| lhs | the polynomial to sutract rhs from. |
| rhs | the polynomial to subtract from lhs. |
| Polynomial< T > regina::operator- | ( | const Polynomial< T > & | lhs, |
| Polynomial< T > && | rhs ) |
Subtracts the two given polynomials.
This operator - is sometimes faster than using -=, since it has more flexibility to avoid an internal deep copy.
| lhs | the polynomial to sutract rhs from. |
| rhs | the polynomial to subtract from lhs. |
|
inline |
Subtracts the two given cyclotomic field elements.
| lhs | the field element to subtract from. |
| rhs | the field element to subtract. |
|
inline |
Subtracts the two given cyclotomic field elements.
| lhs | the field element to subtract from. |
| rhs | the field element to subtract. |
|
inline |
Returns the negative of the given field element.
| arg | the field element to negate. |
|
inline |
Subtracts the two given polynomials.
The two polynomials need not have the same range of non-zero coefficients.
| lhs | the polynomial to subtract from. |
| rhs | the polynomial to subtract. |
|
inline |
Subtracts the two given polynomials.
The two polynomials need not have the same range of non-zero coefficients.
| lhs | the polynomial to subtract from. |
| rhs | the polynomial to subtract. |
Returns the negative of the given polynomial.
| arg | the polynomial to negate. |
| Laurent< T > regina::operator- | ( | Laurent< T > && | lhs, |
| const Laurent< T > & | rhs ) |
Subtracts the two given polynomials.
This operator - is sometimes faster than using -=, since it has more flexibility to avoid an internal deep copy.
| lhs | the polynomial to sutract rhs from. |
| rhs | the polynomial to subtract from lhs. |
Subtracts the two given polynomials.
This operator - is sometimes faster than using -=, since it has more flexibility to avoid an internal deep copy.
| lhs | the polynomial to sutract rhs from. |
| rhs | the polynomial to subtract from lhs. |
Returns the negative of the given polynomial.
| arg | the polynomial to negate. |
| Polynomial< T > regina::operator- | ( | Polynomial< T > && | lhs, |
| const Polynomial< T > & | rhs ) |
Subtracts the two given polynomials.
This operator - is sometimes faster than using -=, since it has more flexibility to avoid an internal deep copy.
| lhs | the polynomial to sutract rhs from. |
| rhs | the polynomial to subtract from lhs. |
| Polynomial< T > regina::operator- | ( | Polynomial< T > && | lhs, |
| Polynomial< T > && | rhs ) |
Subtracts the two given polynomials.
This operator - is sometimes faster than using -=, since it has more flexibility to avoid an internal deep copy.
| lhs | the polynomial to sutract rhs from. |
| rhs | the polynomial to subtract from lhs. |
|
inline |
Returns the negative of the given polynomial.
| arg | the polynomial to negate. |
|
inline |
Divides the two given cyclotomic field elements.
| lhs | the field element to divide by rhs. |
| rhs | the field element to divide lhs by. |
|
inline |
Divides the given field element by the given rational.
| elt | the field element to divide by the given rational. |
| scalar | the rational to divide by. |
|
inline |
Divides the given polynomial by the given scalar constant.
This uses the division operator /= for the coefficient type T.
The scalar is simply of type T; we use the identical type Laurent2<T>::Coefficient here to assist with C++ template type matching.
| poly | the polynomial to divide by the given scalar. |
| scalar | the scalar factor to divide by. |
|
inline |
Divides the given polynomial by the given scalar constant.
This uses the division operator /= for the coefficient type T.
The scalar is simply of type T; we use the identical type Laurent<T>::Coefficient here to assist with C++ template type matching.
| poly | the polynomial to divide by the given scalar. |
| scalar | the scalar factor to divide by. |
|
inline |
Divides the two given polynomials.
More precisely: suppose there exist polynomials q and r with coefficients of type T for which lhs = q.rhs + r, and where r has smaller degree than rhs. Then we call q the quotient, and r the remainder.
This routine returns the quotient q, and discards the remainder. If you need to keep the remainder also, then call Polynomial::divisionAlg() instead.
Coefficients are divided using the operator /= on type T.
If your coefficient type T is not a field (e.g., if T is Integer), you must be sure to know in advance that the quotient exists (see the precondition below). Otherwise the behaviour of this routine is undefined.
| lhs | the polynomial to divide by rhs. |
| rhs | the polynomial that we will divide lhs by. |
|
inline |
Divides the given polynomial by the given scalar constant.
This uses the division operator /= for the coefficient type T.
The scalar is simply of type T; we use the identical type Polynomial<T>::Coefficient here to assist with C++ template type matching.
| poly | the polynomial to divide by the given scalar. |
| scalar | the scalar factor to divide by. |
| std::ostream & regina::operator<< | ( | std::ostream & | out, |
| const IntegerBase< withInfinity > & | i ) |
Writes the given integer to the given output stream.
| out | the output stream to which to write. |
| i | the integer to write. |
|
inline |
Writes the given matrix to the given output stream.
The matrix will be written entirely on a single line, with the first row followed by the second row.
| out | the output stream to which to write. |
| mat | the matrix to write. |
| std::ostream & regina::operator<< | ( | std::ostream & | out, |
| const Matrix3D< Real > & | m ) |
Writes the given matrix to the given output stream.
The matrix will be written row by row, in the form [[ m00 m01 m02 ] [ m10 m11 m12 ] [ m20 m21 m22 ]].
| out | the output stream to which to write. |
| m | the matrix to write. |
|
inline |
Writes the given integer to the given output stream.
| out | the output stream to which to write. |
| i | the integer to write. |
|
inline |
Writes a string representation of the given permutation to the given output stream.
The format will be the same as is used by Perm::str().
| out | the output stream to which to write. |
| p | the permutation to write. |
| n | the number of objects being permuted. This must be between 2 and 16 inclusive. |
|
inline |
Writes a string representation of the given conjugacy class of permutations to the given output stream.
The format will be the same as is used by PermClass<n>::str().
| out | the output stream to which to write. |
| c | the conjugacy class to write. |
| n | the number of objects being permuted. This must be between 2 and 16 inclusive. |
| std::ostream & regina::operator<< | ( | std::ostream & | out, |
| const Rational & | rat ) |
Writes the given rational to the given output stream.
Infinity will be written as Inf. Undefined will be written as Undef. A rational with denominator one will be written as a single integer. All other rationals will be written in the form r/s.
| out | the output stream to which to write. |
| rat | the rational to write. |
| std::ostream & regina::operator<< | ( | std::ostream & | out, |
| const Rotation3D< Real > & | rot ) |
Writes the given rotation to the given output stream.
The rotation will be written using its quaternion coordinates, as a tuple (a, b, c, d).
| out | the output stream to which to write. |
| rot | the rotation to write. |
| std::ostream & regina::operator<< | ( | std::ostream & | out, |
| const Segment3D< Real > & | s ) |
Writes the given line segment to the given output stream.
The segment will be written in the form [(...), (...)].
| out | the output stream to which to write. |
| s | the line segment to write. |
| std::ostream & regina::operator<< | ( | std::ostream & | out, |
| const Vector3D< Real > & | v ) |
Writes the given vector to the given output stream.
The vector will be written as a triple (x, y, z).
| out | the output stream to which to write. |
| v | the vector to write. |
| std::ostream & regina::operator<< | ( | std::ostream & | out, |
| const Vector< T > & | vector ) |
Writes the given vector to the given output stream.
The vector will be written on a single line with elements separated by a single space. No newline will be written.
| out | the output stream to which to write. |
| vector | the vector to write. |
| MatrixInt regina::preImageOfLattice | ( | const MatrixInt & | hom, |
| const std::vector< Integer > & | sublattice ) |
Given a homomorphism from Z^n to Z^k and a sublattice of Z^k, compute the preimage of this sublattice under this homomorphism.
The homomorphism from Z^n to Z^k is described by the given k by n matrix hom. The sublattice is of the form (p1 Z) * (p2 Z) * ... * (pk Z), where the non-negative integers p1, ..., pk are passed in the given list sublattice.
An equivalent problem is to consider hom to be a homomorphism from Z^n to Z_p1 + ... + Z_pk; this routine then finds the kernel of this homomorphism.
The preimage of the sublattice (equivalently, the kernel described above) is some rank n lattice in Z^n. This algorithm finds and returns a basis for the lattice.
| InvalidArgument | The length of sublattice is different from the number of rows of hom. Note that the contents of sublattice (specifically, the signs of the integers it contains) are not checked. |
| hom | the matrix representing the homomorphism from Z^n to Z^k; this must be a k by n matrix. |
| sublattice | a list of length k describing the sublattice of Z^k; the elements of this list must be the non-negative integers p1, ..., pk as described above. |
| long regina::reducedMod | ( | long | k, |
| long | modBase ) |
Reduces k modulo modBase to give the smallest possible absolute value.
For instance, reducedMod(4,10) = 4 but reducedMod(6,10) = -4. In the case of a tie, the positive solution is taken.
| InvalidArgument | The argument modBase is zero or negative. |
| k | the number to reduce modulo modBase. |
| modBase | the modular base in which to work. |
| size_t regina::rowBasis | ( | MatrixInt & | matrix | ) |
Find a basis for the row space of the given matrix.
This routine will rearrange the rows of the given matrix so that the first rank rows form a basis for the row space (where rank is the rank of the matrix). The rank itself will be returned. No other changes will be made to the matrix aside from swapping rows.
Although this routine takes an integer matrix (and only uses integer operations), we consider the row space to be over the rationals. That is, although we never divide, we act as though we could if we wanted to.
| matrix | the matrix to examine and rearrange. |
Finds a basis for the row space of the given matrix, as well as an "incremental" basis for its orthogonal complement.
This routine takes an (r by c) matrix input, as well as a square (c by c) matrix complement, and does the following:
This routine can help with larger procedures that need to build up a row space and simultaneously cut down the complement one dimension at a time.
Although this routine takes integer matrices (and only uses integer operations), we consider all bases to be over the rationals. That is, although we never divide, we act as though we could if we wanted to.
| InvalidArgument | The matrix complement is not square with side length equal to input.columns(). |
| input | the input matrix whose row space we will describe; this matrix will be changed (though only by swapping rows). |
| complement | the square matrix that will be re-filled with the "incremental" basis for the orthogonal complement of input. |
Deprecated routine that determines whether the first given matrix is more aesthetically pleasing than the second.
| m1 | the first matrix to examine. |
| m2 | the second matrix to examine. |
true if m1 is deemed to be more pleasing than m2, or false if either the matrices are equal or m2 is more pleasing than m1.
|
inline |
Deprecated routine that determines whether the first given pair of matrices is more aesthetically pleasing than the second pair.
| pair1first | the first matrix of the first pair to examine. |
| pair1second | the second matrix of the first pair to examine. |
| pair2first | the first matrix of the second pair to examine. |
| pair2second | the second matrix of the second pair to examine. |
true if the first pair is deemed to be more pleasing than the second pair, or false if either the ordered pairs are equal or the second pair is more pleasing than the first. Compare two matrices to determine which is more aesthetically pleasing.
The way in which this judgement is made is purely aesthetic on the part of the author, and is subject to change in future versions of Regina.
std::strong_ordering, this routine returns an integer -1, 0 or 1 (representing less, equal or greater respectively).| m1 | the first matrix to examine. |
| m2 | the second matrix to examine. |
less if m1 is deemed to be more pleasing than m2, greater if m2 is more pleasing than m1, or equal if both matrices are equal. | std::strong_ordering regina::simplerThreeWay | ( | const Matrix2 & | pair1first, |
| const Matrix2 & | pair1second, | ||
| const Matrix2 & | pair2first, | ||
| const Matrix2 & | pair2second ) |
Compares two ordered pairs of matrices to determine which pair is more aesthetically pleasing.
The way in which this judgement is made is purely aesthetic on the part of the author, and is subject to change in future versions of Regina.
Note that pairs are ordered, so the pair (M, N) may be more (or perhaps less) pleasing than the pair (N, M).
std::strong_ordering, this routine returns an integer -1, 0 or 1 (representing less, equal or greater respectively).| pair1first | the first matrix of the first pair to examine. |
| pair1second | the second matrix of the first pair to examine. |
| pair2first | the first matrix of the second pair to examine. |
| pair2second | the second matrix of the second pair to examine. |
less if the first pair is deemed to be more pleasing than the second pair, greater if the second pair is more pleasing than the first, or equal if both ordered pairs are equal. | void regina::smithNormalForm | ( | MatrixInt & | matrix | ) |
Transforms the given integer matrix into Smith normal form.
Note that the given matrix need not be square and need not be of full rank.
Reading down the diagonal, the final Smith normal form will have a series of non-negative, non-decreasing invariant factors followed by zeroes. "Invariant factor" refers to the convention that the ith term divides the (i+1)th term, and so they are unique.
The algorithm used is due to Hafner and McCurley (1991). It does not use modular arithmetic to control the intermediate coefficient explosion.
| matrix | the matrix to transform. |
| void regina::smithNormalForm | ( | MatrixInt & | matrix, |
| MatrixInt & | rowSpaceBasis, | ||
| MatrixInt & | rowSpaceBasisInv, | ||
| MatrixInt & | colSpaceBasis, | ||
| MatrixInt & | colSpaceBasisInv ) |
A Smith normal form algorithm that also returns change of basis matrices.
This is a modification of the one-argument smithNormalForm(MatrixInt&). As well as converting the given matrix matrix into Smith normal form, it also returns the appropriate change-of-basis matrices corresponding to all the row and column operations that were performed.
The only input argument is matrix. The four remaining arguments (the change of basis matrices) will be refilled. All five arguments are used to return information as follows.
Let M be the initial value of matrix, and let S be the Smith normal form of M. After this routine exits:
colSpaceBasis * M * rowSpaceBasis = S;colSpaceBasisInv * S * rowSpaceBasisInv = M;colSpaceBasis * colSpaceBasisInv and rowSpaceBasis * rowSpaceBasisInv are both identity matrices.Thus, one obtains the Smith normal form of the original matrix by multiplying on the left by ColSpaceBasis and on the right by RowSpaceBasis.
The matrices rowSpaceBasis and rowSpaceBasisInv that are passed may be of any size, or they may even be uninitialised; upon return they will both be square with side length matrix.columns(). Likewise, the matrices colSpaceBasis and colSpaceBasisInv that are passed may be of any size or may be uninitialised; upon return they will both be square with side length matrix.rows().
| matrix | the original matrix to put into Smith Normal Form (this need not be square). When the algorithm terminates, this matrix is in its Smith Normal Form. |
| rowSpaceBasis | used to return a change of basis matrix (see above for details). |
| rowSpaceBasisInv | used to return the inverse of rowSpaceBasis. |
| colSpaceBasis | used to return a change of basis matrix (see above for details). |
| colSpaceBasisInv | used to return the inverse of colSpaceBasis. |
Swaps the contents of the given polynomials.
This global routine simply calls Arrow::swap(); it is provided so that Arrow meets the C++ Swappable requirements.
| a | the first polynomial whose contents should be swapped. |
| b | the second polynomial whose contents should be swapped. |
|
inlinenoexcept |
Swaps the contents of the given field elements.
This global routine simply calls Cyclotomic::swap(); it is provided so that Cyclotomic meets the C++ Swappable requirements.
| a | the first field element whose contents should be swapped. |
| b | the second field element whose contents should be swapped. |
|
inlinenoexcept |
Swaps the contents of the given integers.
This global routine simply calls IntegerBase<withInfinity>::swap(); it is provided so that IntegerBase meets the C++ Swappable requirements.
| a | the first integer whose contents should be swapped. |
| b | the second integer whose contents should be swapped. |
Swaps the contents of the given polynomials.
This global routine simply calls Laurent2<T>::swap(); it is provided so that Laurent2<T> meets the C++ Swappable requirements.
| a | the first polynomial whose contents should be swapped. |
| b | the second polynomial whose contents should be swapped. |
Swaps the contents of the given polynomials.
This global routine simply calls Laurent<T>::swap(); it is provided so that Laurent<T> meets the C++ Swappable requirements.
| a | the first polynomial whose contents should be swapped. |
| b | the second polynomial whose contents should be swapped. |
Swaps the contents of the two given matrices.
This global routine simply calls Matrix2::swap(); it is provided so that Matrix2 meets the C++ Swappable requirements.
| a | the first matrix whose contents should be swapped. |
| b | the second matrix whose contents should be swapped. |
Swaps the contents of the given matrices.
This global routine simply calls Matrix<T>::swap(); it is provided so that Matrix<T> meets the C++ Swappable requirements.
| a | the first matrix whose contents should be swapped. |
| b | the second matrix whose contents should be swapped. |
|
inlinenoexcept |
Swaps the contents of the given integers.
This global routine simply calls NativeInteger<bytes>::swap(); it is provided so that NativeInteger<bytes> meets the C++ Swappable requirements.
| a | the first integer whose contents should be swapped. |
| b | the second integer whose contents should be swapped. |
|
inlinenoexcept |
Swaps the contents of the given polynomials.
This global routine simply calls Polynomial<T>::swap(); it is provided so that Polynomial<T> meets the C++ Swappable requirements.
| a | the first polynomial whose contents should be swapped. |
| b | the second polynomial whose contents should be swapped. |
Swaps the contents of the given rationals.
This global routine simply calls Rational::swap(); it is provided so that Rational meets the C++ Swappable requirements.
| a | the first rational whose contents should be swapped. |
| b | the second rational whose contents should be swapped. |
Swaps the contents of the given vectors.
This global routine simply calls Vector<T>::swap(); it is provided so that Vector<T> meets the C++ Swappable requirements.
| a | the first vector whose contents should be swapped. |
| b | the second vector whose contents should be swapped. |
| void regina::tightEncode | ( | std::ostream & | out, |
| IntegerBase< withInfinity > | value ) |
Writes the tight encoding of the given arbitrary precision integer to the given output stream.
See the page on tight encodings for details.
This global function does the same thing as the member function IntegerBase::tightEncode(). However, this global function is more efficient if the integer argument is an rvalue reference (since the const member function induces an extra deep copy).
| out | the output stream to which the encoded string will be written. |
| value | the integer to encode. |
| std::string regina::tightEncoding | ( | IntegerBase< withInfinity > | value | ) |
Returns the tight encoding of the given arbitrary precision integer.
See the page on tight encodings for details.
This global function does the same thing as the member function IntegerBase::tightEncoding(). However, this global function is more efficient if the integer argument is an rvalue reference (since the const member function induces an extra deep copy).
| value | the integer to encode. |
| MatrixInt regina::torsionAutInverse | ( | const MatrixInt & | input, |
| const std::vector< Integer > & | invF ) |
Given an automorphism of an abelian group, this procedure computes the inverse automorphism.
The abelian group is of the form Z_p1 + Z_p2 + ... + Z_pn. The input is an n-by-n matrix A which represents a lift of the automorphism to just some n-by-n matrix. Specifically, you have a little commutative diagram with Z^n --A--> Z^n covering the automorphism of Z_p1 + Z_p2 + ... + Z_pn, where the maps down are the direct sum of the standard quotients Z --> Z_pi. So if you want this procedure to give you meaningful output, A must be a lift of a genuine automorphism of Z_p1 + ... + Z_pn.
| InvalidArgument | Either input is not a square matrix, and/or the length of invF is different from the side length of input. Note that the contents of invF (specifically, the divisibility property) are not checked. |
| input | the n-by-n matrix A, which must be a lift of a genuine automorphism as described above. |
| invF | the list p1, p2, ..., pn. |
|
inlineconstexpr |
A lookup table that stores (n choose k) for all n ≤ 16.
For all values 0 ≤ k ≤ n ≤ 16, the value binomSmall_[n][k] is the binomial coefficient (n choose k).
This array is used in the implementation of the function binomSmall(). End users should call binomSmall() instead of referring to this array directly.