Loading...
Searching...
No Matches
bigunsignedint.hh
Go to the documentation of this file.
// -*- tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*-
// vi: set et ts=4 sw=2 sts=2:
// SPDX-FileCopyrightInfo: Copyright © DUNE Project contributors, see file LICENSE.md in module root
// SPDX-License-Identifier: LicenseRef-GPL-2.0-only-with-DUNE-exception
#ifndef DUNE_BIGUNSIGNEDINT_HH
#define DUNE_BIGUNSIGNEDINT_HH
#include <algorithm>
#include <bit>
#include <iostream>
#include <limits>
#include <cstdint>
#include <cstdlib>
#include <type_traits>
#include <dune/common/exceptions.hh>
#include <dune/common/hash.hh>
namespace Dune
{
#if HAVE_MPI
template<class K>
struct MPITraits;
#endif
namespace Impl {
// numeric_limits_helper provides std::numeric_limits access to the internals
// of bigunsignedint. Previously, the correct specialization of std::numeric_limits
// was a friend of bigunsignedint, but that creates problems on recent versions
// of clang with the alternative libc++ library, because that library declares the
// base template of std::numeric_limits as a class and clang subsequently complains
// if the friend declaration uses 'struct'. Unfortunately, libstdc++ uses a struct,
// making it impossible to keep clang happy for both standard libraries.
// So we move the access helper functionality into a custom struct and simply let
// the numeric_limits specialization inherit from the helper.
template<typename T>
struct numeric_limits_helper
{
protected:
static std::uint16_t& digit(T& big_unsigned_int, std::size_t i)
{
return big_unsigned_int.digit[i];
}
};
}
template<int k>
class bigunsignedint {
public:
// unsigned short is 16 bits wide, n is the number of digits needed
constexpr static int bits = std::numeric_limits<std::uint16_t>::digits;
constexpr static int n = k/bits+(k%bits!=0);
constexpr static int hexdigits = 4;
constexpr static int bitmask = 0xFFFF;
constexpr static int compbitmask = 0xFFFF0000;
constexpr static int overflowmask = 0x1;
bigunsignedint ();
template<typename Signed>
bigunsignedint (Signed x, typename std::enable_if<std::is_integral<Signed>::value && std::is_signed<Signed>::value>::type* = 0);
bigunsignedint (std::uintmax_t x);
void print (std::ostream& s) const ;
bigunsignedint<k> operator+ (const bigunsignedint<k>& x) const;
bigunsignedint<k>& operator+= (const bigunsignedint<k>& x);
bigunsignedint<k> operator- (const bigunsignedint<k>& x) const;
bigunsignedint<k>& operator-= (const bigunsignedint<k>& x);
bigunsignedint<k> operator* (const bigunsignedint<k>& x) const;
bigunsignedint<k>& operator*= (const bigunsignedint<k>& x);
bigunsignedint<k>& operator++ ();
bigunsignedint<k> operator/ (const bigunsignedint<k>& x) const;
bigunsignedint<k>& operator/= (const bigunsignedint<k>& x);
bigunsignedint<k> operator% (const bigunsignedint<k>& x) const;
bigunsignedint<k>& operator%= (const bigunsignedint<k>& x);
bigunsignedint<k> operator& (const bigunsignedint<k>& x) const;
bigunsignedint<k>& operator&= (const bigunsignedint<k>& x);
bigunsignedint<k> operator^ (const bigunsignedint<k>& x) const;
bigunsignedint<k>& operator^= (const bigunsignedint<k>& x);
bigunsignedint<k> operator| (const bigunsignedint<k>& x) const;
bigunsignedint<k>& operator|= (const bigunsignedint<k>& x);
bigunsignedint<k> operator~ () const;
bigunsignedint<k> operator<< (int i) const;
bigunsignedint<k> operator>> (int i) const;
bool operator< (const bigunsignedint<k>& x) const;
bool operator<= (const bigunsignedint<k>& x) const;
bool operator> (const bigunsignedint<k>& x) const;
bool operator>= (const bigunsignedint<k>& x) const;
bool operator== (const bigunsignedint<k>& x) const;
bool operator!= (const bigunsignedint<k>& x) const;
// operator unsigned int () const;
std::uint_least32_t touint() const;
double todouble() const;
friend class bigunsignedint<k/2>;
friend struct Impl::numeric_limits_helper< bigunsignedint<k> >;
friend int bit_width(const bigunsignedint& arg)
{
int width = bits * std::size(arg.digit);
auto it = std::rbegin(arg.digit);
do {
width -= (bits - std::bit_width(*it));
} while ((*it == 0) and ((++it) != std::rend(arg.digit)));
return width;
}
friend int countl_zero(const bigunsignedint& arg)
{
return bits*n - bit_width(arg);
}
inline friend std::size_t hash_value(const bigunsignedint& arg)
{
return hash_range(arg.digit,arg.digit + arg.n);
}
private:
std::uint16_t digit[n];
#if HAVE_MPI
friend struct MPITraits<bigunsignedint<k> >;
#endif
inline void assign(std::uintmax_t x);
} ;
// Constructors
template<int k>
bigunsignedint<k>::bigunsignedint ()
{
assign(0u);
}
template<int k>
template<typename Signed>
bigunsignedint<k>::bigunsignedint (Signed y, typename std::enable_if<std::is_integral<Signed>::value && std::is_signed<Signed>::value>::type*)
{
if (y < 0)
DUNE_THROW(Dune::Exception, "Trying to construct a Dune::bigunsignedint from a negative integer: " << y);
assign(y);
}
template<int k>
bigunsignedint<k>::bigunsignedint (std::uintmax_t x)
{
assign(x);
}
template<int k>
void bigunsignedint<k>::assign(std::uintmax_t x)
{
static const int no=std::min<int>(n, std::numeric_limits<std::uintmax_t>::digits/bits);
for(int i=0; i<no; ++i) {
digit[i] = (x&bitmask);
x=x>>bits;
}
for (unsigned int i=no; i<n; i++) digit[i]=0;
}
// export
template<int k>
inline std::uint_least32_t bigunsignedint<k>::touint () const
{
return (digit[1]<<bits)+digit[0];
}
template<int k>
inline double bigunsignedint<k>::todouble() const
{
int firstInZeroRange=n;
for(int i=n-1; i>=0; --i)
if(digit[i]!=0)
break;
else
--firstInZeroRange;
int representableDigits=std::numeric_limits<double>::digits/bits;
int lastInRepresentableRange=0;
if(representableDigits<firstInZeroRange)
lastInRepresentableRange=firstInZeroRange-representableDigits;
double val=0;
for(int i=firstInZeroRange-1; i>=lastInRepresentableRange; --i)
val =val*(1<<bits)+digit[i];
return val*(1<<(bits*lastInRepresentableRange));
}
// print
template<int k>
inline void bigunsignedint<k>::print (std::ostream& s) const
{
bool leading=false;
// print from left to right
for (int i=n-1; i>=0; i--)
for (int d=hexdigits-1; d>=0; d--)
{
// extract one hex digit
int current = (digit[i]>>(d*4))&0xF;
if (current!=0)
{
// s.setf(std::ios::noshowbase);
s << std::hex << current;
leading = false;
}
else if (!leading) s << std::hex << current;
}
if (leading) s << "0";
s << std::dec;
}
template <int k>
inline std::ostream& operator<< (std::ostream& s, const bigunsignedint<k>& x)
{
x.print(s);
return s;
}
#define DUNE_BINOP(OP) \
template <int k> \
inline bigunsignedint<k> bigunsignedint<k>::operator OP (const bigunsignedint<k> &x) const \
{ \
auto temp = *this; \
temp OP##= x; \
return temp; \
}
DUNE_BINOP(+)
DUNE_BINOP(-)
DUNE_BINOP(*)
DUNE_BINOP(/)
DUNE_BINOP(%)
DUNE_BINOP(&)
DUNE_BINOP(^)
DUNE_BINOP(|)
#undef DUNE_BINOP
template <int k>
inline bigunsignedint<k>& bigunsignedint<k>::operator+= (const bigunsignedint<k>& x)
{
std::uint_fast32_t overflow=0;
for (unsigned int i=0; i<n; i++)
{
std::uint_fast32_t sum = static_cast<std::uint_fast32_t>(digit[i]) + static_cast<std::uint_fast32_t>(x.digit[i]) + overflow;
digit[i] = sum&bitmask;
overflow = (sum>>bits)&overflowmask;
}
return *this;
}
template <int k>
inline bigunsignedint<k>& bigunsignedint<k>::operator-= (const bigunsignedint<k>& x)
{
std::int_fast32_t overflow=0;
for (unsigned int i=0; i<n; i++)
{
std::int_fast32_t diff = static_cast<std::int_fast32_t>(digit[i]) - static_cast<std::int_fast32_t>(x.digit[i]) - overflow;
if (diff>=0)
{
digit[i] = static_cast<std::uint16_t>(diff);
overflow = 0;
}
else
{
digit[i] = static_cast<std::uint16_t>(diff+bitmask+1);
overflow = 1;
}
}
return *this;
}
template <int k>
inline bigunsignedint<k>& bigunsignedint<k>::operator*= (const bigunsignedint<k>& x)
{
bigunsignedint<2*k> finalproduct(0);
for (unsigned int m=0; m<n; m++) // digit in right factor
{
bigunsignedint<2*k> singleproduct(0);
std::uint_fast32_t overflow(0);
for (unsigned int i=0; i<n; i++)
{
std::uint_fast32_t digitproduct = static_cast<std::uint_fast32_t>(digit[i])*static_cast<std::uint_fast32_t>(x.digit[m])+overflow;
singleproduct.digit[i+m] = static_cast<std::uint16_t>(digitproduct&bitmask);
overflow = (digitproduct>>bits)&bitmask;
}
finalproduct = finalproduct+singleproduct;
}
for (unsigned int i=0; i<n; i++) digit[i] = finalproduct.digit[i];
return *this;
}
template <int k>
inline bigunsignedint<k>& bigunsignedint<k>::operator++ ()
{
std::uint_fast32_t overflow=1;
for (unsigned int i=0; i<n; i++)
{
std::uint_fast32_t sum = static_cast<std::uint_fast32_t>(digit[i]) + overflow;
digit[i] = sum&bitmask;
overflow = (sum>>bits)&overflowmask;
}
return *this;
}
template <int k>
inline bigunsignedint<k>& bigunsignedint<k>::operator/= (const bigunsignedint<k>& x)
{
if(x==0)
DUNE_THROW(Dune::MathError, "division by zero!");
// better slow than nothing
bigunsignedint<k> result(0);
while (*this>=x)
{
++result;
*this -= x;
}
*this = result;
return *this;
}
template <int k>
inline bigunsignedint<k>& bigunsignedint<k>::operator%= (const bigunsignedint<k>& x)
{
// better slow than nothing
while (*this>=x)
{
*this -= x;
}
return *this;
}
template <int k>
inline bigunsignedint<k>& bigunsignedint<k>::operator&= (const bigunsignedint<k>& x)
{
for (unsigned int i=0; i<n; i++)
digit[i] = digit[i]&x.digit[i];
return *this;
}
template <int k>
inline bigunsignedint<k>& bigunsignedint<k>::operator^= (const bigunsignedint<k>& x)
{
for (unsigned int i=0; i<n; i++)
digit[i] = digit[i]^x.digit[i];
return *this;
}
template <int k>
inline bigunsignedint<k>& bigunsignedint<k>::operator|= (const bigunsignedint<k>& x)
{
for (unsigned int i=0; i<n; i++)
digit[i] = digit[i]|x.digit[i];
return *this;
}
template <int k>
inline bigunsignedint<k> bigunsignedint<k>::operator~ () const
{
bigunsignedint<k> result;
for (unsigned int i=0; i<n; i++)
result.digit[i] = ~digit[i];
return result;
}
template <int k>
inline bigunsignedint<k> bigunsignedint<k>::operator<< (int shift) const
{
bigunsignedint<k> result(0);
// multiples of bits
int j=shift/bits;
for (int i=n-1-j; i>=0; i--)
result.digit[i+j] = digit[i];
// remainder
j=shift%bits;
for (int i=n-1; i>=0; i--)
{
unsigned int temp = result.digit[i];
temp = temp<<j;
result.digit[i] = static_cast<std::uint16_t>(temp&bitmask);
temp = temp>>bits;
if (i+1<(int)n)
result.digit[i+1] = result.digit[i+1]|temp;
}
return result;
}
template <int k>
inline bigunsignedint<k> bigunsignedint<k>::operator>> (int shift) const
{
bigunsignedint<k> result(0);
// multiples of bits
int j=shift/bits;
for (unsigned int i=0; i<n-j; i++)
result.digit[i] = digit[i+j];
// remainder
j=shift%bits;
for (unsigned int i=0; i<n; i++)
{
std::uint_fast32_t temp = result.digit[i];
temp = temp<<(bits-j);
result.digit[i] = static_cast<std::uint16_t>((temp&compbitmask)>>bits);
if (i>0)
result.digit[i-1] = result.digit[i-1] | (temp&bitmask);
}
return result;
}
template <int k>
inline bool bigunsignedint<k>::operator!= (const bigunsignedint<k>& x) const
{
for (unsigned int i=0; i<n; i++)
if (digit[i]!=x.digit[i]) return true;
return false;
}
template <int k>
inline bool bigunsignedint<k>::operator== (const bigunsignedint<k>& x) const
{
return !((*this)!=x);
}
template <int k>
inline bool bigunsignedint<k>::operator< (const bigunsignedint<k>& x) const
{
for (int i=n-1; i>=0; i--)
if (digit[i]<x.digit[i]) return true;
else if (digit[i]>x.digit[i]) return false;
return false;
}
template <int k>
inline bool bigunsignedint<k>::operator<= (const bigunsignedint<k>& x) const
{
for (int i=n-1; i>=0; i--)
if (digit[i]<x.digit[i]) return true;
else if (digit[i]>x.digit[i]) return false;
return true;
}
template <int k>
inline bool bigunsignedint<k>::operator> (const bigunsignedint<k>& x) const
{
return !((*this)<=x);
}
template <int k>
inline bool bigunsignedint<k>::operator>= (const bigunsignedint<k>& x) const
{
return !((*this)<x);
}
template <int k>
inline bigunsignedint<k> operator+ (const bigunsignedint<k>& x, std::uintmax_t y)
{
bigunsignedint<k> temp(y);
return x+temp;
}
template <int k>
inline bigunsignedint<k> operator- (const bigunsignedint<k>& x, std::uintmax_t y)
{
bigunsignedint<k> temp(y);
return x-temp;
}
template <int k>
inline bigunsignedint<k> operator* (const bigunsignedint<k>& x, std::uintmax_t y)
{
bigunsignedint<k> temp(y);
return x*temp;
}
template <int k>
inline bigunsignedint<k> operator/ (const bigunsignedint<k>& x, std::uintmax_t y)
{
bigunsignedint<k> temp(y);
return x/temp;
}
template <int k>
inline bigunsignedint<k> operator% (const bigunsignedint<k>& x, std::uintmax_t y)
{
bigunsignedint<k> temp(y);
return x%temp;
}
template <int k>
inline bigunsignedint<k> operator+ (std::uintmax_t x, const bigunsignedint<k>& y)
{
bigunsignedint<k> temp(x);
return temp+y;
}
template <int k>
inline bigunsignedint<k> operator- (std::uintmax_t x, const bigunsignedint<k>& y)
{
bigunsignedint<k> temp(x);
return temp-y;
}
template <int k>
inline bigunsignedint<k> operator* (std::uintmax_t x, const bigunsignedint<k>& y)
{
bigunsignedint<k> temp(x);
return temp*y;
}
template <int k>
inline bigunsignedint<k> operator/ (std::uintmax_t x, const bigunsignedint<k>& y)
{
bigunsignedint<k> temp(x);
return temp/y;
}
template <int k>
inline bigunsignedint<k> operator% (std::uintmax_t x, const bigunsignedint<k>& y)
{
bigunsignedint<k> temp(x);
return temp%y;
}
// Forward declare type-trait for numbers
template<class T> struct IsNumber;
template <int k>
struct IsNumber<bigunsignedint<k>> : public std::true_type {};
}
namespace std
{
template<int k>
struct numeric_limits<Dune::bigunsignedint<k> >
: private Dune::Impl::numeric_limits_helper<Dune::bigunsignedint<k> > // for access to internal state of bigunsignedint
{
public:
static const bool is_specialized = true;
static Dune::bigunsignedint<k> min()
{
return static_cast<Dune::bigunsignedint<k> >(0);
}
static Dune::bigunsignedint<k> max()
{
Dune::bigunsignedint<k> max_;
for(std::size_t i=0; i < Dune::bigunsignedint<k>::n; ++i)
// access internal state via the helper base class
Dune::Impl::numeric_limits_helper<Dune::bigunsignedint<k> >::
digit(max_,i)=std::numeric_limits<std::uint16_t>::max();
return max_;
}
static const int digits = Dune::bigunsignedint<k>::bits *
Dune::bigunsignedint<k>::n;
static const bool is_signed = false;
static const bool is_integer = true;
static const bool is_exact = true;
static const int radix = 2;
static Dune::bigunsignedint<k> epsilon()
{
return static_cast<Dune::bigunsignedint<k> >(0);
}
static Dune::bigunsignedint<k> round_error()
{
return static_cast<Dune::bigunsignedint<k> >(0);
}
static const int min_exponent = 0;
static const int min_exponent10 = 0;
static const int max_exponent = 0;
static const int max_exponent10 = 0;
static const bool has_infinity = false;
static const bool has_quiet_NaN = false;
static const bool has_signaling_NaN = false;
static const float_denorm_style has_denorm = denorm_absent;
static const bool has_denorm_loss = false;
static Dune::bigunsignedint<k> infinity() noexcept
{
return static_cast<Dune::bigunsignedint<k> >(0);
}
static Dune::bigunsignedint<k> quiet_NaN() noexcept
{
return static_cast<Dune::bigunsignedint<k> >(0);
}
static Dune::bigunsignedint<k> signaling_NaN() noexcept
{
return static_cast<Dune::bigunsignedint<k> >(0);
}
static Dune::bigunsignedint<k> denorm_min() noexcept
{
return static_cast<Dune::bigunsignedint<k> >(0);
}
static const bool is_iec559 = false;
static const bool is_bounded = true;
static const bool is_modulo = true;
static const bool traps = false;
static const bool tinyness_before = false;
static const float_round_style round_style = round_toward_zero;
};
}
DUNE_DEFINE_HASH(DUNE_HASH_TEMPLATE_ARGS(int k),DUNE_HASH_TYPE(Dune::bigunsignedint<k>))
#endif
exceptions.hh
A few common exception classes.
hash.hh
Support for calculating hash values of objects.
DUNE_DEFINE_HASH
#define DUNE_DEFINE_HASH(template_args, type)
Defines the required struct specialization to make type hashable via Dune::hash.
Definition hash.hh:100
DUNE_HASH_TYPE
#define DUNE_HASH_TYPE(...)
Wrapper macro for the type to be hashed in DUNE_DEFINE_HASH.
Definition hash.hh:117
DUNE_HASH_TEMPLATE_ARGS
#define DUNE_HASH_TEMPLATE_ARGS(...)
Wrapper macro for the template arguments in DUNE_DEFINE_HASH.
Definition hash.hh:109
Dune::bigunsignedint::operator/=
bigunsignedint< k > & operator/=(const bigunsignedint< k > &x)
Definition bigunsignedint.hh:400
Dune::bigunsignedint::operator<<
bigunsignedint< k > operator<<(int i) const
left shift
Definition bigunsignedint.hh:464
Dune::bigunsignedint::operator+=
bigunsignedint< k > & operator+=(const bigunsignedint< k > &x)
Definition bigunsignedint.hh:328
Dune::bigunsignedint::operator^=
bigunsignedint< k > & operator^=(const bigunsignedint< k > &x)
Definition bigunsignedint.hh:439
Dune::operator<<
std::ostream & operator<<(std::ostream &s, const bigunsignedint< k > &x)
Definition bigunsignedint.hh:301
Dune::bigunsignedint::operator<=
bool operator<=(const bigunsignedint< k > &x) const
less than or equal
Definition bigunsignedint.hh:536
Dune::bigunsignedint::print
void print(std::ostream &s) const
Print number in hex notation.
Definition bigunsignedint.hh:278
Dune::bigunsignedint::operator<
bool operator<(const bigunsignedint< k > &x) const
less than
Definition bigunsignedint.hh:527
Dune::operator/
bigunsignedint< k > operator/(const bigunsignedint< k > &x, std::uintmax_t y)
Definition bigunsignedint.hh:579
Dune::bigunsignedint::operator==
bool operator==(const bigunsignedint< k > &x) const
equal
Definition bigunsignedint.hh:521
Dune::bigunsignedint::operator!=
bool operator!=(const bigunsignedint< k > &x) const
not equal
Definition bigunsignedint.hh:513
Dune::bigunsignedint::bigunsignedint
bigunsignedint()
Construct uninitialized.
Definition bigunsignedint.hh:220
Dune::bigunsignedint::operator&=
bigunsignedint< k > & operator&=(const bigunsignedint< k > &x)
Definition bigunsignedint.hh:431
Dune::operator-
bigunsignedint< k > operator-(const bigunsignedint< k > &x, std::uintmax_t y)
Definition bigunsignedint.hh:565
Dune::bigunsignedint::operator>=
bool operator>=(const bigunsignedint< k > &x) const
greater or equal
Definition bigunsignedint.hh:551
Dune::bigunsignedint::operator>>
bigunsignedint< k > operator>>(int i) const
right shift
Definition bigunsignedint.hh:489
Dune::operator+
bigunsignedint< k > operator+(const bigunsignedint< k > &x, std::uintmax_t y)
Definition bigunsignedint.hh:558
Dune::bigunsignedint::operator~
bigunsignedint< k > operator~() const
bitwise complement
Definition bigunsignedint.hh:455
Dune::bigunsignedint::operator++
bigunsignedint< k > & operator++()
prefix increment
Definition bigunsignedint.hh:386
Dune::bigunsignedint::operator|=
bigunsignedint< k > & operator|=(const bigunsignedint< k > &x)
Definition bigunsignedint.hh:447
Dune::operator%
bigunsignedint< k > operator%(const bigunsignedint< k > &x, std::uintmax_t y)
Definition bigunsignedint.hh:586
Dune::bigunsignedint::operator%=
bigunsignedint< k > & operator%=(const bigunsignedint< k > &x)
Definition bigunsignedint.hh:419
Dune::bigunsignedint::todouble
double todouble() const
Convert to a double.
Definition bigunsignedint.hh:259
Dune::bigunsignedint::operator-=
bigunsignedint< k > & operator-=(const bigunsignedint< k > &x)
Definition bigunsignedint.hh:342
Dune::bigunsignedint::operator>
bool operator>(const bigunsignedint< k > &x) const
greater than
Definition bigunsignedint.hh:545
Dune::bigunsignedint::operator*=
bigunsignedint< k > & operator*=(const bigunsignedint< k > &x)
Definition bigunsignedint.hh:364
Dune::bigunsignedint::touint
std::uint_least32_t touint() const
export to other types
Definition bigunsignedint.hh:253
DUNE_BINOP
#define DUNE_BINOP(OP)
Definition bigunsignedint.hh:307
DUNE_THROW
#define DUNE_THROW(E,...)
Definition exceptions.hh:314
Dune::operator*
constexpr decltype(auto) operator*() const
Dereferencing operator.
Definition iteratorfacades.hh:1119
std
STL namespace.
Dune
Dune namespace
Definition alignedallocator.hh:13
Dune::hash_range
std::size_t hash_range(It first, It last)
Hashes all elements in the range [first,last) and returns the combined hash.
Definition hash.hh:322
Dune::assign
void assign(T &dst, const T &src, bool mask)
masked Simd assignment (scalar version)
Definition simd.hh:447
Dune::MPITraits
A traits class describing the mapping of types onto MPI_Datatypes.
Definition mpitraits.hh:41
Dune::bigunsignedint
Portable very large unsigned integers.
Definition bigunsignedint.hh:74
Dune::bigunsignedint::overflowmask
static constexpr int overflowmask
Definition bigunsignedint.hh:83
Dune::bigunsignedint::operator|
bigunsignedint< k > operator|(const bigunsignedint< k > &x) const
bitwise or
Dune::bigunsignedint::hexdigits
static constexpr int hexdigits
Definition bigunsignedint.hh:80
Dune::bigunsignedint::operator^
bigunsignedint< k > operator^(const bigunsignedint< k > &x) const
bitwise exor
Dune::bigunsignedint::operator%
bigunsignedint< k > operator%(const bigunsignedint< k > &x) const
Dune::bigunsignedint::n
static constexpr int n
Definition bigunsignedint.hh:79
Dune::bigunsignedint::bit_width
friend int bit_width(const bigunsignedint &arg)
Bit width.
Definition bigunsignedint.hh:184
Dune::bigunsignedint::operator-
bigunsignedint< k > operator-(const bigunsignedint< k > &x) const
subtract
Dune::bigunsignedint::compbitmask
static constexpr int compbitmask
Definition bigunsignedint.hh:82
Dune::bigunsignedint::operator&
bigunsignedint< k > operator&(const bigunsignedint< k > &x) const
bitwise and
Dune::bigunsignedint::bits
static constexpr int bits
Definition bigunsignedint.hh:78
Dune::bigunsignedint::operator/
bigunsignedint< k > operator/(const bigunsignedint< k > &x) const
Dune::bigunsignedint::operator+
bigunsignedint< k > operator+(const bigunsignedint< k > &x) const
add
Dune::bigunsignedint::hash_value
friend std::size_t hash_value(const bigunsignedint &arg)
Definition bigunsignedint.hh:203
Dune::bigunsignedint::bitmask
static constexpr int bitmask
Definition bigunsignedint.hh:81
Dune::bigunsignedint::countl_zero
friend int countl_zero(const bigunsignedint &arg)
Count left zero bits.
Definition bigunsignedint.hh:198
Dune::IsNumber
Whether this type acts as a scalar in the context of (hierarchically blocked) containers.
Definition typetraits.hh:194
std::numeric_limits< Dune::bigunsignedint< k > >::is_iec559
static const bool is_iec559
Definition bigunsignedint.hh:711
std::numeric_limits< Dune::bigunsignedint< k > >::min_exponent
static const int min_exponent
Definition bigunsignedint.hh:679
std::numeric_limits< Dune::bigunsignedint< k > >::radix
static const int radix
Definition bigunsignedint.hh:667
std::numeric_limits< Dune::bigunsignedint< k > >::is_specialized
static const bool is_specialized
Definition bigunsignedint.hh:644
std::numeric_limits< Dune::bigunsignedint< k > >::has_quiet_NaN
static const bool has_quiet_NaN
Definition bigunsignedint.hh:685
std::numeric_limits< Dune::bigunsignedint< k > >::is_signed
static const bool is_signed
Definition bigunsignedint.hh:664
std::numeric_limits< Dune::bigunsignedint< k > >::is_integer
static const bool is_integer
Definition bigunsignedint.hh:665
std::numeric_limits< Dune::bigunsignedint< k > >::is_bounded
static const bool is_bounded
Definition bigunsignedint.hh:712
std::numeric_limits< Dune::bigunsignedint< k > >::denorm_min
static Dune::bigunsignedint< k > denorm_min() noexcept
Definition bigunsignedint.hh:706
std::numeric_limits< Dune::bigunsignedint< k > >::is_modulo
static const bool is_modulo
Definition bigunsignedint.hh:713
std::numeric_limits< Dune::bigunsignedint< k > >::digits
static const int digits
Definition bigunsignedint.hh:662
std::numeric_limits< Dune::bigunsignedint< k > >::traps
static const bool traps
Definition bigunsignedint.hh:715
std::numeric_limits< Dune::bigunsignedint< k > >::tinyness_before
static const bool tinyness_before
Definition bigunsignedint.hh:716
std::numeric_limits< Dune::bigunsignedint< k > >::min_exponent10
static const int min_exponent10
Definition bigunsignedint.hh:680
std::numeric_limits< Dune::bigunsignedint< k > >::max
static Dune::bigunsignedint< k > max()
Definition bigunsignedint.hh:651
std::numeric_limits< Dune::bigunsignedint< k > >::min
static Dune::bigunsignedint< k > min()
Definition bigunsignedint.hh:646
std::numeric_limits< Dune::bigunsignedint< k > >::epsilon
static Dune::bigunsignedint< k > epsilon()
Definition bigunsignedint.hh:669
std::numeric_limits< Dune::bigunsignedint< k > >::round_style
static const float_round_style round_style
Definition bigunsignedint.hh:717
std::numeric_limits< Dune::bigunsignedint< k > >::has_denorm_loss
static const bool has_denorm_loss
Definition bigunsignedint.hh:689
std::numeric_limits< Dune::bigunsignedint< k > >::signaling_NaN
static Dune::bigunsignedint< k > signaling_NaN() noexcept
Definition bigunsignedint.hh:701
std::numeric_limits< Dune::bigunsignedint< k > >::max_exponent10
static const int max_exponent10
Definition bigunsignedint.hh:682
std::numeric_limits< Dune::bigunsignedint< k > >::is_exact
static const bool is_exact
Definition bigunsignedint.hh:666
std::numeric_limits< Dune::bigunsignedint< k > >::has_denorm
static const float_denorm_style has_denorm
Definition bigunsignedint.hh:688
std::numeric_limits< Dune::bigunsignedint< k > >::has_signaling_NaN
static const bool has_signaling_NaN
Definition bigunsignedint.hh:686
std::numeric_limits< Dune::bigunsignedint< k > >::infinity
static Dune::bigunsignedint< k > infinity() noexcept
Definition bigunsignedint.hh:691
std::numeric_limits< Dune::bigunsignedint< k > >::max_exponent
static const int max_exponent
Definition bigunsignedint.hh:681
std::numeric_limits< Dune::bigunsignedint< k > >::quiet_NaN
static Dune::bigunsignedint< k > quiet_NaN() noexcept
Definition bigunsignedint.hh:696
std::numeric_limits< Dune::bigunsignedint< k > >::has_infinity
static const bool has_infinity
Definition bigunsignedint.hh:684
std::numeric_limits< Dune::bigunsignedint< k > >::round_error
static Dune::bigunsignedint< k > round_error()
Definition bigunsignedint.hh:674
Dune::Exception
Base class for Dune-Exceptions.
Definition exceptions.hh:98
Dune::MathError
Default exception class for mathematical errors.
Definition exceptions.hh:335
Dune::type