intervals.h

Go to the documentation of this file.

 
#include "elementa/license.inc"
#include "elementa/checks.inc"
 
#ifndef ELEMENTA_MATH_INTERVALS_H
#define ELEMENTA_MATH_INTERVALS_H
 
#include <string>
#include "elementa/base/exceptions.h"
 
namespace elementa
{
 
namespace math
{
 
 
/* *************************************************************************/
/* *****************************************************************************
 
    Enum class: IntervalClosedness
 
*******************************************************************************/
 
enum class IntervalCl: uint8_t {
                                CLOSED,
                                OPENED,
                                LEFT_CLOSED,
                                RIGHT_CLOSED
                               };
 
 
/* *****************************************************************************
 
    Template class: Interval
 
*******************************************************************************/
 
 
template <typename ELEMTYPE>
class Interval
{
 public:
 
 
    static Interval fromWidth(ELEMTYPE mi, ELEMTYPE width,
                              IntervalCl cl = IntervalCl::CLOSED)
        { return(Interval{mi,static_cast<ELEMTYPE>(mi + width),cl}); }
    
 
    Interval(void): closedl_{false},
                    closedr_{false},
                    allclosed_{false},
                    min_{ELEMTYPE{}}, // if numerical, gets 0
                    max_{ELEMTYPE{}} {}
 
    Interval(ELEMTYPE mi, ELEMTYPE ma, 
             IntervalCl cl = IntervalCl::CLOSED): 
                                    closedl_{(cl == IntervalCl::CLOSED) ||
                                             (cl == IntervalCl::LEFT_CLOSED)},
                                    closedr_{(cl == IntervalCl::CLOSED) ||
                                             (cl == IntervalCl::RIGHT_CLOSED)},
                                    allclosed_{cl == IntervalCl::CLOSED},
                                    min_{mi},max_{ma} 
        { if (ma < mi) ELE_CODE_INVARG(
                                "Invalid interval (max " +
                                std::to_string(ma) + " is < min " +
                                std::to_string(mi) + ")"); 
          if ((closedl_ != closedr_) && (ma == mi)) 
            ELE_CODE_INVARG("Invalid semi-closed interval"); }
                            
                            
    Interval(const Interval & o) { copyFrom(o); }
    Interval(Interval && o) { copyFrom(o); }
    Interval & operator=(const Interval & o) { copyFrom(o); return(*this); }
    Interval & operator=(Interval && o) { copyFrom(o); return(*this); }
 
 
    ELEMTYPE minimum(void) const noexcept { return(min_); }
 
    ELEMTYPE maximum(void) const noexcept { return(max_); }
    
    ELEMTYPE width(void) const noexcept { return(max_ - min_); }
 
    IntervalCl closedness(void) const noexcept 
        { return(closednessFromCloses(closedl_,closedr_)); }
 
    bool closedMin(void) const noexcept { return(closedl_); }
 
    bool closedMax(void) const noexcept { return(closedr_); }
 
    bool empty(void) const noexcept { return((!allclosed_) && (min_ == max_)); }
 
    Interval intersect(const Interval & oth) const noexcept
    {
        if ( ((oth.min_ > max_) || (oth.max_ < min_)) ||
             ((oth.closedl_ != closedr_) && (oth.min_ == max_)) ||
             ((oth.closedr_ != closedl_) && (oth.max_ == min_)) ) 
            return(Interval{});
        ELEMTYPE a,b;
        bool cl,cr;
        if ((oth.min_ > min_) || (oth.min_ == min_)) 
        {
            a = oth.min_;
            cl = oth.closedl_;
            b = std::min(oth.max_,max_);
            cr = closedr_;
        }
        else 
        {
            a = min_;
            cl = closedl_;
            b = std::min(oth.max_,max_);
            cr = oth.closedr_;
        }
        return(Interval{a,b,closednessFromCloses(cl,cr)});
    }
 
    bool containPoint(ELEMTYPE e) const noexcept
        { return( ((e > min_) && (e < max_)) ||
                  ((e == min_) && (closedl_)) ||
                  ((e == max_) && (closedr_)) ); }
 
    std::string to_string(void) const
        { return(std::string(1, closedl_ ? '[' : '(') +
                 std::to_string(min_) + ".." + std::to_string(max_) +
                 std::string(1, closedl_ ? ']' : ')')); }
 
 
 private:
 
    static IntervalCl closednessFromCloses(bool l, bool r) noexcept
        { return(l == r ? 
                    (l ? IntervalCl::CLOSED : IntervalCl::OPENED) :
                    (l ? IntervalCl::LEFT_CLOSED : IntervalCl::RIGHT_CLOSED)); }
 
    bool closedl_,closedr_,allclosed_;
 
    ELEMTYPE min_,max_;
    
    void copyFrom(const Interval & o)
    { closedl_ = o.closedl_; closedr_ = o.closedr_; allclosed_ = o.allclosed_;
      min_ = o.min_; max_ = o.max_; }
};
 
 
} // end math namespace
 
} // end elementa namespace
 
 
#endif