range.hpp

Go to the documentation of this file.

#pragma once
 
// Templated Range<T> — represents a [start, end) interval with set operations.
 
#include <algorithm>
#include <cmath>
#include <optional>
#include <type_traits>
 
namespace pulp::runtime {
 
template<typename T>
struct Range {
    T start{};
    T end{};
 
    constexpr Range() = default;
    constexpr Range(T s, T e) : start(s), end(e) {}

    constexpr T length() const { return end - start; }

    constexpr bool empty() const { return start >= end; }

    constexpr bool contains(T value) const { return value >= start && value < end; }

    constexpr bool contains(const Range& other) const {
        return other.start >= start && other.end <= end;
    }

    constexpr bool intersects(const Range& other) const {
        return start < other.end && other.start < end;
    }

    constexpr Range intersection(const Range& other) const {
        T s = std::max(start, other.start);
        T e = std::min(end, other.end);
        return (s < e) ? Range(s, e) : Range{};
    }

    constexpr Range enclosing_union(const Range& other) const {
        if (empty()) return other;
        if (other.empty()) return *this;
        return Range(std::min(start, other.start), std::max(end, other.end));
    }

    constexpr T constrain(T value) const {
        if (end <= start) return start;
        if constexpr (std::is_integral_v<T>) {
            return std::clamp(value, start, end - T(1));
        } else {
            return std::clamp(value, start, std::nextafter(end, start));
        }
    }

    constexpr Range expanded(T value) const {
        if (empty()) return Range(value, value + T(1));
        return Range(std::min(start, value), std::max(end, value + T(1)));
    }
 
    constexpr bool operator==(const Range& other) const {
        return start == other.start && end == other.end;
    }
    constexpr bool operator!=(const Range& other) const { return !(*this == other); }

    static constexpr Range from_start_length(T s, T len) { return Range(s, s + len); }
};
 
// Common type aliases
using IntRange = Range<int>;
using FloatRange = Range<float>;
using DoubleRange = Range<double>;
using SizeRange = Range<size_t>;
 
}  // namespace pulp::runtime