Regina Calculation Engine
|
Underlying mathematical gruntwork. More...
Namespaces | |
regina::detail | |
Contains implementation details and common functionality for Regina's dimension-agnostic classes. | |
Classes | |
class | regina::Cyclotomic |
Represents an element of a cyclotomic field. More... | |
class | regina::NativeInteger< bytes > |
A wrapper class for a native, fixed-precision integer type of the given size. More... | |
struct | regina::InfinityBase< supportInfinity > |
Internal base classes for use with IntegerBase, templated on whether we should support infinity as an allowed value. More... | |
class | regina::IntegerBase< supportInfinity > |
Represents an arbitrary precision integer. 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... | |
struct | regina::MatrixRingIdentities< T, ring > |
Provides additive and multiplicative identity constants for the Matrix class. More... | |
class | regina::Matrix< T, ring > |
Represents a matrix of elements of the given type T. More... | |
class | regina::Perm< n > |
Represents a permutation of {0,1,...,n-1}. 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... | |
class | regina::Ray |
A fast class for storing a ray rooted at the origin that passes through an integer point. 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::Vector< T > |
An optimised vector class of elements from a given ring T. More... | |
Typedefs | |
typedef Cyclotomic | regina::NCyclotomic |
Deprecated typedef for backward compatibility. More... | |
typedef IntegerBase< true > | regina::LargeInteger |
LargeInteger is a typedef for IntegerBase<true>, which offers arbitrary precision integers with support for infinity. More... | |
typedef IntegerBase< false > | regina::Integer |
Integer is a typedef for IntegerBase<false>, which offers arbitrary precision integers without support for infinity. More... | |
typedef NativeInteger< sizeof(long)> | regina::NNativeLong |
NNativeLong is a typedef for the NativeInteger template class whose underlying integer type is a native long. More... | |
typedef Integer | regina::NInteger |
Deprecated typedef for backward compatibility. More... | |
typedef LargeInteger | regina::NLargeInteger |
Deprecated typedef for backward compatibility. More... | |
template<int bytes> | |
using | regina::NNativeInteger = NativeInteger< bytes > |
Deprecated typedef for backward compatibility. More... | |
template<class T > | |
using | regina::MatrixRing = Matrix< T, true > |
Deprecated typedef for backward compatibility. More... | |
template<class T > | |
using | regina::MatrixIntDomain = Matrix< T, true > |
Deprecated typedef for backward compatibility. More... | |
template<class T > | |
using | regina::NMatrix = Matrix< T, false > |
Deprecated typedef for backward compatibility. More... | |
template<class T > | |
using | regina::NMatrixRing = Matrix< T, true > |
Deprecated typedef for backward compatibility. More... | |
typedef MatrixInt | regina::NMatrixInt |
Deprecated typedef for backward compatibility. More... | |
template<int n> | |
using | regina::NPerm = Perm< n > |
Deprecated typedef for backward compatibility. More... | |
template<typename T > | |
using | regina::NPolynomial = Polynomial< T > |
Deprecated typedef for backward compatibility. More... | |
typedef Primes | regina::NPrimes |
Deprecated typedef for backward compatibility. More... | |
typedef Rational | regina::NRational |
Deprecated typedef for backward compatibility. More... | |
typedef Ray | regina::NRay |
Deprecated typedef for backward compatibility. More... | |
typedef Perm< 2 > | regina::NPerm2 |
Deprecated typedef for backward compatibility. More... | |
typedef Perm< 3 > | regina::NPerm3 |
Deprecated typedef for backward compatibility. More... | |
typedef Perm< 4 > | regina::NPerm4 |
Deprecated typedef for backward compatibility. More... | |
typedef Perm< 5 > | regina::NPerm5 |
Deprecated typedef for backward compatibility. More... | |
template<class T > | |
using | regina::NVector = Vector< T > |
Deprecated typedef for backward compatibility. More... | |
Functions | |
template<class R > | |
bool | regina::isZero (R x) |
Deprecated routine for managing floating-point roundoff errors. More... | |
template<class R > | |
bool | regina::isNonZero (R x) |
Deprecated routine for managing floating-point roundoff errors. More... | |
template<class R > | |
bool | regina::isPositive (R x) |
Deprecated routine for managing floating-point roundoff errors. More... | |
template<class R > | |
bool | regina::isNegative (R x) |
Deprecated routine for managing floating-point roundoff errors. More... | |
template<class R > | |
bool | regina::isNonNegative (R x) |
Deprecated routine for managing floating-point roundoff errors. More... | |
template<class R > | |
bool | regina::isNonPositive (R x) |
Deprecated routine for managing floating-point roundoff errors. More... | |
int | regina::binomSmall (int n, int k) |
Returns the binomial coefficient n choose k in constant time for small arguments (n ≤ 16). More... | |
long | regina::binomMedium (int n, int k) |
Returns the binomial coefficient n choose k in linear time for medium-sized arguments (n ≤ 29). More... | |
Cyclotomic | regina::operator* (Cyclotomic elt, const Rational &scalar) |
Multiplies the given field element by the given rational. More... | |
Cyclotomic | regina::operator* (const Rational &scalar, Cyclotomic elt) |
Multiplies the given field element by the given rational. More... | |
Cyclotomic | regina::operator/ (Cyclotomic elt, const Rational &scalar) |
Divides the given field element by the given rational. More... | |
Cyclotomic | regina::operator+ (const Cyclotomic &lhs, const Cyclotomic &rhs) |
Adds the two given cyclotomic field elements. More... | |
Cyclotomic | regina::operator+ (Cyclotomic &&lhs, const Cyclotomic &rhs) |
Adds the two given cyclotomic field elements. More... | |
Cyclotomic | regina::operator+ (const Cyclotomic &lhs, Cyclotomic &&rhs) |
Adds the two given cyclotomic field elements. More... | |
Cyclotomic | regina::operator+ (Cyclotomic &&lhs, Cyclotomic &&rhs) |
Adds the two given cyclotomic field elements. More... | |
Cyclotomic | regina::operator- (Cyclotomic arg) |
Returns the negative of the given field element. More... | |
Cyclotomic | regina::operator- (const Cyclotomic &lhs, const Cyclotomic &rhs) |
Subtracts the two given cyclotomic field elements. More... | |
Cyclotomic | regina::operator- (Cyclotomic &&lhs, const Cyclotomic &rhs) |
Subtracts the two given cyclotomic field elements. More... | |
Cyclotomic | regina::operator- (const Cyclotomic &lhs, Cyclotomic &&rhs) |
Subtracts the two given cyclotomic field elements. More... | |
Cyclotomic | regina::operator- (Cyclotomic &&lhs, Cyclotomic &&rhs) |
Subtracts the two given cyclotomic field elements. More... | |
Cyclotomic | regina::operator* (const Cyclotomic &lhs, const Cyclotomic &rhs) |
Multiplies the two given cyclotomic field elements. More... | |
Cyclotomic | regina::operator/ (const Cyclotomic &lhs, const Cyclotomic &rhs) |
Divides the two given cyclotomic field elements. More... | |
template<bool supportInfinity> | |
std::ostream & | regina::operator<< (std::ostream &out, const IntegerBase< supportInfinity > &i) |
Writes the given integer to the given output stream. More... | |
template<bool supportInfinity> | |
IntegerBase< supportInfinity > | regina::operator+ (long lhs, const IntegerBase< supportInfinity > &rhs) |
Adds the given native integer to the given large integer. More... | |
template<bool supportInfinity> | |
IntegerBase< supportInfinity > | regina::operator* (long lhs, const IntegerBase< supportInfinity > &rhs) |
Multiplies the given native integer with the given large integer. More... | |
template<int bytes> | |
std::ostream & | regina::operator<< (std::ostream &out, const NativeInteger< bytes > &i) |
Writes the given integer to the given output stream. More... | |
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. More... | |
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. More... | |
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. More... | |
template<typename T > | |
Laurent< T > | regina::operator+ (const Laurent< T > &lhs, const Laurent< T > &rhs) |
Adds the two given polynomials. More... | |
template<typename T > | |
Laurent< T > | regina::operator+ (Laurent< T > &&lhs, const Laurent< T > &rhs) |
Adds the two given polynomials. More... | |
template<typename T > | |
Laurent< T > | regina::operator+ (const Laurent< T > &lhs, Laurent< T > &&rhs) |
Adds the two given polynomials. More... | |
template<typename T > | |
Laurent< T > | regina::operator+ (Laurent< T > &&lhs, Laurent< T > &&rhs) |
Adds the two given polynomials. More... | |
template<typename T > | |
Laurent< T > | regina::operator- (Laurent< T > arg) |
Returns the negative of the given polynomial. More... | |
template<typename T > | |
Laurent< T > | regina::operator- (const Laurent< T > &lhs, const Laurent< T > &rhs) |
Subtracts the two given polynomials. More... | |
template<typename T > | |
Laurent< T > | regina::operator- (Laurent< T > &&lhs, const Laurent< T > &rhs) |
Subtracts the two given polynomials. More... | |
template<typename T > | |
Laurent< T > | regina::operator- (const Laurent< T > &lhs, Laurent< T > &&rhs) |
Subtracts the two given polynomials. More... | |
template<typename T > | |
Laurent< T > | regina::operator- (Laurent< T > &&lhs, Laurent< T > &&rhs) |
Subtracts the two given polynomials. More... | |
template<typename T > | |
Laurent< T > | regina::operator* (const Laurent< T > &lhs, const Laurent< T > &rhs) |
Multiplies the two given polynomials. More... | |
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. More... | |
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. More... | |
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. More... | |
template<typename T > | |
Laurent2< T > | regina::operator+ (const Laurent2< T > &lhs, const Laurent2< T > &rhs) |
Adds the two given polynomials. More... | |
template<typename T > | |
Laurent2< T > | regina::operator+ (Laurent2< T > &&lhs, const Laurent2< T > &rhs) |
Adds the two given polynomials. More... | |
template<typename T > | |
Laurent2< T > | regina::operator+ (const Laurent2< T > &lhs, Laurent2< T > &&rhs) |
Adds the two given polynomials. More... | |
template<typename T > | |
Laurent2< T > | regina::operator+ (Laurent2< T > &&lhs, Laurent2< T > &&rhs) |
Adds the two given polynomials. More... | |
template<typename T > | |
Laurent2< T > | regina::operator- (Laurent2< T > arg) |
Returns the negative of the given polynomial. More... | |
template<typename T > | |
Laurent2< T > | regina::operator- (const Laurent2< T > &lhs, const Laurent2< T > &rhs) |
Subtracts the two given polynomials. More... | |
template<typename T > | |
Laurent2< T > | regina::operator- (Laurent2< T > &&lhs, const Laurent2< T > &rhs) |
Subtracts the two given polynomials. More... | |
template<typename T > | |
Laurent2< T > | regina::operator- (const Laurent2< T > &lhs, Laurent2< T > &&rhs) |
Subtracts the two given polynomials. More... | |
template<typename T > | |
Laurent2< T > | regina::operator- (Laurent2< T > &&lhs, Laurent2< T > &&rhs) |
Subtracts the two given polynomials. More... | |
template<typename T > | |
Laurent2< T > | regina::operator* (const Laurent2< T > &lhs, const Laurent2< T > &rhs) |
Multiplies the two given polynomials. More... | |
void | regina::smithNormalForm (MatrixInt &matrix) |
Transforms the given integer matrix into Smith normal form. More... | |
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. More... | |
void | regina::metricalSmithNormalForm (MatrixInt &matrix, MatrixInt *rowSpaceBasis=0, MatrixInt *rowSpaceBasisInv=0, MatrixInt *colSpaceBasis=0, MatrixInt *colSpaceBasisInv=0) |
An alternative Smith normal form algorithm that also returns change of basis matrices. More... | |
unsigned | regina::rowBasis (MatrixInt &matrix) |
Find a basis for the row space of the given matrix. More... | |
unsigned | 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. More... | |
void | regina::columnEchelonForm (MatrixInt &M, MatrixInt &R, MatrixInt &Ri, const std::vector< unsigned > &rowList) |
Transforms a given matrix into column echelon form with respect to a collection of rows. More... | |
std::unique_ptr< 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. More... | |
std::unique_ptr< MatrixInt > | regina::torsionAutInverse (const MatrixInt &input, const std::vector< Integer > &invF) |
Given an automorphism of an abelian group, this procedure computes the inverse automorphism. More... | |
long | regina::reducedMod (long k, long modBase) |
Reduces k modulo modBase to give the smallest possible absolute value. More... | |
long | regina::gcd (long a, long b) |
Calculates the greatest common divisor of two signed integers. More... | |
long | regina::gcdWithCoeffs (long a, long b, long &u, long &v) |
Calculates the greatest common divisor of two given integers and finds the smallest coefficients with which these integers combine to give their gcd. More... | |
long | regina::lcm (long a, long b) |
Calculates the lowest common multiple of two signed integers. More... | |
unsigned long | regina::modularInverse (unsigned long n, unsigned long k) |
Calculates the multiplicative inverse of one integer modulo another. More... | |
constexpr char | regina::digit (int i) |
Returns the character used to express the integer i in a permutation. More... | |
constexpr int64_t | regina::factorial (int n) |
Returns the factorial of n. More... | |
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. More... | |
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. More... | |
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. More... | |
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. More... | |
template<typename T > | |
Polynomial< T > | regina::operator+ (const Polynomial< T > &lhs, const Polynomial< T > &rhs) |
Adds the two given polynomials. More... | |
template<typename T > | |
Polynomial< T > | regina::operator+ (Polynomial< T > &&lhs, const Polynomial< T > &rhs) |
Adds the two given polynomials. More... | |
template<typename T > | |
Polynomial< T > | regina::operator+ (const Polynomial< T > &lhs, Polynomial< T > &&rhs) |
Adds the two given polynomials. More... | |
template<typename T > | |
Polynomial< T > | regina::operator+ (Polynomial< T > &&lhs, Polynomial< T > &&rhs) |
Adds the two given polynomials. More... | |
template<typename T > | |
Polynomial< T > | regina::operator- (Polynomial< T > arg) |
Returns the negative of the given polynomial. More... | |
template<typename T > | |
Polynomial< T > | regina::operator- (const Polynomial< T > &lhs, const Polynomial< T > &rhs) |
Subtracts the two given polynomials. More... | |
template<typename T > | |
Polynomial< T > | regina::operator- (Polynomial< T > &&lhs, const Polynomial< T > &rhs) |
Subtracts the two given polynomials. More... | |
template<typename T > | |
Polynomial< T > | regina::operator- (const Polynomial< T > &lhs, Polynomial< T > &&rhs) |
Subtracts the two given polynomials. More... | |
template<typename T > | |
Polynomial< T > | regina::operator- (Polynomial< T > &&lhs, Polynomial< T > &&rhs) |
Subtracts the two given polynomials. More... | |
template<typename T > | |
Polynomial< T > | regina::operator* (const Polynomial< T > &lhs, const Polynomial< T > &rhs) |
Multiplies the two given polynomials. More... | |
template<typename T > | |
Polynomial< T > | regina::operator/ (Polynomial< T > lhs, const Polynomial< T > &rhs) |
Divides the two given polynomials. More... | |
std::ostream & | regina::operator<< (std::ostream &out, const Rational &rat) |
Writes the given rational to the given output stream. More... | |
template<class T > | |
std::ostream & | regina::operator<< (std::ostream &out, const Vector< T > &vector) |
Writes the given vector to the given output stream. More... | |
Variables | |
const double | regina::epsilon |
Deprecated constant for managing floating-point roundoff errors. More... | |
const int *const | regina::detail::binomSmall_ [17] |
A lookup table that stores (n choose k) for all n ≤ 16. More... | |
static T | regina::Vector< T >::zero |
Zero in the underlying number system. More... | |
static T | regina::Vector< T >::one |
One in the underlying number system. More... | |
static T | regina::Vector< T >::minusOne |
Negative one in the underlying number system. More... | |
Underlying mathematical gruntwork.
typedef IntegerBase<false> regina::Integer |
Integer is a typedef for IntegerBase<false>, which offers arbitrary precision integers without support for infinity.
typedef IntegerBase<true> regina::LargeInteger |
LargeInteger is a typedef for IntegerBase<true>, which offers arbitrary precision integers with support for infinity.
using regina::MatrixIntDomain = typedef Matrix<T, true> |
Deprecated typedef for backward compatibility.
This typedef will be removed in a future release of Regina.
using regina::MatrixRing = typedef Matrix<T, true> |
Deprecated typedef for backward compatibility.
This typedef will be removed in a future release of Regina.
true
. typedef Cyclotomic regina::NCyclotomic |
Deprecated typedef for backward compatibility.
This typedef will be removed in a future release of Regina.
typedef Integer regina::NInteger |
Deprecated typedef for backward compatibility.
This typedef will be removed in a future release of Regina.
typedef LargeInteger regina::NLargeInteger |
Deprecated typedef for backward compatibility.
This typedef will be removed in a future release of Regina.
using regina::NMatrix = typedef Matrix<T, false> |
Deprecated typedef for backward compatibility.
This typedef will be removed in a future release of Regina.
typedef MatrixInt regina::NMatrixInt |
Deprecated typedef for backward compatibility.
This typedef will be removed in a future release of Regina.
using regina::NMatrixRing = typedef Matrix<T, true> |
Deprecated typedef for backward compatibility.
This typedef will be removed in a future release of Regina.
true
. using regina::NNativeInteger = typedef NativeInteger<bytes> |
Deprecated typedef for backward compatibility.
This typedef will be removed in a future release of Regina.
typedef NativeInteger<sizeof(long)> regina::NNativeLong |
NNativeLong is a typedef for the NativeInteger template class whose underlying integer type is a native long.
using regina::NPerm = typedef Perm<n> |
Deprecated typedef for backward compatibility.
This typedef will be removed in a future release of Regina.
typedef Perm<2> regina::NPerm2 |
Deprecated typedef for backward compatibility.
This typedef will be removed in a future release of Regina.
typedef Perm<3> regina::NPerm3 |
Deprecated typedef for backward compatibility.
This typedef will be removed in a future release of Regina.
typedef Perm<4> regina::NPerm4 |
Deprecated typedef for backward compatibility.
This typedef will be removed in a future release of Regina.
typedef Perm<5> regina::NPerm5 |
Deprecated typedef for backward compatibility.
This typedef will be removed in a future release of Regina.
using regina::NPolynomial = typedef Polynomial<T> |
Deprecated typedef for backward compatibility.
This typedef will be removed in a future release of Regina.
typedef Primes regina::NPrimes |
Deprecated typedef for backward compatibility.
This typedef will be removed in a future release of Regina.
typedef Rational regina::NRational |
Deprecated typedef for backward compatibility.
This typedef will be removed in a future release of Regina.
typedef Ray regina::NRay |
Deprecated typedef for backward compatibility.
This typedef will be removed in a future release of Regina.
using regina::NVector = typedef Vector<T> |
Deprecated typedef for backward compatibility.
This typedef will be removed in a future release of Regina.
long regina::binomMedium | ( | int | n, |
int | k | ||
) |
Returns the binomial coefficient n choose k in linear time for medium-sized arguments (n ≤ 29).
This routine computes the binomial coefficient using the standard formula. It works entirely with native long integers; the constraint n ≤ 29 is designed to avoid overflow (since all intermediate results are guaranteed to stay below 2^31).
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).
n | the parameter n in (n choose k); this must be between 0 and 29 inclusive. |
k | the parameter k in (n choose k); this must be between 0 and n inclusive. |
|
inline |
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.
If you need a compile-time constant, you should use the constant FaceNumbering<n-1, k-1>::nFaces instead. This function is provided for situations where n and/or k are not known until runtime.
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< unsigned > & | rowList | ||
) |
Transforms a given matrix into column echelon form with respect to a collection of rows.
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:
original_M * R = final_M
and final_M * Ri = original_M
(and of course final_M
is in column echelon form with respect to the given row list).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.
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. The integers may appear in any order (though changing the order will change the resulting column echelon form). |
|
inline |
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. |
|
inline |
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 | ||
) |
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. |
long regina::gcdWithCoeffs | ( | long | a, |
long | b, | ||
long & | u, | ||
long & | v | ||
) |
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, the values placed in u and v will be those for which u*a + v*b = d
, -abs(a)/d < v*sign(b) <= 0
and 1 <= u*sign(a) <= abs(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.
a | one of the integers to work with. |
b | the other integer with which to work. |
u | a variable into which the final coefficient of a will be placed. |
v | a variable into which the final coefficient of b will be placed. |
|
inline |
Deprecated routine for managing floating-point roundoff errors.
Determines whether the given real number is strictly negative. Any number within regina::epsilon of zero is considered to be zero.
x | the number to examine. |
true
if and only if the given number is strictly negative.
|
inline |
Deprecated routine for managing floating-point roundoff errors.
Determines whether the given real number is non-negative. Any number within regina::epsilon of zero is considered to be zero.
x | the number to examine. |
true
if and only if the given number is non-negative.
|
inline |
Deprecated routine for managing floating-point roundoff errors.
Determines whether the given real number is non-positive. Any number within regina::epsilon of zero is considered to be zero.
x | the number to examine. |
true
if and only if the given number is non-positive.
|
inline |
Deprecated routine for managing floating-point roundoff errors.
Determines whether the given real number is non-zero. Any number within regina::epsilon of zero is considered to be zero.
x | the number to examine. |
true
if and only if the given number is approximately non-zero.
|
inline |
Deprecated routine for managing floating-point roundoff errors.
Determines whether the given real number is strictly positive. Any number within regina::epsilon of zero is considered to be zero.
x | the number to examine. |
true
if and only if the given number is strictly positive.
|
inline |
Deprecated routine for managing floating-point roundoff errors.
Determines whether the given real number is zero. Any number within regina::epsilon of zero is considered to be zero.
x | the number to examine. |
true
if and only if the given number is approximately zero. long regina::lcm | ( | long | a, |
long | b | ||
) |
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 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 = 0 , |
||
MatrixInt * | rowSpaceBasisInv = 0 , |
||
MatrixInt * | colSpaceBasis = 0 , |
||
MatrixInt * | colSpaceBasisInv = 0 |
||
) |
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), if passed, will be refilled, though they must be constructed with the correct dimensions as seen in the preconditions below. 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.
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). This is optional; you may pass a null pointer instead. |
rowSpaceBasisInv | used to return the inverse of rowSpaceBasis. This is optional; you may pass a null pointer instead. |
colSpaceBasis | used to return a change of basis matrix (see above for details). This is optional; you may pass a null pointer instead. |
colSpaceBasisInv | used to return the inverse of colSpaceBasis. This is optional; you may pass a null pointer instead. |
unsigned long regina::modularInverse | ( | unsigned long | n, |
unsigned long | k | ||
) |
Calculates the multiplicative inverse of one integer modulo another.
The inverse returned will be between 0 and n-1 inclusive.
n | the modular base in which to work. |
k | the number whose multiplicative inverse should be found. |
k * v == 1 (mod n)
.
|
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 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 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. |
|
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 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 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 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 Polynomial<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 Polynomial<T>::Coefficient here to assist with C++ template type matching.
scalar | the scalar to multiply by. |
poly | the polynomial to multiply by. |
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. |
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 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 |
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.
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 cyclotomic field elements.
lhs | the first field element to add. |
rhs | the second field element 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 cyclotomic field elements.
lhs | the first field element to add. |
rhs | the second field element 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. |
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 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 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. |
Returns the negative of the given polynomial.
arg | the polynomial 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. |
|
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. |
|
inline |
Returns the negative of the given field element.
arg | the field element to negate. |
|
inline |
Subtracts the two given cyclotomic field elements.
lhs | the field element to subtract from. |
rhs | the field element to subtract. |
Returns the negative of the given polynomial.
arg | the polynomial to negate. |
|
inline |
Subtracts the two given cyclotomic field elements.
lhs | the field element to subtract from. |
rhs | the field element 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. |
|
inline |
Returns the negative of the given polynomial.
arg | the polynomial to negate. |
|
inline |
Subtracts the two given cyclotomic field elements.
lhs | the field element to subtract from. |
rhs | the field element to subtract. |
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. |
|
inline |
Subtracts the two given cyclotomic field elements.
lhs | the field element to subtract from. |
rhs | the field element to subtract. |
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. |
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- | ( | 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. |
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. |
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 |
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 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 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 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. |
|
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 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. |
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. |
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. |
|
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 3 and 16 inclusive. |
std::ostream& regina::operator<< | ( | std::ostream & | out, |
const IntegerBase< supportInfinity > & | 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 integer to the given output stream.
out | the output stream to which to write. |
i | the integer to write. |
std::unique_ptr<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.
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.
k | the number to reduce modulo modBase. |
modBase | the modular base in which to work. |
unsigned 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.
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. |
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, though they must be constructed with the correct dimensions as seen in the preconditions below. 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.
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. |
std::unique_ptr<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
.
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. |
const int* const regina::detail::binomSmall_[17] |
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.
const double regina::epsilon |
Deprecated constant for managing floating-point roundoff errors.
A very small positive real designed to accommodate for rounding error. Any two numbers within epsilon of each other are considered to be equal by the generic zero-testing and sign-testing routines defined in this file (isZero(), isPositive(), isNonNegative() and so on).
|
static |
Negative one in the underlying number system.
This would be const
if it weren't for the fact that some compilers don't like this. It should never be modified!
|
static |
One in the underlying number system.
This would be const
if it weren't for the fact that some compilers don't like this. It should never be modified!
|
static |
Zero in the underlying number system.
This would be const
if it weren't for the fact that some compilers don't like this. It should never be modified!