Contents

# Bounds

Description
bounds_t<LowerT, UpperT>
holds the lower and upper bounds of a half-open interval. It is templated to allow the different integer representations for the lower and upper bounds. The intent is to model a valid iteration space over a single dimension.
Bounds can be used to iterate over an entire extent or to restrict iteration space within an extent
Creating Bounds
Bounds can be created using full bounds_t type, but this may be tedious.
```bounds_t<int, int>(start, finish)
bounds_t<int, aligned<16>>(start, aligned<16>(finish))
bounds_t<fixed<0>, fixed<1920>>()```
It is simpler and clearer to use factory function bounds to build a bounds_t<>.
```bounds(start,finish);
bounds(start, aligned<16>(finish));
bounds(0_fixed, 1920_fixed)```
Discovering Bounds
Accessors know their valid iteraton space. Initial bounds for an accessor are set to set the lower bound to be fixed<0> and the upper bound set to the value and type of the dimension's extent as specified during construction of the n_container(fixed<>,aligned<>, or int).
To query bounds for given dimension of the accessor use template function
bounds_d<int DimensionT>(object)
.
```auto b0 = bounds_d<0>(ca);
auto b1 = bounds_d<1>(ca);
for (int y = b0.lower(); y < b0.upper(); ++y)
for (int x = b1.lower(); x < b1.upper(); ++x) {
RGBAs pixel = ca[y][x];
// …
}```
bounds_t
can participate in C++11 range-based for loops.
```for (auto y: bounds_d<0>(ca))
for (auto x: bounds_d<1>(ca)) {
RGBAs pixel = ca[y][x];
// …
}```
```for (auto y: ca.bounds_d0())
for (auto x: ca.bounds_d1()) {
RGBAs pixel = ca[y][x];
// …
}```
N-Dimensional Indexes and Bounds
To model index and bounds values over multiple dimensions, respectively the following template classes are provided:
n_index_t<…>
and
n_bounds_t<…>
. These are both variadic templates, accepting any number of arguments.
n_index
is a generator to simplify creating instances of
n_index_t
.
`n_index`
n_bounds
is a generator to simplify creating instances of
n_bounds_t
.
`n_bounds[bounds(540,1080)][bounds(960,1920)]`
Alternatively,
n_bounds_t
can be defined in terms of a
n_index_t
and
n_extent_t
.
`n_bounds(n_index, n_extent);`
Accessing Subsections
From a container's accessors, a new accessor can be created over a subsection defined by a
n_bounds_t
.
```auto ca = c.const_access();
auto subsect = ca.section(n_bounds[bounds(540, 1080)][bounds(960,1920)]);```
The effect is to restrict the results of
bounds_d<int Dimension>
on the subsection accessor.
You can create a new accessor translated to a different index space.