/usr/include/boost/histogram/detail
Edit: /usr/include/boost/histogram/detail/linearize.hpp (4482B)
// Copyright 2019 Hans Dembinski
//
// Distributed under the Boost Software License, Version 1.0.
// (See accompanying file LICENSE_1_0.txt
// or copy at http://www.boost.org/LICENSE_1_0.txt)
#ifndef BOOST_HISTOGRAM_DETAIL_LINEARIZE_HPP
#define BOOST_HISTOGRAM_DETAIL_LINEARIZE_HPP
#include
#include
#include
#include
#include
#include
#include
namespace boost {
namespace histogram {
namespace detail {
// initial offset to out must be set
template
std::size_t linearize(Opts, Index& out, const std::size_t stride,
const axis::index_type size, const axis::index_type idx) {
constexpr bool u = Opts::test(axis::option::underflow);
constexpr bool o = Opts::test(axis::option::overflow);
// must be non-const to avoid if constexpr warning from msvc
bool fast_track = std::is_same::value || (u && o);
if (fast_track) {
assert(idx >= (u ? -1 : 0));
assert(idx < (o ? size + 1 : size));
assert(idx >= 0 || static_cast(-idx * stride) <= out);
out += idx * stride;
} else {
assert(idx >= -1);
assert(idx < size + 1);
// must be non-const to avoid if constexpr warning from msvc
bool is_valid = (u || idx >= 0) && (o || idx < size);
if (is_valid)
out += idx * stride;
else
out = invalid_index;
}
return size + u + o;
}
template
std::size_t linearize(Index& out, const std::size_t stride, const Axis& ax,
const Value& v) {
// mask options to reduce no. of template instantiations
constexpr auto opts = axis::traits::get_options{} &
(axis::option::underflow | axis::option::overflow);
return linearize(opts, out, stride, ax.size(), axis::traits::index(ax, v));
}
// initial offset of out must be zero
template
std::size_t linearize_growth(Index& out, axis::index_type& shift,
const std::size_t stride, Axis& a, const Value& v) {
axis::index_type idx;
std::tie(idx, shift) = axis::traits::update(a, v);
constexpr bool u = axis::traits::get_options::test(axis::option::underflow);
if (u) ++idx;
if (std::is_same::value) {
assert(idx < axis::traits::extent(a));
out += idx * stride;
} else {
if (0 <= idx && idx < axis::traits::extent(a))
out += idx * stride;
else
out = invalid_index;
}
return axis::traits::extent(a);
}
// initial offset of out must be zero
template
std::size_t linearize_index(optional_index& out, const std::size_t stride, const A& ax,
const axis::index_type idx) noexcept {
const auto opt = axis::traits::get_options();
const axis::index_type begin = opt & axis::option::underflow ? -1 : 0;
const axis::index_type end = opt & axis::option::overflow ? ax.size() + 1 : ax.size();
const axis::index_type extent = end - begin;
// i may be arbitrarily out of range
if (begin <= idx && idx < end)
out += (idx - begin) * stride;
else
out = invalid_index;
return extent;
}
template
optional_index linearize_indices(const A& axes, const multi_index& indices) noexcept {
assert(axes_rank(axes) == detail::size(indices));
optional_index idx{0}; // offset not used by linearize_index
auto stride = static_cast(1);
using std::begin;
auto i = begin(indices);
for_each_axis(axes,
[&](const auto& a) { stride *= linearize_index(idx, stride, a, *i++); });
return idx;
}
template
std::size_t linearize(Index& o, const std::size_t s, const axis::variant& a,
const Value& v) {
return axis::visit([&o, &s, &v](const auto& a) { return linearize(o, s, a, v); }, a);
}
template
std::size_t linearize_growth(Index& o, axis::index_type& sh, const std::size_t st,
axis::variant& a, const Value& v) {
return axis::visit([&](auto& a) { return linearize_growth(o, sh, st, a, v); }, a);
}
} // namespace detail
} // namespace histogram
} // namespace boost
#endif // BOOST_HISTOGRAM_DETAIL_LINEARIZE_HPP