interval.h

Go to the documentation of this file.

#ifndef INTERVAL_H
#define INTERVAL_H

#include <numeric.h>
#include <QDebug>

namespace frechet { namespace data {

class Interval {
private:
    double _lower,_upper;
public:
    static const Interval UNIT;
    static const Interval INVALID;
public:
    Interval() : _lower(NAN),_upper(NAN) {}
    Interval(double lower, double upper) : _lower(lower), _upper(upper) {}
    Interval(const Interval& that) : _lower(that._lower), _upper(that._upper) {}
    Interval(const Interval& that,double shift) : _lower(that._lower+shift), _upper(that._upper+shift) {}

    double size() const     { return _upper-_lower; }

    bool valid() const      { return !std::isnan(_lower) && !std::isnan(_upper); }
    bool empty() const      { return _lower > _upper; }
    operator bool () const  { return valid() && !empty(); }
    bool operator! () const { return !valid() || empty(); }

    double lower() const    { return _lower; }
    double upper() const    { return _upper; }

    double& lower()         { return _lower; }
    double& upper()         { return _upper; }
    Interval& setLower(double value) { _lower=value; return *this; }
    Interval& setUpper(double value) { _upper=value; return *this; }
    double mid() const {
        return (_lower+_upper)/2;
    }

    Interval& operator= (const Interval& that) {
        return assign(that._lower,that._upper);
    }
    inline static bool equals(double a, double b) {
        if (std::isnan(a))
            return std::isnan(b);
        else
            return a==b;
    }

    bool operator== (const Interval& that) const {
        return equals(_lower,that._lower) && equals(_upper,that._upper);
        //return (_lower==that._lower) && (_upper==that._upper);
    }
    bool equals(const Interval& that, double precision) const {
        return (abs(_lower-that._lower) <= precision) && ((abs(_upper-that._upper) <= precision));
    }
    bool operator!= (const Interval& that) const {
        return ! operator==(that);
    }

    /*
     * */
    Interval    normalized() const {
        if (empty())
            return Interval(_upper,_lower);
        else
            return *this;
    }
    Interval&   normalize() {
        if (empty())
            return assign(_upper,_lower);
        else
            return* this;
    }
    Interval& clear() {
        _lower = _upper = NAN;
        return *this;
    }
    bool contains(double x) const {
        return (x >= _lower) && (x <= _upper);
    }

    bool contains(double x, double precision) const {
        return (x >= (_lower-precision))
                && (x <= (_upper+precision));
    }
    bool contains(const Interval& that) const {
        return (that._lower >= _lower) && (that._upper <= _upper);
    }

    bool intersects(const Interval& that) const {
        return (that._upper >= _lower) && (that._lower <= _upper);
    }

    bool intersects_proper(const Interval& that) const {
        return (that._upper > _lower) && (that._lower < _upper);
    }

    bool bordersTo(const Interval& that) const {
        return (that._upper == _lower) || (that._lower == _upper);
    }
    double mapToUnitInterval(double x) const {
        //  map to Unit
        if (size()==0.0)
            return (x-lower());
        else
            return (x-lower()) / size();
    }

    double mapFromUnitInterval(double x) const {
        return lower() + x*size();
    }

    double mapTo(double x, const Interval& other) const {
        return other.mapFromUnitInterval(mapToUnitInterval(x));
    }

    double mapFrom(double x, const Interval& other) const {
        return mapFromUnitInterval(other.mapToUnitInterval(x));
    }

    Interval    operator+ (double offset) const   {
        return Interval(_lower+offset,_upper+offset);
    }
    Interval&   operator+= (double offset) {
        return assign(_lower+offset,_upper+offset);
    }

    Interval    operator- (double offset) const   {
        return Interval(_lower-offset,_upper-offset);
    }
    Interval&   operator-= (double offset) {
        return assign(_lower-offset,_upper-offset);
    }
    Interval    operator* (double factor) const   {
        return Interval(_lower*factor,_upper*factor);
    }
    Interval&   operator*= (double factor) {
        return assign(_lower*factor,_upper*factor);
    }

    Interval    operator/ (double factor) const   {
        return Interval(_lower/factor,_upper/factor);
    }
    Interval&   operator/= (double factor) {
        return assign(_lower/factor,_upper/factor);
    }

    Interval    operator+ (const Interval& that) const {
        return Interval(
                    numeric::min(_lower,that._lower),
                    numeric::max(_upper,that._upper));
    }

    Interval&    operator+= (const Interval& that) {
        return assign(
                    numeric::min(_lower,that._lower),
                    numeric::max(_upper,that._upper));
    }

    Interval    operator- (const Interval& that) const {
        return Interval(
                    numeric::max(_lower,that._upper),
                    numeric::min(_upper,that._lower));
    }

    Interval    operator-= (const Interval& that) {
        return assign(
                    numeric::max(_lower,that._upper),
                    numeric::min(_upper,that._lower));
    }

    Interval    operator& (const Interval& that) const {
        return Interval(
                    numeric::max(_lower,that._lower),
                    numeric::min(_upper,that._upper));
    }

    Interval&    operator&= (const Interval& that) {
        return assign(
                    numeric::max(_lower,that._lower),
                    numeric::min(_upper,that._upper));
    }

    Interval& union_lf(const Interval& that);

private:
    Interval& assign(double lower, double upper) {
        _lower = lower;
        _upper = upper;
        return *this;
    }
    //  sketch for a lock-free union operator
    static void assign_min_lf(volatile double* value, double update_value);
    static void assign_max_lf(volatile double* value, double update_value);
    static int64_t compare_and_swap(volatile int64_t* value, int64_t old_value, int64_t update_value);
};


class IntervalPair
{
public:
    Interval H; 
    Interval V; 

    IntervalPair() : H(), V() {}
    IntervalPair(const Interval& ah, const Interval& av)
        : H(ah),V(av)
    { }

    QRectF boundingRect() const
    {
        QRectF r;
        r.setCoords(H.lower(),V.lower(), H.upper(),V.upper());
        return r;
    }
    bool operator== (const IntervalPair& that) {
        return H==that.H && V==that.V;
    }
    bool operator!= (const IntervalPair& that) {
        return H!=that.H || V!=that.V;
    }
    IntervalPair& operator+= (const IntervalPair& that)
    {
        H += that.H;
        V += that.V;
        return *this;
    }

    IntervalPair& clear()
    {
        H.clear();
        V.clear();
        return *this;
    }
    IntervalPair translated(double i, double j) const
    {
        return IntervalPair(H+i, V+j);
    }
};

std::ostream& operator <<(std::ostream& stream, const frechet::data::Interval& ival);
std::ostream& operator <<(std::ostream& stream, const frechet::data::IntervalPair& ival);

} }  //  namespace frechet::data

QDebug operator<< (QDebug debug, const frechet::data::Interval& ival);
QDebug operator<< (QDebug debug, const frechet::data::IntervalPair& ival);

#endif // INTERVAL_H