我想檢查 aboost::icl::right_open_interval<double> i1和 a是否boost::icl::closed_interval<double> i2有交集。不幸的是，該boost::icl::intersects(i1, i2)功能僅在i1和i2共享相同型別時才有效。我想知道
- 為什么不支持不同的區間型別，因為區間庫似乎很自然，以及
- 如果有一種很好的方法可以將上述函式推廣到不同的區間型別。
uj5u.com熱心網友回復：
有型別模型靜態間隔概念：
還有動態間隔概念，它基本上添加了運行時狀態，指示interval_bounds：
using icl::interval_bounds;
using std::is_same_v;
using I = icl::interval<double>;
using CI = I::interval_type;
auto a = I::right_open(3, M_PI);
auto b = I::closed(3.14, 5);
auto c = I::left_open(7, std::numeric_limits<double>::infinity());
for (auto lhs : {a, b, c})
for (auto rhs : {a, b, c})
std::cout << lhs << " & " << rhs << " = " << (lhs & rhs) << "" << std::endl;
印刷
[3,3.14159) & [3,3.14159) = [3,3.14159)
[3,3.14159) & [3.14,5] = [3.14,3.14159)
[3,3.14159) & (7,inf] = ()
[3.14,5] & [3,3.14159) = [3.14,3.14159)
[3.14,5] & [3.14,5] = [3.14,5]
[3.14,5] & (7,inf] = (]
(7,inf] & [3,3.14159) = ()
(7,inf] & [3.14,5] = (]
(7,inf] & (7,inf] = (7,inf]
有效型別都是一樣的：
static_assert(is_same_v<decltype(a), CI>);
static_assert(is_same_v<decltype(b), CI>);
static_assert(is_same_v<decltype(c), CI>);
static_assert(is_same_v<CI, icl::continuous_interval<double>>);
您可以將其用于您的用例：
auto i1 = icl::right_open_interval<double>(3, M_PI);
auto i2 = icl::closed_interval<double>(3.14, 5);
auto i3 = icl::left_open_interval(7.0, std::numeric_limits<double>::infinity());
如您所知，它們沒有相同的型別：
static_assert(not is_same_v<decltype(i1), decltype(i2)>);
static_assert(not is_same_v<decltype(i1), decltype(i3)>);
static_assert(not is_same_v<decltype(i2), decltype(i3)>);
存在這些靜態間隔型別，因此庫可以具有絕對最小的運行時開銷/存盤。想象一下在一個陣列中存盤一百萬個間隔。如果您知道型別，您是否真的要承擔大小開銷：
static_assert(sizeof(i1) == sizeof(i2));
static_assert(sizeof(i2) == sizeof(i3));
static_assert(sizeof(I::interval_type) == sizeof(i1) 8);
當然不是。
但是，正如您所發現的，某些操作僅針對同質運算元靜態實作。通用代碼可以找出任何給定區間型別的邊界型別：
static_assert(icl::interval_bound_type<decltype(i1)>::value == interval_bounds::static_right_open);
static_assert(icl::interval_bound_type<decltype(i2)>::value == interval_bounds::static_closed);
static_assert(icl::interval_bound_type<decltype(i3)>::value == interval_bounds::static_left_open);
static_assert(icl::interval_bound_type<CI>::value == interval_bounds::dynamic);
So, you can convert to suit your needs:
template <typename I>
auto make_dynamic(I const& in) {
static_assert(icl::is_interval<I>::value);
static_assert(icl::has_static_bounds<I>::value);
using T = icl::interval_traits<I>;
using D = typename T::domain_type;
using R = std::conditional_t<icl::is_continuous<D>::value,
icl::continuous_interval<D>,
icl::discrete_interval<D>>;
constexpr auto b = icl::interval_bound_type<I>::value;
return icl::dynamic_interval_traits<R>::construct(
T::lower(in), T::upper(in), static_cast<icl::interval_bounds>(b));
}
And then:
for (auto lhs : {make_dynamic(i1), make_dynamic(i2), make_dynamic(i3)})
for (auto rhs : {make_dynamic(i1), make_dynamic(i2), make_dynamic(i3)})
{
std::cout << lhs << " & " << rhs << " = " << (lhs & rhs) << "" << std::endl;
converted_results.push_back(lhs & rhs);
}
Prints the exact same as above:
[3,3.14159) & [3,3.14159) = [3,3.14159)
[3,3.14159) & [3.14,5] = [3.14,3.14159)
[3,3.14159) & (7,inf] = ()
[3.14,5] & [3,3.14159) = [3.14,3.14159)
[3.14,5] & [3.14,5] = [3.14,5]
[3.14,5] & (7,inf] = (]
(7,inf] & [3,3.14159) = ()
(7,inf] & [3.14,5] = (]
(7,inf] & (7,inf] = (7,inf]
Here's an applied example showing how create a mapping of intervals:
using Set = std::set<char>;
boost::icl::interval_map<double, Set> s;
s.add({a, Set{'a'}});
s.add({b, Set{'b'}});
s.add({c, Set{'c'}});
std::cout << "s: " << s << "\n";
Prints:
s: {([3,3.14)->{a })([3.14,3.14159)->{a b })([3.14159,5]->{b })((7,inf]->{c })}
See all the code Live On Coliru
Recommendation
This all looks a bit clumsy, right. Therefore I'd suggest picking a camp: dynamic bounds or static bounds.
If you really want static bounds, consider defining BOOST_ICL_USE_STATIC_BOUNDED_INTERVALS:
// If this macro is defined, right_open_interval with static interval borders
// will be used as default for all interval containers.
// BOOST_ICL_USE_STATIC_BOUNDED_INTERVALS should be defined in the application
// before other includes from the ITL
//#define BOOST_ICL_USE_STATIC_BOUNDED_INTERVALS
// If BOOST_ICL_USE_STATIC_BOUNDED_INTERVALS is NOT defined, ITL uses intervals
// with dynamic borders as default.
Note this has the effect of e.g. making interval sets/maps using right-open intervals always. See a more elaborate example: https://www.boost.org/doc/libs/1_78_0/libs/icl/doc/html/boost_icl/examples/static_interval.html, and the Interface documentation.
Listing
For future reference:
#include <boost/icl/interval_map.hpp>
#include <iostream>
namespace icl = boost::icl;
template <typename I>
auto make_dynamic(I const& in) {
static_assert(icl::is_interval<I>::value);
static_assert(icl::has_static_bounds<I>::value);
using T = icl::interval_traits<I>;
using D = typename T::domain_type;
using R = std::conditional_t<icl::is_continuous<I>::value,
icl::continuous_interval<D>,
icl::discrete_interval<D>>;
constexpr auto b = icl::interval_bound_type<I>::value;
return icl::dynamic_interval_traits<R>::construct(
T::lower(in), T::upper(in), static_cast<icl::interval_bounds>(b));
}
int main() {
using icl::interval_bounds;
using std::is_same_v;
using I = icl::interval<double>;
using CI = I::interval_type;
auto a = I::right_open(3, M_PI);
auto b = I::closed(3.14, 5);
auto c = I::left_open(7, std::numeric_limits<double>::infinity());
std::cout << "--------------" << std::endl;
std::vector<CI> dynamic_results;
for (auto lhs : {a, b, c})
for (auto rhs : {a, b, c})
{
std::cout << lhs << " & " << rhs << " = " << (lhs & rhs) << "" << std::endl;
dynamic_results.push_back(lhs & rhs);
}
static_assert(is_same_v<decltype(a), CI>);
static_assert(is_same_v<decltype(b), CI>);
static_assert(is_same_v<decltype(c), CI>);
static_assert(is_same_v<CI, icl::continuous_interval<double>>);
auto i1 = icl::right_open_interval<double>(3, M_PI);
auto i2 = icl::closed_interval<double>(3.14, 5);
auto i3 = icl::left_open_interval(7.0, std::numeric_limits<double>::infinity());
static_assert(not is_same_v<decltype(i1), decltype(i2)>);
static_assert(not is_same_v<decltype(i1), decltype(i3)>);
static_assert(not is_same_v<decltype(i2), decltype(i3)>);
static_assert(sizeof(i1) == sizeof(i2));
static_assert(sizeof(i2) == sizeof(i3));
static_assert(sizeof(I::interval_type) == sizeof(i1) 8);
static_assert(icl::interval_bound_type<decltype(i1)>::value == interval_bounds::static_right_open);
static_assert(icl::interval_bound_type<decltype(i2)>::value == interval_bounds::static_closed);
static_assert(icl::interval_bound_type<decltype(i3)>::value == interval_bounds::static_left_open);
static_assert(icl::interval_bound_type<CI>::value == interval_bounds::dynamic);
std::cout << "--------------" << std::endl;
std::vector<CI> converted_results;
for (auto lhs : {make_dynamic(i1), make_dynamic(i2), make_dynamic(i3)})
for (auto rhs : {make_dynamic(i1), make_dynamic(i2), make_dynamic(i3)})
{
std::cout << lhs << " & " << rhs << " = " << (lhs & rhs) << "" << std::endl;
converted_results.push_back(lhs & rhs);
}
assert(dynamic_results == converted_results);
using Set = std::set<char>;
boost::icl::interval_map<double, Set> s;
s.add({a, Set{'a'}});
s.add({b, Set{'b'}});
s.add({c, Set{'c'}});
std::cout << "s: " << s << "\n";
}
Prints
--------------
[3,3.14159) & [3,3.14159) = [3,3.14159)
[3,3.14159) & [3.14,5] = [3.14,3.14159)
[3,3.14159) & (7,inf] = ()
[3.14,5] & [3,3.14159) = [3.14,3.14159)
[3.14,5] & [3.14,5] = [3.14,5]
[3.14,5] & (7,inf] = (]
(7,inf] & [3,3.14159) = ()
(7,inf] & [3.14,5] = (]
(7,inf] & (7,inf] = (7,inf]
--------------
[3,3.14159) & [3,3.14159) = [3,3.14159)
[3,3.14159) & [3.14,5] = [3.14,3.14159)
[3,3.14159) & (7,inf] = ()
[3.14,5] & [3,3.14159) = [3.14,3.14159)
[3.14,5] & [3.14,5] = [3.14,5]
[3.14,5] & (7,inf] = (]
(7,inf] & [3,3.14159) = ()
(7,inf] & [3.14,5] = (]
(7,inf] & (7,inf] = (7,inf]
s: {([3,3.14)->{a })([3.14,3.14159)->{a b })([3.14159,5]->{b })((7,inf]->{c })}
轉載請註明出處，本文鏈接：https://www.uj5u.com/gongcheng/438911.html