Interval.hpp

浏览该文件的文档.

 
 
#pragma once
 
#include "AstGlobal.h"
#include "DoubleRange.hpp"
#include "AstUtil/Logger.hpp"
#include "AstUtil/Math.hpp"
#include <cstddef>
#include <cmath>
#include <limits>
 
AST_NAMESPACE_BEGIN
 
class Interval
{
public:
    static Interval Empty();
public:
    double start() const{return start_;}
    double stop() const{return stop_;}
    double& start() {return start_;}
    double& stop() {return stop_;}
    double duration() const{return stop_ - start_;}
public:
    bool isEmpty() const { return !(start_ <= stop_); }
    bool isPoint() const { return start_ == stop_; }
    bool isDegenerate() const { return isPoint(); }
    bool isValid() const { return start_ <= stop_; }
    bool isNonEmpty() const { return isValid(); }
    bool contains(double t) const { return start_ <= t && t <= stop_; }
public:
    void setBounds(double start, double stop);
 
    void setEmpty();
 
    void setWhole();
public:
    DoubleRange discretize(double step) const;
 
    size_t discretizedCount(double step) const;
 
 
    Interval& unite(const Interval& other);
 
    Interval united(const Interval& other) const;
 
    Interval& intersect(const Interval& other);
 
    Interval intersected(const Interval& other) const;
 
    bool intersects(const Interval& other) const;
 
    Interval& operator|=(const Interval& other) { return unite(other); }
 
    Interval operator|(const Interval& other) const { return united(other); }
 
    Interval& operator&=(const Interval& other) { return intersect(other); }
 
    Interval operator&(const Interval& other) const { return intersected(other); }
public:
    double start_;
    double stop_;
};
 
inline Interval Interval::Empty()
{
    return Interval{+(std::numeric_limits<double>::infinity()),
                    -(std::numeric_limits<double>::infinity()) }; 
}
 
inline void Interval::setBounds(double start, double stop)
{
    start_ = start;
    stop_ = stop;
}
 
inline void Interval::setEmpty()
{
    start_ = +std::numeric_limits<double>::infinity();
    stop_  = -std::numeric_limits<double>::infinity();
}
 
inline void Interval::setWhole()
{
    start_ = -std::numeric_limits<double>::infinity();
    stop_  = +std::numeric_limits<double>::infinity();
}
 
inline Interval& Interval::unite(const Interval &other)
{
    start_ = (std::min)(start_, other.start());
    stop_  = (std::max)(stop_,  other.stop());
    return *this;
}
 
inline Interval Interval::united(const Interval &other) const
{
    return Interval{(std::min)(start_, other.start()),
                    (std::max)(stop_,  other.stop())};
}
 
inline Interval& Interval::intersect(const Interval &other)
{
    double s = (propagate_nan::max)(start_, other.start_);
    double t = (propagate_nan::min)(stop_,  other.stop());
    if (!(s <= t)) {
        *this = Empty();   // 不相交 → 规范空区间（不钳回假点）
    } else {
        start_ = s;
        stop_  = t;
    }
    return *this;
}
 
inline Interval Interval::intersected(const Interval &other) const
{
    double s = (propagate_nan::max)(start_, other.start_);
    double t = (propagate_nan::min)(stop_,  other.stop());
    if (!(s <= t)) {
        return Empty();    // 不相交 → 规范空区间
    }
    return Interval{s, t};
}
 
inline bool Interval::intersects(const Interval &other) const
{
    // 与 intersected() 一致：非空交集（含相切产生的点区间）才算相交；NaN → false
    return (propagate_nan::max)(start_, other.start()) <= (propagate_nan::min)(stop_, other.stop());
}
 
inline DoubleRange Interval::discretize(double step) const
{
    double dur = duration();
    if(step > 0 && dur >= 0)
    {
        size_t n = static_cast<size_t>(std::ceil(dur / step)) + 1;
        return DoubleRange(start_, stop_, step, n);
    }
    // 如果存在 nan，duration()为 nan，if 条件为false, 返回空范围
    return DoubleRange(0.0, 0.0, step, 0);
}
 
inline size_t Interval::discretizedCount(double step) const
{
    double dur = duration();
    if(step > 0 && dur >= 0)
    {
        return static_cast<size_t>(std::ceil(dur / step)) + 1;
    }
    // 如果存在 nan，duration()为 nan，if 条件为false, 返回0
    return 0;
}
 
 
AST_NAMESPACE_END