│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │ -
5#ifndef DUNE_QUADMATH_HH
│ │ │ │ -
6#define DUNE_QUADMATH_HH
│ │ │ │ +
5#ifndef DUNE_ITERATORFACADES_HH
│ │ │ │ +
6#define DUNE_ITERATORFACADES_HH
│ │ │ │
│ │ │ │ -
│ │ │ │ -
│ │ │ │ +
│ │ │ │ +
│ │ │ │
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
38 using float128_t = __float128;
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
43 float128_t value_ = 0.0q;
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
46 constexpr Float128() =
default;
│ │ │ │ -
47 constexpr Float128(
const float128_t& value) noexcept
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
53 std::enable_if_t<std::is_arithmetic<T>::value,
int> = 0>
│ │ │ │ -
54 constexpr Float128(
const T& value) noexcept
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
59 explicit Float128(
const char* str) noexcept
│ │ │ │ -
60 : value_(strtoflt128(str, NULL))
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
64 constexpr operator float128_t() const noexcept {
return value_; }
│ │ │ │ -
│ │ │ │ -
66 constexpr float128_t
const& value() const noexcept {
return value_; }
│ │ │ │ -
67 constexpr float128_t& value() noexcept {
return value_; }
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
70 template<
class CharT,
class Traits>
│ │ │ │ -
71 friend std::basic_istream<CharT, Traits>&
│ │ │ │ -
72 operator>>(std::basic_istream<CharT, Traits>& in, Float128& x)
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
77 x.value() = strtoflt128(buf.c_str(), NULL);
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
81 template<
class CharT,
class Traits>
│ │ │ │ -
82 friend std::basic_ostream<CharT, Traits>&
│ │ │ │ -
83 operator<<(std::basic_ostream<CharT, Traits>& out,
const Float128& x)
│ │ │ │ -
│ │ │ │ -
85 const std::size_t bufSize = 128;
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
88 std::string format =
"%." + std::to_string(out.precision()) +
"Q" +
│ │ │ │ -
89 ((out.flags() | std::ios_base::scientific) ?
"e" :
"f");
│ │ │ │ -
90 const int numChars = quadmath_snprintf(buf, bufSize, format.c_str(), x.value());
│ │ │ │ -
91 if (std::size_t(numChars) >= bufSize) {
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
99 constexpr Float128& operator++() noexcept { ++value_;
return *
this; }
│ │ │ │ -
100 constexpr Float128& operator--() noexcept { --value_;
return *
this; }
│ │ │ │ -
│ │ │ │ -
102 constexpr Float128 operator++(
int)
noexcept { Float128 tmp{*
this}; ++value_;
return tmp; }
│ │ │ │ -
103 constexpr Float128 operator--(
int)
noexcept { Float128 tmp{*
this}; --value_;
return tmp; }
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
106 constexpr Float128
operator+() const noexcept {
return Float128{+value_}; }
│ │ │ │ -
107 constexpr Float128
operator-() const noexcept {
return Float128{-value_}; }
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
110#define DUNE_ASSIGN_OP(OP) \
│ │ │ │ -
111 constexpr Float128& operator OP(const Float128& u) noexcept \
│ │ │ │ -
│ │ │ │ -
113 value_ OP float128_t(u); \
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
116 static_assert(true, "Require semicolon to unconfuse editors")
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
131#define DUNE_BINARY_OP(OP) \
│ │ │ │ -
132 constexpr Float128 operator OP(const Float128& t, \
│ │ │ │ -
133 const Float128& u) noexcept \
│ │ │ │ -
│ │ │ │ -
135 return Float128{float128_t(t) OP float128_t(u)}; \
│ │ │ │ -
│ │ │ │ -
137 constexpr Float128 operator OP(const float128_t& t, \
│ │ │ │ -
138 const Float128& u) noexcept \
│ │ │ │ -
│ │ │ │ -
140 return Float128{t OP float128_t(u)}; \
│ │ │ │ -
│ │ │ │ -
142 constexpr Float128 operator OP(const Float128& t, \
│ │ │ │ -
143 const float128_t& u) noexcept \
│ │ │ │ -
│ │ │ │ -
145 return Float128{float128_t(t) OP u}; \
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
148 std::enable_if_t<std::is_arithmetic<T>::value, int> = 0> \
│ │ │ │ -
149 constexpr Float128 operator OP(const T& t, \
│ │ │ │ -
150 const Float128& u) noexcept \
│ │ │ │ -
│ │ │ │ -
152 return Float128{float128_t(t) OP float128_t(u)}; \
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
155 std::enable_if_t<std::is_arithmetic<U>::value, int> = 0> \
│ │ │ │ -
156 constexpr Float128 operator OP(const Float128& t, \
│ │ │ │ -
157 const U& u) noexcept \
│ │ │ │ -
│ │ │ │ -
159 return Float128{float128_t(t) OP float128_t(u)}; \
│ │ │ │ -
│ │ │ │ -
161 static_assert(true, "Require semicolon to unconfuse editors")
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
173#define DUNE_BINARY_BOOL_OP(OP) \
│ │ │ │ -
174 constexpr bool operator OP(const Float128& t, \
│ │ │ │ -
175 const Float128& u) noexcept \
│ │ │ │ -
│ │ │ │ -
177 return float128_t(t) OP float128_t(u); \
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
180 std::enable_if_t<std::is_arithmetic<T>::value, int> = 0> \
│ │ │ │ -
181 constexpr bool operator OP(const T& t, \
│ │ │ │ -
182 const Float128& u) noexcept \
│ │ │ │ -
│ │ │ │ -
184 return float128_t(t) OP float128_t(u); \
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
187 std::enable_if_t<std::is_arithmetic<U>::value, int> = 0> \
│ │ │ │ -
188 constexpr bool operator OP(const Float128& t, \
│ │ │ │ -
189 const U& u) noexcept \
│ │ │ │ -
│ │ │ │ -
191 return float128_t(t) OP float128_t(u); \
│ │ │ │ -
│ │ │ │ -
193 static_assert(true, "Require semicolon to unconfuse editors")
│ │ │ │ -
│ │ │ │ -
195 DUNE_BINARY_BOOL_OP(==);
│ │ │ │ -
196 DUNE_BINARY_BOOL_OP(!=);
│ │ │ │ -
197 DUNE_BINARY_BOOL_OP(<);
│ │ │ │ -
198 DUNE_BINARY_BOOL_OP(>);
│ │ │ │ -
199 DUNE_BINARY_BOOL_OP(<=);
│ │ │ │ -
200 DUNE_BINARY_BOOL_OP(>=);
│ │ │ │ -
│ │ │ │ -
202#undef DUNE_BINARY_BOOL_OP
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
140 template<
class T,
class V,
class R = V&,
class D = std::ptrdiff_t>
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
201 return static_cast<DerivedType const*
>(
this)->dereference();
│ │ │ │ +
│ │ │ │ +
│ │ │ │
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
207#define DUNE_UNARY_FUNC(name,func) \
│ │ │ │ -
208 inline Float128 name(const Float128& u) noexcept \
│ │ │ │ -
│ │ │ │ -
210 return Float128{func (float128_t(u))}; \
│ │ │ │ -
│ │ │ │ -
212 static_assert(true, "Require semicolon to unconfuse editors")
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
215#define DUNE_CUSTOM_UNARY_FUNC(type,name,func) \
│ │ │ │ -
216 inline type name(const Float128& u) noexcept \
│ │ │ │ -
│ │ │ │ -
218 return (type)(func (float128_t(u))); \
│ │ │ │ -
│ │ │ │ -
220 static_assert(true, "Require semicolon to unconfuse editors")
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
223#define DUNE_BINARY_FUNC(name,func) \
│ │ │ │ -
224 inline Float128 name(const Float128& t, \
│ │ │ │ -
225 const Float128& u) noexcept \
│ │ │ │ -
│ │ │ │ -
227 return Float128{func (float128_t(t), float128_t(u))}; \
│ │ │ │ -
│ │ │ │ -
229 static_assert(true, "Require semicolon to unconfuse editors")
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
248 DUNE_CUSTOM_UNARY_FUNC(
int, ilogb, ilogbq);
│ │ │ │ -
│ │ │ │ -
250 DUNE_CUSTOM_UNARY_FUNC(
long long int, llrint, llrintq);
│ │ │ │ -
251 DUNE_CUSTOM_UNARY_FUNC(
long long int, llround, llroundq);
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
257 DUNE_CUSTOM_UNARY_FUNC(
long int, lrint, lrintq);
│ │ │ │ -
258 DUNE_CUSTOM_UNARY_FUNC(
long int, lround, lroundq);
│ │ │ │ -
│ │ │ │ -
260 DUNE_BINARY_FUNC(nextafter, nextafterq);
│ │ │ │ -
261 DUNE_BINARY_FUNC(pow, powq);
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
272 DUNE_CUSTOM_UNARY_FUNC(
bool, isfinite, finiteq);
│ │ │ │ -
273 DUNE_CUSTOM_UNARY_FUNC(
bool, isinf, isinfq);
│ │ │ │ -
274 DUNE_CUSTOM_UNARY_FUNC(
bool, isnan, isnanq);
│ │ │ │ -
275 DUNE_CUSTOM_UNARY_FUNC(
bool, signbit, signbitq);
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
206 return &(
static_cast<const DerivedType *
>(
this)->dereference());
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
235 template<
class T1,
class V1,
class R1,
class D,
│ │ │ │ +
236 class T2,
class V2,
class R2>
│ │ │ │ +
237 inline typename EnableIfInterOperable<T1,T2,bool>::type
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
241 if(std::is_convertible<T2,T1>::value)
│ │ │ │ +
242 return static_cast<const T1&
>(lhs).equals(
static_cast<const T2&
>(rhs));
│ │ │ │ +
│ │ │ │ +
244 return static_cast<const T2&
>(rhs).equals(
static_cast<const T1&
>(lhs));
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
257 template<
class T1,
class V1,
class R1,
class D,
│ │ │ │ +
258 class T2,
class V2,
class R2>
│ │ │ │ +
259 inline typename EnableIfInterOperable<T1,T2,bool>::type
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
263 if(std::is_convertible<T2,T1>::value)
│ │ │ │ +
264 return !
static_cast<const T1&
>(lhs).equals(
static_cast<const T2&
>(rhs));
│ │ │ │ +
│ │ │ │ +
266 return !
static_cast<const T2&
>(rhs).equals(
static_cast<const T1&
>(lhs));
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
273 template<
class T,
class V,
class R = V&,
class D = std::ptrdiff_t>
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │
│ │ │ │ -
277#undef DUNE_UNARY_FUNC
│ │ │ │ -
278#undef DUNE_CUSTOM_UNARY_FUNC
│ │ │ │ -
279#undef DUNE_BINARY_FUNC
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
283#define DUNE_BINARY_ARITHMETIC_FUNC(name,func) \
│ │ │ │ -
284 inline Float128 name(const Float128& t, \
│ │ │ │ -
285 const Float128& u) noexcept \
│ │ │ │ -
│ │ │ │ -
287 return Float128{func (float128_t(t), float128_t(u))}; \
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
290 std::enable_if_t<std::is_arithmetic<T>::value, int> = 0> \
│ │ │ │ -
291 inline Float128 name(const T& t, \
│ │ │ │ -
292 const Float128& u) noexcept \
│ │ │ │ -
│ │ │ │ -
294 return Float128{func (float128_t(t), float128_t(u))}; \
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
297 std::enable_if_t<std::is_arithmetic<U>::value, int> = 0> \
│ │ │ │ -
298 inline Float128 name(const Float128& t, \
│ │ │ │ -
299 const U& u) noexcept \
│ │ │ │ -
│ │ │ │ -
301 return Float128{func (float128_t(t), float128_t(u))}; \
│ │ │ │ -
│ │ │ │ -
303 static_assert(true, "Require semicolon to unconfuse editors")
│ │ │ │ -
│ │ │ │ -
305 DUNE_BINARY_ARITHMETIC_FUNC(atan2,atan2q);
│ │ │ │ -
306 DUNE_BINARY_ARITHMETIC_FUNC(copysign,copysignq);
│ │ │ │ -
307 DUNE_BINARY_ARITHMETIC_FUNC(fdim,fdimq);
│ │ │ │ -
308 DUNE_BINARY_ARITHMETIC_FUNC(fmax,fmaxq);
│ │ │ │ -
309 DUNE_BINARY_ARITHMETIC_FUNC(fmin,fminq);
│ │ │ │ -
310 DUNE_BINARY_ARITHMETIC_FUNC(fmod,fmodq);
│ │ │ │ -
311 DUNE_BINARY_ARITHMETIC_FUNC(hypot,hypotq);
│ │ │ │ -
312 DUNE_BINARY_ARITHMETIC_FUNC(remainder,remainderq);
│ │ │ │ -
│ │ │ │ -
314#undef DUNE_BINARY_ARITHMETIC_FUNC
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
318 inline Float128 fma(
const Float128& t,
const Float128& u,
const Float128& v)
│ │ │ │ -
│ │ │ │ -
320 return Float128{fmaq(float128_t(t),float128_t(u),float128_t(v))};
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
323 inline Float128 frexp(
const Float128& u,
int* p)
│ │ │ │ -
│ │ │ │ -
325 return Float128{frexpq(float128_t(u), p)};
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
328 inline Float128 ldexp(
const Float128& u,
int p)
│ │ │ │ -
│ │ │ │ -
330 return Float128{ldexpq(float128_t(u), p)};
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
333 inline Float128 remquo(
const Float128& t,
const Float128& u,
int* quo)
│ │ │ │ -
│ │ │ │ -
335 return Float128{remquoq(float128_t(t), float128_t(u), quo)};
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
335 return static_cast<DerivedType const*
>(
this)->dereference();
│ │ │ │
│ │ │ │ +
│ │ │ │
│ │ │ │ -
338 inline Float128 scalbln(
const Float128& u,
long int e)
│ │ │ │ -
│ │ │ │ -
340 return Float128{scalblnq(float128_t(u), e)};
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
340 return &(
static_cast<const DerivedType *
>(
this)->dereference());
│ │ │ │
│ │ │ │ +
│ │ │ │
│ │ │ │ -
343 inline Float128 scalbn(
const Float128& u,
int e)
│ │ │ │ -
│ │ │ │ -
345 return Float128{scalbnq(float128_t(u), e)};
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
356 std::enable_if_t<std::is_integral<Int>::value,
int> = 0>
│ │ │ │ -
357 inline Float128 pow(
const Float128& x,
const Int p)
│ │ │ │ -
│ │ │ │ -
359 static const Float128
max_value = FLT128_MAX;
│ │ │ │ -
360 static const Float128
min_value = FLT128_MIN;
│ │ │ │ -
361 static const Float128 inf_value = float128_t{1} / float128_t{0};
│ │ │ │ -
│ │ │ │ -
363 const bool isneg = (x < 0);
│ │ │ │ -
364 const bool isnan = (x != x);
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
367 if (isnan) {
return x; }
│ │ │ │ -
368 if (isinf) {
return Float128{nanq(
"")}; }
│ │ │ │ -
│ │ │ │ -
370 const Float128 abs_x = (isneg ? -x : x);
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
373 return (isneg ? -inf_value : +inf_value);
│ │ │ │ -
│ │ │ │ -
375 return Float128(1) / pow(x, Int(-p));
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
378 if (p == Int(0)) {
return Float128(1); }
│ │ │ │ -
379 if (p == Int(1)) {
return x; }
│ │ │ │ -
│ │ │ │ -
381 return (isneg ? -inf_value : +inf_value);
│ │ │ │ -
│ │ │ │ -
383 if (p == Int(2)) {
return (x * x); }
│ │ │ │ -
384 if (p == Int(3)) {
return ((x * x) * x); }
│ │ │ │ -
385 if (p == Int(4)) {
const Float128 x2 = (x * x);
return (x2 * x2); }
│ │ │ │ -
│ │ │ │ -
387 Float128 result = ((p % Int(2)) != Int(0)) ? x : Float128(1);
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
391 while (Int(p2 /= 2) != Int(0)) {
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
394 const bool has_binary_power = (Int(p2 % Int(2)) != Int(0));
│ │ │ │ -
395 if (has_binary_power)
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
406 struct IsNumber<Impl::Float128>
│ │ │ │ -
407 :
public std::true_type {};
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
413#ifndef NO_STD_NUMERIC_LIMITS_SPECIALIZATION
│ │ │ │ -
│ │ │ │ -
415 class numeric_limits<
Dune::Impl::Float128>
│ │ │ │ -
│ │ │ │ -
417 using Float128 = Dune::Impl::Float128;
│ │ │ │ -
418 using float128_t = Dune::Impl::float128_t;
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
421 static constexpr bool is_specialized =
true;
│ │ │ │ -
422 static constexpr Float128
min() noexcept {
return FLT128_MIN; }
│ │ │ │ -
423 static constexpr Float128
max() noexcept {
return FLT128_MAX; }
│ │ │ │ -
424 static constexpr Float128 lowest() noexcept {
return -FLT128_MAX; }
│ │ │ │ -
425 static constexpr int digits = FLT128_MANT_DIG;
│ │ │ │ -
426 static constexpr int digits10 = 34;
│ │ │ │ -
427 static constexpr int max_digits10 = 36;
│ │ │ │ -
428 static constexpr bool is_signed =
true;
│ │ │ │ -
429 static constexpr bool is_integer =
false;
│ │ │ │ -
430 static constexpr bool is_exact =
false;
│ │ │ │ -
431 static constexpr int radix = 2;
│ │ │ │ -
432 static constexpr Float128 epsilon() noexcept {
return FLT128_EPSILON; }
│ │ │ │ -
433 static constexpr Float128 round_error() noexcept {
return float128_t{0.5}; }
│ │ │ │ -
434 static constexpr int min_exponent = FLT128_MIN_EXP;
│ │ │ │ -
435 static constexpr int min_exponent10 = FLT128_MIN_10_EXP;
│ │ │ │ -
436 static constexpr int max_exponent = FLT128_MAX_EXP;
│ │ │ │ -
437 static constexpr int max_exponent10 = FLT128_MAX_10_EXP;
│ │ │ │ -
438 static constexpr bool has_infinity =
true;
│ │ │ │ -
439 static constexpr bool has_quiet_NaN =
true;
│ │ │ │ -
440 static constexpr bool has_signaling_NaN =
false;
│ │ │ │ -
441 static constexpr float_denorm_style has_denorm = denorm_present;
│ │ │ │ -
442 static constexpr bool has_denorm_loss =
false;
│ │ │ │ -
443 static constexpr Float128 infinity() noexcept {
return float128_t{1}/float128_t{0}; }
│ │ │ │ -
444 static Float128 quiet_NaN() noexcept {
return nanq(
""); }
│ │ │ │ -
445 static constexpr Float128 signaling_NaN() noexcept {
return float128_t{}; }
│ │ │ │ -
446 static constexpr Float128 denorm_min() noexcept {
return FLT128_DENORM_MIN; }
│ │ │ │ -
447 static constexpr bool is_iec559 =
true;
│ │ │ │ -
448 static constexpr bool is_bounded =
false;
│ │ │ │ -
449 static constexpr bool is_modulo =
false;
│ │ │ │ -
450 static constexpr bool traps =
false;
│ │ │ │ -
451 static constexpr bool tinyness_before =
false;
│ │ │ │ -
452 static constexpr float_round_style round_style = round_to_nearest;
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
A few common exception classes.
│ │ │ │ -
#define DUNE_BINARY_OP(OP)
Definition debugalign.hh:261
│ │ │ │ -
#define DUNE_UNARY_FUNC(name)
│ │ │ │ -
#define DUNE_ASSIGN_OP(OP)
Definition debugalign.hh:220
│ │ │ │ -
Traits for type conversions and type information.
│ │ │ │ -
Stream & operator>>(Stream &stream, std::tuple< Ts... > &t)
Read a std::tuple.
Definition streamoperators.hh:43
│ │ │ │ -
constexpr auto max
Function object that returns the greater of the given values.
Definition hybridutilities.hh:484
│ │ │ │ -
constexpr auto min
Function object that returns the smaller of the given values.
Definition hybridutilities.hh:506
│ │ │ │ -
std::ostream & operator<<(std::ostream &s, const bigunsignedint< k > &x)
Definition bigunsignedint.hh:278
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
382 template<
class T1,
class V1,
class R1,
class D,
│ │ │ │ +
383 class T2,
class V2,
class R2>
│ │ │ │ +
384 inline typename std::enable_if<std::is_convertible<T2,T1>::value,
bool>::type
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
388 return static_cast<const T1&
>(lhs).equals(
static_cast<const T2&
>(rhs));
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
399 template<
class T1,
class V1,
class R1,
class D,
│ │ │ │ +
400 class T2,
class V2,
class R2>
│ │ │ │ +
│ │ │ │ +
402 typename std::enable_if<std::is_convertible<T1,T2>::value && !std::is_convertible<T2,T1>::value,
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
407 return static_cast<const T2&
>(rhs).equals(
static_cast<const T1&
>(lhs));
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
420 template<
class T1,
class V1,
class R1,
class D,
│ │ │ │ +
421 class T2,
class V2,
class R2>
│ │ │ │ +
422 inline typename EnableIfInterOperable<T1,T2,bool>::type
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
426 return !(lhs == rhs);
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
433 template<
class T,
class V,
class R = V&,
class D = std::ptrdiff_t>
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
503 return static_cast<DerivedType const*
>(
this)->dereference();
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
508 return &(
static_cast<const DerivedType *
>(
this)->dereference());
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
518 return static_cast<const DerivedType *
>(
this)->elementAt(n);
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
591 template<
class T1,
class V1,
class R1,
class D,
│ │ │ │ +
592 class T2,
class V2,
class R2>
│ │ │ │ +
593 inline typename EnableIfInterOperable<T1,T2,bool>::type
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
597 if(std::is_convertible<T2,T1>::value)
│ │ │ │ +
598 return static_cast<const T1&
>(lhs).equals(
static_cast<const T2&
>(rhs));
│ │ │ │ +
│ │ │ │ +
600 return static_cast<const T2&
>(rhs).equals(
static_cast<const T1&
>(lhs));
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
613 template<
class T1,
class V1,
class R1,
class D,
│ │ │ │ +
614 class T2,
class V2,
class R2>
│ │ │ │ +
615 inline typename EnableIfInterOperable<T1,T2,bool>::type
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
619 if(std::is_convertible<T2,T1>::value)
│ │ │ │ +
620 return !
static_cast<const T1&
>(lhs).equals(
static_cast<const T2&
>(rhs));
│ │ │ │ +
│ │ │ │ +
622 return !
static_cast<const T2&
>(rhs).equals(
static_cast<const T1&
>(lhs));
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
635 template<
class T1,
class V1,
class R1,
class D,
│ │ │ │ +
636 class T2,
class V2,
class R2>
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
641 if(std::is_convertible<T2,T1>::value)
│ │ │ │ +
642 return static_cast<const T1&
>(lhs).distanceTo(
static_cast<const T2&
>(rhs))>0;
│ │ │ │ +
│ │ │ │ +
644 return static_cast<const T2&
>(rhs).distanceTo(
static_cast<const T1&
>(lhs))<0;
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
658 template<
class T1,
class V1,
class R1,
class D,
│ │ │ │ +
659 class T2,
class V2,
class R2>
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
664 if(std::is_convertible<T2,T1>::value)
│ │ │ │ +
665 return static_cast<const T1&
>(lhs).distanceTo(
static_cast<const T2&
>(rhs))>=0;
│ │ │ │ +
│ │ │ │ +
667 return static_cast<const T2&
>(rhs).distanceTo(
static_cast<const T1&
>(lhs))<=0;
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
681 template<
class T1,
class V1,
class R1,
class D,
│ │ │ │ +
682 class T2,
class V2,
class R2>
│ │ │ │ +
683 inline typename EnableIfInterOperable<T1,T2,bool>::type
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
687 if(std::is_convertible<T2,T1>::value)
│ │ │ │ +
688 return static_cast<const T1&
>(lhs).distanceTo(
static_cast<const T2&
>(rhs))<0;
│ │ │ │ +
│ │ │ │ +
690 return static_cast<const T2&
>(rhs).distanceTo(
static_cast<const T1&
>(lhs))>0;
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
703 template<
class T1,
class V1,
class R1,
class D,
│ │ │ │ +
704 class T2,
class V2,
class R2>
│ │ │ │ +
705 inline typename EnableIfInterOperable<T1,T2,bool>::type
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
709 if(std::is_convertible<T2,T1>::value)
│ │ │ │ +
710 return static_cast<const T1&
>(lhs).distanceTo(
static_cast<const T2&
>(rhs))<=0;
│ │ │ │ +
│ │ │ │ +
712 return static_cast<const T2&
>(rhs).distanceTo(
static_cast<const T1&
>(lhs))>=0;
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
725 template<
class T1,
class V1,
class R1,
class D,
│ │ │ │ +
726 class T2,
class V2,
class R2>
│ │ │ │ +
727 inline typename EnableIfInterOperable<T1,T2,D>::type
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
731 if(std::is_convertible<T2,T1>::value)
│ │ │ │ +
732 return -
static_cast<const T1&
>(lhs).distanceTo(
static_cast<const T2&
>(rhs));
│ │ │ │ +
│ │ │ │ +
734 return static_cast<const T2&
>(rhs).distanceTo(
static_cast<const T1&
>(lhs));
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
748 template<
class ProxyType>
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
753 noexcept(std::is_nothrow_constructible_v<ProxyType, ProxyType&&>)
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
758 noexcept(std::is_nothrow_constructible_v<ProxyType, const ProxyType&>)
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
790 static constexpr auto baseIterator(It&& it)
noexcept
│ │ │ │ +
791 ->
decltype(it.baseIterator())
│ │ │ │ +
│ │ │ │ +
793 return it.baseIterator();
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
798 static constexpr auto derived(It&& it)
noexcept
│ │ │ │ +
799 ->
decltype(it.derived())
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
808 namespace Impl::Concepts {
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
813 struct BaseIterDereferenceOp
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
816 auto require(
const It& it) ->
decltype(
│ │ │ │ +
817 *(IteratorFacadeAccess::baseIterator(it)),
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
824 template<
class It1,
class It2>
│ │ │ │ +
825 auto require(
const It1& it1,
const It2& it2) ->
decltype(
│ │ │ │ +
826 requireConvertible<bool>(it1 == it2)
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
830 struct BaseIterEqualsOp
│ │ │ │ +
│ │ │ │ +
832 template<
class It1,
class It2>
│ │ │ │ +
833 auto require(
const It1& it1,
const It2& it2) ->
decltype(
│ │ │ │ +
834 Dune::Concept::requireConvertible<bool>(IteratorFacadeAccess::baseIterator(it1) == IteratorFacadeAccess::baseIterator(it2))
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
838 struct BaseIterIncrementOp
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
841 auto require(It it) ->
decltype(
│ │ │ │ +
842 ++(IteratorFacadeAccess::baseIterator(it))
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
846 struct BaseIterDecrementOp
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
849 auto require(It it) ->
decltype(
│ │ │ │ +
850 --(IteratorFacadeAccess::baseIterator(it))
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
858 auto require(It it) ->
decltype(
│ │ │ │ +
859 it += std::declval<D>()
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
864 struct BaseIterAdvanceOp
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
867 auto require(It it) ->
decltype(
│ │ │ │ +
868 IteratorFacadeAccess::baseIterator(it) += std::declval<D>()
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
873 struct IterDistanceOp
│ │ │ │ +
│ │ │ │ +
875 template<
class It1,
class It2>
│ │ │ │ +
876 auto require(
const It1& it1,
const It2& it2) ->
decltype(
│ │ │ │ +
877 Dune::Concept::requireConvertible<D>(it1 - it2)
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
882 struct BaseIterDistanceOp
│ │ │ │ +
│ │ │ │ +
884 template<
class It1,
class It2>
│ │ │ │ +
885 auto require(
const It1& it1,
const It2& it2) ->
decltype(
│ │ │ │ +
886 Dune::Concept::requireConvertible<D>(IteratorFacadeAccess::baseIterator(it1) - IteratorFacadeAccess::baseIterator(it2))
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
1051 template<
class It,
class C,
class V,
class R = V&,
class P = V*,
class D = std::ptrdiff_t>
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
1054 static constexpr bool isBidirectional = std::is_convertible_v<C, std::bidirectional_iterator_tag>;
│ │ │ │ +
1055 static constexpr bool isRandomAccess = std::is_convertible_v<C, std::random_access_iterator_tag>;
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
1097 static_assert(std::is_signed_v<difference_type>,
│ │ │ │ +
1098 "Type used as difference_type must be signed");
│ │ │ │ +
│ │ │ │ +
1100 static_assert(std::is_convertible_v<
decltype(*constDerived),
reference>,
│ │ │ │ +
1101 "Derived class does not implement `*it` or `*(it.baseIterator())` for const `it` required by IteratorFacade<..., std::forward_iterator_tag, ...>.");
│ │ │ │ +
│ │ │ │ +
1103 "Derived class does not implement `++it`, `++(it.baseIterator())`, or `it+=1` for mutable `it` required by IteratorFacade<..., std::forward_iterator_tag, ...>.");
│ │ │ │ +
1104 static_assert(std::is_convertible_v<
decltype(constDerived==constDerived),
bool>,
│ │ │ │ +
1105 "Derived class does not implement `it1==it2` or `it1.baseIterator()==it2.baseIterator()` for const `it1` and `it2` required by IteratorFacade<..., std::forward_iterator_tag, ...>.");
│ │ │ │ +
1106 if constexpr (isBidirectional)
│ │ │ │ +
│ │ │ │ +
1108 "Derived class does not implement `--it`, `--(it.baseIterator())`, or `it-=1` for mutable `it` required by IteratorFacade<..., std::bidirectional_iterator_tag, ...>.");
│ │ │ │ +
1109 if constexpr (isRandomAccess)
│ │ │ │ +
│ │ │ │ +
1111 static_assert(std::is_convertible_v<decltype(derived()+=std::declval<difference_type>()),
DerivedIterator&>,
│ │ │ │ +
1112 "Derived class does not implement `it+=` or `it.baseIterator()+=` for mutable `it` required by IteratorFacade<..., std::random_access_iterator_tag, ...>.");
│ │ │ │ +
1113 static_assert(std::is_convertible_v<
decltype(constDerived-constDerived),
difference_type>,
│ │ │ │ +
1114 "Derived class does not implement `it1-it2` or `it1.baseIterator()-it2.baseIterator()` for const `it1` and `it2` required by IteratorFacade<..., std::random_access_iterator_tag, ...>.");
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
1119 constexpr decltype(
auto)
operator*()
const
│ │ │ │ +
│ │ │ │ +
1121 if constexpr (Dune::models<Impl::Concepts::BaseIterDereferenceOp<reference>,
DerivedIterator>())
│ │ │ │ +
1122 return *(IteratorFacadeAccess::baseIterator(
derived()));
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
1125 "Derived class does not implement `*it` or `*(it.baseIterator())` for const `it` required by IteratorFacade<..., std::forward_iterator_tag, ...>.");
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
1131 if constexpr (std::is_pointer_v<pointer>)
│ │ │ │ +
1132 return std::addressof(*
derived());
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
1138 constexpr decltype(
auto)
operator++()
│ │ │ │ +
│ │ │ │ +
1140 if constexpr (Dune::models<Impl::Concepts::BaseIterIncrementOp, DerivedIterator>())
│ │ │ │ +
│ │ │ │ +
1142 ++(IteratorFacadeAccess::baseIterator(
derived()));
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
1145 else if constexpr (Dune::models<Impl::Concepts::IterAdvanceOp<difference_type>,
DerivedIterator>())
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
1152 "Derived class does not implement `++it`, `++(it.baseIterator())`, or `it+=1` for mutable `it` required by IteratorFacade<..., std::forward_iterator_tag, ...>.");
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
1168 template<
bool dummy=true, std::enable_if_t<isB
idirectional and dummy,
int> =0>
│ │ │ │ +
│ │ │ │ +
1169 constexpr decltype(
auto)
operator--()
│ │ │ │ +
│ │ │ │ +
1171 if constexpr (Dune::models<Impl::Concepts::BaseIterDecrementOp, DerivedIterator>())
│ │ │ │ +
│ │ │ │ +
1173 --(IteratorFacadeAccess::baseIterator(
derived()));
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
1176 else if constexpr (Dune::models<Impl::Concepts::IterAdvanceOp<difference_type>,
DerivedIterator>())
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
1183 "Derived class does not implement `--it`, `--(it.baseIterator())`, or `it-=1` for mutable `it` required by IteratorFacade<..., std::bidirectional_iterator_tag, ...>.");
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
1191 template<
bool dummy=true, std::enable_if_t<isB
idirectional and dummy,
int> =0>
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
1206 template<
bool dummy=true, std::enable_if_t<isRandomAccess and dummy,
int> =0>
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
1217 template<
bool dummy=true, std::enable_if_t<isRandomAccess and dummy,
int> =0>
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
1220 if constexpr (Dune::models<Impl::Concepts::BaseIterAdvanceOp<difference_type>,
DerivedIterator>())
│ │ │ │ +
│ │ │ │ +
1222 IteratorFacadeAccess::baseIterator(
derived()) += n;
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
1227 "Derived class does not implement `it+=` or `it.baseIterator()+=` for mutable `it` required by IteratorFacade<..., std::random_access_iterator_tag, ...>.");
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
1235 template<
bool dummy=true, std::enable_if_t<isRandomAccess and dummy,
int> =0>
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
1248 template<
bool dummy=true, std::enable_if_t<isRandomAccess and dummy,
int> =0>
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
1260 template<
bool dummy=true, std::enable_if_t<isRandomAccess and dummy,
int> =0>
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
1282 template<
class T1,
class T2,
class C,
class V1,
class V2,
class R1,
class R2,
class P1,
class P2,
class D1,
class D2>
│ │ │ │ +
│ │ │ │ +
1283 constexpr auto operator==(
const IteratorFacade<T1,C,V1,R1,P1,D1>& it1,
const IteratorFacade<T2,C,V2,R2,P2,D2>& it2)
│ │ │ │ +
│ │ │ │ +
1285 const T1& derivedIt1 = IteratorFacadeAccess::derived(it1);
│ │ │ │ +
1286 const T2& derivedIt2 = IteratorFacadeAccess::derived(it2);
│ │ │ │ +
1287 if constexpr (Dune::models<Impl::Concepts::BaseIterEqualsOp, T1, T2>())
│ │ │ │ +
1288 return IteratorFacadeAccess::baseIterator(derivedIt1) == IteratorFacadeAccess::baseIterator(derivedIt2);
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
1291 "Derived class does not implement `it1==it2` or `it1.baseIterator()==it2.baseIterator()` for const `it1` and `it2` required by IteratorFacade<..., std::forward_iterator_tag, ...>.");
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
1301 template<
class T1,
class T2,
class C,
class V1,
class V2,
class R1,
class R2,
class P1,
class P2,
class D1,
class D2,
│ │ │ │ +
1302 std::enable_if_t< Dune::models<Impl::Concepts::IterEqualsOp,T1, T2>() ,
int> =0>
│ │ │ │ +
│ │ │ │ +
1303 constexpr bool operator!=(
const IteratorFacade<T1,C,V1,R1,P1,D1>& it1,
const IteratorFacade<T2,C,V2,R2,P2,D2>& it2)
│ │ │ │ +
│ │ │ │ +
1305 const T1& derivedIt1 = IteratorFacadeAccess::derived(it1);
│ │ │ │ +
1306 const T2& derivedIt2 = IteratorFacadeAccess::derived(it2);
│ │ │ │ +
1307 return not(derivedIt1 == derivedIt2);
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
1320 template<
class T1,
class T2,
class C,
class V1,
class V2,
class R1,
class R2,
class P1,
class P2,
class D>
│ │ │ │ +
│ │ │ │ +
1321 constexpr auto operator-(
const IteratorFacade<T1,C,V1,R1,P1,D>& it1,
const IteratorFacade<T2,C,V2,R2,P2,D>& it2)
│ │ │ │ +
│ │ │ │ +
1323 const T1& derivedIt1 = IteratorFacadeAccess::derived(it1);
│ │ │ │ +
1324 const T2& derivedIt2 = IteratorFacadeAccess::derived(it2);
│ │ │ │ +
1325 if constexpr (Dune::models<Impl::Concepts::BaseIterDistanceOp<D>,T1, T2>())
│ │ │ │ +
1326 return D(IteratorFacadeAccess::baseIterator(derivedIt1) - IteratorFacadeAccess::baseIterator(derivedIt2));
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
1329 "Derived class does not implement `it1-it2` or `it1.baseIterator()-it2.baseIterator()` for const `it1` and `it2` required by IteratorFacade<..., std::random_access_iterator_tag, ...>.");
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
1339 template<
class T1,
class T2,
class C,
class V1,
class V2,
class R1,
class R2,
class P1,
class P2,
class D1,
class D2,
│ │ │ │ +
1340 std::enable_if_t< Dune::models<Impl::Concepts::IterDistanceOp<D1>,T1, T2>() ,
int> =0>
│ │ │ │ +
│ │ │ │ +
1341 constexpr bool operator<(
const IteratorFacade<T1,C,V1,R1,P1,D1>& it1,
const IteratorFacade<T2,C,V2,R2,P2,D2>& it2)
│ │ │ │ +
│ │ │ │ +
1343 const T1& derivedIt1 = IteratorFacadeAccess::derived(it1);
│ │ │ │ +
1344 const T2& derivedIt2 = IteratorFacadeAccess::derived(it2);
│ │ │ │ +
1345 return (derivedIt1 - derivedIt2) < D1(0);
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
1355 template<
class T1,
class T2,
class C,
class V1,
class V2,
class R1,
class R2,
class P1,
class P2,
class D1,
class D2,
│ │ │ │ +
1356 std::enable_if_t< Dune::models<Impl::Concepts::IterDistanceOp<D1>,T1, T2>() ,
int> =0>
│ │ │ │ +
│ │ │ │ +
1357 constexpr bool operator<=(
const IteratorFacade<T1,C,V1,R1,P1,D1>& it1,
const IteratorFacade<T2,C,V2,R2,P2,D2>& it2)
│ │ │ │ +
│ │ │ │ +
1359 const T1& derivedIt1 = IteratorFacadeAccess::derived(it1);
│ │ │ │ +
1360 const T2& derivedIt2 = IteratorFacadeAccess::derived(it2);
│ │ │ │ +
1361 return (derivedIt1 - derivedIt2) <= D1(0);
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
1371 template<
class T1,
class T2,
class C,
class V1,
class V2,
class R1,
class R2,
class P1,
class P2,
class D1,
class D2,
│ │ │ │ +
1372 std::enable_if_t< Dune::models<Impl::Concepts::IterDistanceOp<D1>,T1, T2>() ,
int> =0>
│ │ │ │ +
│ │ │ │ +
1373 constexpr bool operator>(
const IteratorFacade<T1,C,V1,R1,P1,D1>& it1,
const IteratorFacade<T2,C,V2,R2,P2,D2>& it2)
│ │ │ │ +
│ │ │ │ +
1375 const T1& derivedIt1 = IteratorFacadeAccess::derived(it1);
│ │ │ │ +
1376 const T2& derivedIt2 = IteratorFacadeAccess::derived(it2);
│ │ │ │ +
1377 return (derivedIt1 - derivedIt2) > D1(0);
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
1387 template<
class T1,
class T2,
class C,
class V1,
class V2,
class R1,
class R2,
class P1,
class P2,
class D1,
class D2,
│ │ │ │ +
1388 std::enable_if_t< Dune::models<Impl::Concepts::IterDistanceOp<D1>,T1, T2>() ,
int> =0>
│ │ │ │ +
│ │ │ │ +
1389 constexpr bool operator>=(
const IteratorFacade<T1,C,V1,R1,P1,D1>& it1,
const IteratorFacade<T2,C,V2,R2,P2,D2>& it2)
│ │ │ │ +
│ │ │ │ +
1391 const T1& derivedIt1 = IteratorFacadeAccess::derived(it1);
│ │ │ │ +
1392 const T2& derivedIt2 = IteratorFacadeAccess::derived(it2);
│ │ │ │ +
1393 return (derivedIt1 - derivedIt2) >= D1(0);
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
Traits for type conversions and type information.
│ │ │ │ +
Infrastructure for concepts.
│ │ │ │
bigunsignedint< k > operator-(const bigunsignedint< k > &x, std::uintmax_t y)
Definition bigunsignedint.hh:542
│ │ │ │ -
bigunsignedint< k > operator+(const bigunsignedint< k > &x, std::uintmax_t y)
Definition bigunsignedint.hh:535
│ │ │ │ -
#define DUNE_THROW(E, m)
Definition exceptions.hh:218
│ │ │ │ +
EnableIfInterOperable< T1, T2, bool >::type operator<(const RandomAccessIteratorFacade< T1, V1, R1, D > &lhs, const RandomAccessIteratorFacade< T2, V2, R2, D > &rhs)
Comparison operator.
Definition iteratorfacades.hh:638
│ │ │ │ +
EnableIfInterOperable< T1, T2, bool >::type operator>(const RandomAccessIteratorFacade< T1, V1, R1, D > &lhs, const RandomAccessIteratorFacade< T2, V2, R2, D > &rhs)
Comparison operator.
Definition iteratorfacades.hh:684
│ │ │ │ +
EnableIfInterOperable< T1, T2, bool >::type operator<=(const RandomAccessIteratorFacade< T1, V1, R1, D > &lhs, const RandomAccessIteratorFacade< T2, V2, R2, D > &rhs)
Comparison operator.
Definition iteratorfacades.hh:661
│ │ │ │ +
EnableIfInterOperable< T1, T2, bool >::type operator==(const ForwardIteratorFacade< T1, V1, R1, D > &lhs, const ForwardIteratorFacade< T2, V2, R2, D > &rhs)
Checks for equality.
Definition iteratorfacades.hh:238
│ │ │ │ +
EnableIfInterOperable< T1, T2, bool >::type operator>=(const RandomAccessIteratorFacade< T1, V1, R1, D > &lhs, const RandomAccessIteratorFacade< T2, V2, R2, D > &rhs)
Comparison operator.
Definition iteratorfacades.hh:706
│ │ │ │ +
EnableIfInterOperable< T1, T2, bool >::type operator!=(const ForwardIteratorFacade< T1, V1, R1, D > &lhs, const ForwardIteratorFacade< T2, V2, R2, D > &rhs)
Checks for inequality.
Definition iteratorfacades.hh:260
│ │ │ │
│ │ │ │
Dune namespace.
Definition alignedallocator.hh:13
│ │ │ │ -
T max_value(const AlignedNumber< T, align > &val)
Definition debugalign.hh:494
│ │ │ │ -
T min_value(const AlignedNumber< T, align > &val)
Definition debugalign.hh:500
│ │ │ │ -
Default exception class for range errors.
Definition exceptions.hh:254
│ │ │ │ +
Namespace for concepts.
Definition concept.hh:34
│ │ │ │ +
constexpr bool requireConvertible()
Definition concept.hh:247
│ │ │ │ +
Base class for stl conformant forward iterators.
Definition iteratorfacades.hh:142
│ │ │ │ +
std::forward_iterator_tag iterator_category
Definition iteratorfacades.hh:146
│ │ │ │ +
V * pointer
Definition iteratorfacades.hh:149
│ │ │ │ +
DerivedType & operator++()
Preincrement operator.
Definition iteratorfacades.hh:210
│ │ │ │ +
D DifferenceType
The type of the difference between two positions.
Definition iteratorfacades.hh:191
│ │ │ │ +
R Reference
The type of the reference to the values accessed.
Definition iteratorfacades.hh:196
│ │ │ │ +
Pointer operator->() const
Definition iteratorfacades.hh:204
│ │ │ │ +
T DerivedType
The type of derived iterator.
Definition iteratorfacades.hh:176
│ │ │ │ +
V Value
The type of value accessed through the iterator.
Definition iteratorfacades.hh:181
│ │ │ │ +
typename std::remove_const< V >::type value_type
Definition iteratorfacades.hh:147
│ │ │ │ +
DerivedType operator++(int)
Postincrement operator.
Definition iteratorfacades.hh:217
│ │ │ │ +
V * Pointer
The pointer to the Value.
Definition iteratorfacades.hh:186
│ │ │ │ +
D difference_type
Definition iteratorfacades.hh:148
│ │ │ │ +
Reference operator*() const
Dereferencing operator.
Definition iteratorfacades.hh:199
│ │ │ │ +
R reference
Definition iteratorfacades.hh:150
│ │ │ │ +
Facade class for stl conformant bidirectional iterators.
Definition iteratorfacades.hh:275
│ │ │ │ +
V * pointer
Definition iteratorfacades.hh:282
│ │ │ │ +
typename std::remove_const< V >::type value_type
Definition iteratorfacades.hh:280
│ │ │ │ +
Reference operator*() const
Dereferencing operator.
Definition iteratorfacades.hh:333
│ │ │ │ +
D difference_type
Definition iteratorfacades.hh:281
│ │ │ │ +
T DerivedType
The type of derived iterator.
Definition iteratorfacades.hh:310
│ │ │ │ +
DerivedType & operator--()
Preincrement operator.
Definition iteratorfacades.hh:360
│ │ │ │ +
Pointer operator->() const
Definition iteratorfacades.hh:338
│ │ │ │ +
DerivedType & operator++()
Preincrement operator.
Definition iteratorfacades.hh:344
│ │ │ │ +
V * Pointer
The pointer to the Value.
Definition iteratorfacades.hh:320
│ │ │ │ +
R Reference
The type of the reference to the values accessed.
Definition iteratorfacades.hh:330
│ │ │ │ +
DerivedType operator++(int)
Postincrement operator.
Definition iteratorfacades.hh:351
│ │ │ │ +
std::bidirectional_iterator_tag iterator_category
Definition iteratorfacades.hh:279
│ │ │ │ +
D DifferenceType
The type of the difference between two positions.
Definition iteratorfacades.hh:325
│ │ │ │ +
DerivedType operator--(int)
Postincrement operator.
Definition iteratorfacades.hh:367
│ │ │ │ +
R reference
Definition iteratorfacades.hh:283
│ │ │ │ +
V Value
The type of value accessed through the iterator.
Definition iteratorfacades.hh:315
│ │ │ │ +
Base class for stl conformant forward iterators.
Definition iteratorfacades.hh:435
│ │ │ │ +
typename std::remove_const< V >::type value_type
Definition iteratorfacades.hh:440
│ │ │ │ +
D difference_type
Definition iteratorfacades.hh:441
│ │ │ │ +
DerivedType operator--(int)
Postdecrement operator.
Definition iteratorfacades.hh:558
│ │ │ │ +
V * pointer
Definition iteratorfacades.hh:442
│ │ │ │ +
std::random_access_iterator_tag iterator_category
Definition iteratorfacades.hh:439
│ │ │ │ +
Reference operator*() const
Dereferencing operator.
Definition iteratorfacades.hh:501
│ │ │ │ +
DerivedType & operator++()
Preincrement operator.
Definition iteratorfacades.hh:522
│ │ │ │ +
R reference
Definition iteratorfacades.hh:443
│ │ │ │ +
Pointer operator->() const
Definition iteratorfacades.hh:506
│ │ │ │ +
D DifferenceType
The type of the difference between two positions.
Definition iteratorfacades.hh:493
│ │ │ │ +
DerivedType & operator--()
Predecrement operator.
Definition iteratorfacades.hh:551
│ │ │ │ +
DerivedType & operator-=(DifferenceType n)
Definition iteratorfacades.hh:565
│ │ │ │ +
DerivedType operator+(DifferenceType n) const
Definition iteratorfacades.hh:542
│ │ │ │ +
Reference operator[](DifferenceType n) const
Get the element n positions from the current one.
Definition iteratorfacades.hh:516
│ │ │ │ +
T DerivedType
The type of derived iterator.
Definition iteratorfacades.hh:478
│ │ │ │ +
V * Pointer
The pointer to the Value.
Definition iteratorfacades.hh:488
│ │ │ │ +
DerivedType operator-(DifferenceType n) const
Definition iteratorfacades.hh:571
│ │ │ │ +
DerivedType operator++(int)
Postincrement operator.
Definition iteratorfacades.hh:529
│ │ │ │ +
V Value
The type of value accessed through the iterator.
Definition iteratorfacades.hh:483
│ │ │ │ +
DerivedType & operator+=(DifferenceType n)
Definition iteratorfacades.hh:536
│ │ │ │ +
R Reference
The type of the reference to the values accessed.
Definition iteratorfacades.hh:498
│ │ │ │ +
Helper to mimic a pointer for proxy objects.
Definition iteratorfacades.hh:750
│ │ │ │ +
constexpr ProxyArrowResult(const ProxyType &p) noexcept(std::is_nothrow_constructible_v< ProxyType, const ProxyType & >)
Definition iteratorfacades.hh:757
│ │ │ │ +
constexpr ProxyType * operator->() noexcept
Definition iteratorfacades.hh:767
│ │ │ │ +
constexpr const ProxyType * operator->() const noexcept
Definition iteratorfacades.hh:762
│ │ │ │ +
constexpr ProxyArrowResult(ProxyType &&p) noexcept(std::is_nothrow_constructible_v< ProxyType, ProxyType && >)
Definition iteratorfacades.hh:752
│ │ │ │ +
This class encapsulates access of IteratorFacade.
Definition iteratorfacades.hh:786
│ │ │ │ +
CRTP-Mixing class for stl conformant iterators of given iterator category.
Definition iteratorfacades.hh:1053
│ │ │ │ +
constexpr DerivedIterator operator--(int)
Postdecrement operator.
Definition iteratorfacades.hh:1192
│ │ │ │ +
D difference_type
Definition iteratorfacades.hh:1086
│ │ │ │ +
C iterator_category
Definition iteratorfacades.hh:1082
│ │ │ │ +
IteratorFacade()
Definition iteratorfacades.hh:1095
│ │ │ │ +
constexpr pointer operator->() const
Arrow access to members of referenced value.
Definition iteratorfacades.hh:1129
│ │ │ │ +
pointer Pointer
Definition iteratorfacades.hh:1091
│ │ │ │ +
reference Reference
Definition iteratorfacades.hh:1090
│ │ │ │ +
constexpr DerivedIterator operator+(difference_type n) const
Create iterator incremented by given value.
Definition iteratorfacades.hh:1236
│ │ │ │ +
constexpr DerivedIterator operator++(int)
Postincrement operator.
Definition iteratorfacades.hh:1156
│ │ │ │ +
constexpr DerivedIterator & derived()
Cast of *this to DerivedIterator type.
Definition iteratorfacades.hh:1074
│ │ │ │ +
It DerivedIterator
The derived iterator type.
Definition iteratorfacades.hh:1065
│ │ │ │ +
constexpr DerivedIterator & operator-=(difference_type n)
Decrement iterator by given value.
Definition iteratorfacades.hh:1249
│ │ │ │ +
constexpr decltype(auto) operator--()
Predecrement operator.
Definition iteratorfacades.hh:1169
│ │ │ │ +
R reference
Definition iteratorfacades.hh:1084
│ │ │ │ +
constexpr reference operator[](difference_type n) const
Dereference element with given offset form this iterator.
Definition iteratorfacades.hh:1207
│ │ │ │ +
constexpr const DerivedIterator & derived() const
Cast of *this to const DerivedIterator type.
Definition iteratorfacades.hh:1068
│ │ │ │ +
P pointer
Definition iteratorfacades.hh:1085
│ │ │ │ +
typename std::remove_const< V >::type value_type
Definition iteratorfacades.hh:1083
│ │ │ │ +
value_type Value
Definition iteratorfacades.hh:1089
│ │ │ │ +
constexpr decltype(auto) operator++()
Preincrement operator.
Definition iteratorfacades.hh:1138
│ │ │ │ +
difference_type DifferenceType
Definition iteratorfacades.hh:1092
│ │ │ │ +
constexpr DerivedIterator operator-(difference_type n) const
Create iterator decremented by given value.
Definition iteratorfacades.hh:1261
│ │ │ │ +
Enable typedef if two types are interoperable.
Definition typetraits.hh:81
│ │ │ │ +
template which always yields a false value
Definition typetraits.hh:124
│ │ │ │
1.9.8
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │ ├── html2text {}
│ │ │ │ │ @@ -1,15 +1,46 @@
│ │ │ │ │ dune-common 2.10
│ │ │ │ │ Loading...
│ │ │ │ │ Searching...
│ │ │ │ │ No Matches
│ │ │ │ │ * _d_u_n_e
│ │ │ │ │ * _c_o_m_m_o_n
│ │ │ │ │ -vc.hh File Reference
│ │ │ │ │ -Compatibility header for including