UT/UT_Interval.h

Go to the documentation of this file.

/*
 * PROPRIETARY INFORMATION.  This software is proprietary to
 * Side Effects Software Inc., and is not to be reproduced,
 * transmitted, or disclosed in any way without written permission.
 *
 * Produced by:
 *      Side Effects Software Inc
 *      123 Front Street West, Suite 1401
 *      Toronto, Ontario
 *      Canada   M5J 2M2
 *      416-504-9876
 */

#ifndef __UT_Interval_h__
#define __UT_Interval_h__

#include "UT_API.h"
#include "UT_Math.h"

#ifdef WIN32
    #undef min
    #undef max
#endif

class UT_API UT_Interval {
  public:
       explicit UT_Interval(fpreal a = 0);
                UT_Interval(fpreal a, fpreal b, bool order=false);
    UT_Interval &operator+=(const UT_Interval &rhs);
    UT_Interval &operator-=(const UT_Interval &rhs);
    UT_Interval &operator*=(const UT_Interval &rhs);
    UT_Interval &operator/=(const UT_Interval &rhs); 
    UT_Interval &operator|=(const UT_Interval &rhs);
    UT_Interval &operator&=(const UT_Interval &rhs);
    UT_Interval &operator+=(fpreal rhs);
    UT_Interval &operator-=(fpreal rhs);
    UT_Interval &operator*=(fpreal rhs);
    bool        operator==(const UT_Interval &rhs) const;
    bool        operator!=(const UT_Interval &rhs) const;
    void        assign(fpreal Min, fpreal Max, bool order_them=false)
                {
                    min = Min;
                    max = Max;
                    if (order_them && min > max)
                    {
                        fpreal tmp = min;
                        min = max;
                        max = tmp;
                    }
                }
    void        extendToContain( fpreal a );
    void        minWith(const UT_Interval &rhs);
    void        maxWith(const UT_Interval &rhs);
    void        order();
    fpreal      closest(fpreal val) const;
    fpreal      closest(fpreal val, fpreal wrap) const;
    fpreal      avg() const     { return (max+min)*0.5; }
    fpreal      delta() const   { return max - min; }
    void        square();
    UT_Interval sqr() const;
    UT_Interval abs() const;
    UT_Interval pow(float arg) const;
    int         contains(fpreal arg) const;
    int         isValid(fpreal tol = 0.f) const;
    void        display() const;
    int equalZero(fpreal tol = 0.00001f) const
    {
        return ((min>=-tol) && (min <= tol) && (max >=-tol) && (max <= tol));
    }

    int isEqual(const UT_Interval &v, fpreal tol = 0.00001f) const
    {
        return ((min>=v.min-tol) && (min<=v.min+tol) && 
                (max>=v.max-tol) && (max<=v.max+tol));
    }

    void clampZero(fpreal tol = 0.00001f)
    {
        if (min>=-tol && min<= tol) min = 0;
        if (max>=-tol && max<= tol) max = 0;
    }

    void negate() 
    { 
        fpreal tmp = min; 
        min = -max; 
        max = -tmp; 
    }
    void invert(UT_Interval &v) const
    {
        v.min = min;
        v.max = max;
        if (!v.min) 
            v.min+=0.00001f; 
        if(!v.max) 
            v.max+=0.00001f; 
        fpreal tmp = v.min; 
        v.min = 1/v.max; 
        v.max = 1/tmp; 

    }
    void invert() 
    { 
        if (!min) 
            min+=0.00001f; 
        if(!max) 
            max+=0.00001f; 
        fpreal tmp = min; 
        min = 1/max; 
        max = 1/tmp; 
    }
  public:
    float       min, max;
};

inline UT_Interval operator+(const UT_Interval &lhs, const UT_Interval &rhs);
inline UT_Interval operator+(fpreal lhs, const UT_Interval &rhs);
inline UT_Interval operator+(const UT_Interval &lhs, fpreal rhs);
inline UT_Interval operator-(const UT_Interval &lhs, const UT_Interval &rhs);
inline UT_Interval operator-(fpreal lhs, const UT_Interval &rhs);
inline UT_Interval operator-(const UT_Interval &lhs, fpreal rhs);
inline UT_Interval operator-(const UT_Interval &rhs);
inline UT_Interval operator*(const UT_Interval &lhs, const UT_Interval &rhs);
inline UT_Interval operator*(fpreal lhs, const UT_Interval &rhs);
inline UT_Interval operator*(const UT_Interval &lhs, fpreal rhs);
inline UT_Interval operator/(const UT_Interval &lhs, const UT_Interval &rhs);
inline UT_Interval operator/(fpreal lhs, const UT_Interval &rhs);
inline UT_Interval operator/(const UT_Interval &lhs, fpreal rhs);
inline UT_Interval operator|(const UT_Interval &lhs, const UT_Interval &rhs);
inline UT_Interval operator&(const UT_Interval &lhs, const UT_Interval &rhs);
inline UT_Interval maxOf(const UT_Interval &arg0, const UT_Interval &arg1);
inline UT_Interval minOf(const UT_Interval &arg0, const UT_Interval &arg1);

//////////////////////////////////////////////////////////////////////////
//////////////// Inline Implementations //////////////////////////////////
//////////////////////////////////////////////////////////////////////////

inline UT_Interval::UT_Interval(fpreal a): min(a), max(a) {}
inline UT_Interval::UT_Interval(fpreal a, fpreal b, bool order_them)
    : min(a), 
      max(b) 
{
    if (order_them && min > max)
    {
        fpreal tmp = min;
        min = max;
        max = tmp;
    }
}

inline UT_Interval &UT_Interval::operator+=(const UT_Interval &rhs) 
{
  min += rhs.min;
  max += rhs.max;
  return *this;
}

inline UT_Interval &UT_Interval::operator+=(fpreal rhs) 
{
  min += rhs;
  max += rhs;
  return *this;
}

inline UT_Interval &UT_Interval::operator-=(const UT_Interval &rhs) 
{
  fpreal t = rhs.min;
  min -= rhs.max;
  max -= t;
  return *this;
}

inline UT_Interval &UT_Interval::operator-=(fpreal rhs) 
{
  min -= rhs;
  max -= rhs;
  return *this;
}

inline UT_Interval &UT_Interval::operator*=(const UT_Interval &rhs) 
{
  fpreal                t1 = min*rhs.min;
  fpreal                t2 = max*rhs.min;
  fpreal                t3 = min*rhs.max;
  fpreal                t4 = max*rhs.max;
  fpreal                tmin, tmax;

  if (t1 < t2) { tmin = t1; tmax = t2; }
  else { tmin = t2; tmax = t1; }
  if (tmax < t3) { tmax = t3; }
  if (tmin > t3) { tmin = t3; }
  if (tmax < t4) { tmax = t4; }
  if (tmin > t4) { tmin = t4; }
  min = tmin;
  max = tmax;
  return *this;
}

inline UT_Interval &UT_Interval::operator/=(const UT_Interval &rhs) 
{
    UT_Interval inverted;
    rhs.invert(inverted);
    (*this) *= inverted;
    return *this;
}



inline UT_Interval &UT_Interval::operator*=(fpreal rhs) 
{
  if (rhs >= 0.0F)  { min *= rhs;  max *= rhs; }
  else { fpreal t = min * rhs;  min = max * rhs; max = t; }
  return *this;
}
inline    bool  UT_Interval::operator==(const UT_Interval &rhs) const
{
    return min == rhs.min && max == rhs.max;
}
inline    bool  UT_Interval::operator!=(const UT_Interval &rhs) const
{
    return min != rhs.min || max != rhs.max;
}
 

inline void UT_Interval::maxWith(const UT_Interval &rhs) 
{
  if (min < rhs.min) min = rhs.min;
  if (max < rhs.max) max = rhs.max;
}

inline void UT_Interval::extendToContain( fpreal a )
{
    if( min>a )
        min = a;
    else if( max<a )
        max = a;
}

inline void UT_Interval::minWith(const UT_Interval &rhs) 
{
  if (min > rhs.min) min = rhs.min;
  if (max > rhs.max) max = rhs.max;
}

inline UT_Interval &UT_Interval::operator|=(const UT_Interval &rhs) 
{
  if (min > rhs.min) min = rhs.min;
  if (max < rhs.max) max = rhs.max;
  return *this;
}

inline UT_Interval &UT_Interval::operator&=(const UT_Interval &rhs) 
{
  if (min < rhs.min) min = rhs.min;
  if (max > rhs.max) max = rhs.max;
  return *this;
}


inline UT_Interval UT_Interval::sqr() const
{
  fpreal tmin, tmax;
  if (min < 0.0F) {
    if (max < 0.0F) {
        tmin = max*max;
        tmax = min*min;
    }
    else {
        tmin = min*min;
        tmax = max*max;
        tmax = (tmin < tmax) ? tmax :  tmin;
        tmin = 0.0F;
    }
  }
  else {
    tmin = min*min;
    tmax = max*max;
  }
  return UT_Interval(tmin, tmax);
}

inline void UT_Interval::square()
{
  fpreal tmin, tmax;
  if (min < 0.0F) {
    if (max < 0.0F) {
        tmin = max*max;
        tmax = min*min;
    }
    else {
        tmin = min*min;
        tmax = max*max;
        tmax = (tmin < tmax) ? tmax :  tmin;
        tmin = 0.0F;
    }
  }
  else {
    tmin = min*min;
    tmax = max*max;
  }
  min = tmin;
  max = tmax;
}


inline UT_Interval UT_Interval::abs() const
{
  if (max < 0.0F) {
    return UT_Interval(-max, -min);
  }
  else if (min < 0.0F) {
    fpreal tmax;
    if (-min > max) tmax = -min;
    else tmax = max;
    return UT_Interval(0.0F, tmax);
  }
  return *this;
}

inline fpreal
UT_Interval::closest(fpreal val) const
{
    fpreal      dmin, dmax;

    dmin = val - min;
    dmax = max - val;
    if (dmin < 0.0F)
        return min;
    else if (dmax < 0.0F)
        return max;
    return val;
}

inline fpreal
UT_Interval::closest(fpreal val, fpreal wrap) const
{
    fpreal      dmin, dmax;

    dmin = val - min;
    dmax = max - val;
    if (dmin < 0.0F)
    {
        if (dmin < dmax - wrap)
            return max;
        else
            return min;
    }
    else if (dmax < 0.0F)
    {
        if (dmin - wrap < dmax)
            return max;
        else
            return min;
    }
    return val;
}

#if 0
// WARNING! assumes that the interval is positive.
//
inline UT_Interval UT_Interval::pow(fpreal arg) const
{
  if (arg > 0) return UT_Interval(powf(min, arg), powf(max, arg));
  else return UT_Interval(powf(max, arg), powf(min, arg));
}
#endif

inline int UT_Interval::contains(fpreal arg) const
{
  return ((arg >= min) && (arg <= max));
}

inline int UT_Interval::isValid(fpreal tol) const
{
  return UTisLessOrEqual(min, max, tol);
}

inline void UT_Interval::order()
{
    if (min > max)
    {
        fpreal tmp = min;
        min = max;
        max = tmp;
    }
}

// Free functions

inline UT_Interval operator+(const UT_Interval &lhs, const UT_Interval &rhs)
{
  return UT_Interval(lhs.min + rhs.min, lhs.max + rhs.max);
}

inline UT_Interval operator+(fpreal lhs, const UT_Interval &rhs)
{
  return UT_Interval(rhs.min + lhs, rhs.max + lhs);
}


inline UT_Interval operator+(const UT_Interval &lhs, fpreal rhs)
{
  return UT_Interval(lhs.min + rhs, lhs.max + rhs);
}

inline UT_Interval operator-(const UT_Interval &lhs, const UT_Interval &rhs)
{
  return UT_Interval(lhs.min - rhs.max, lhs.max - rhs.min);
}

inline UT_Interval operator-(fpreal lhs, const UT_Interval &rhs)
{
  return UT_Interval(lhs - rhs.max, lhs - rhs.min);
}

inline UT_Interval operator-(const UT_Interval &lhs, fpreal rhs)
{
  return UT_Interval(lhs.min - rhs, lhs.max - rhs);
}

inline UT_Interval operator-(const UT_Interval &rhs)
{
  return UT_Interval(-rhs.max, -rhs.min);
}

inline UT_Interval operator*(const UT_Interval &lhs, const UT_Interval &rhs)
{
  fpreal                t1 = lhs.min*rhs.min;
  fpreal                t2 = lhs.max*rhs.min;
  fpreal                t3 = lhs.min*rhs.max;
  fpreal                t4 = lhs.max*rhs.max;
  fpreal                tmin, tmax;

  if (t1 < t2) { tmin = t1; tmax = t2; }
  else { tmin = t2; tmax = t1; }
  if (tmax < t3) { tmax = t3; }
  if (tmin > t3) { tmin = t3; }
  if (tmax < t4) { tmax = t4; }
  if (tmin > t4) { tmin = t4; }
  return UT_Interval(tmin, tmax);
}

inline UT_Interval operator*(fpreal lhs, const UT_Interval &rhs)
{
  fpreal tmin, tmax;
  if (lhs > 0.0F) { tmin = lhs*rhs.min;  tmax = lhs*rhs.max; }
  else { tmin = lhs*rhs.max;  tmax = lhs*rhs.min; }
  return UT_Interval(tmin, tmax);
}

inline UT_Interval operator*(const UT_Interval &lhs, fpreal rhs)
{
  fpreal tmin, tmax;
  if (rhs > 0.0F) { tmin = rhs*lhs.min;  tmax = rhs*lhs.max; }
  else { tmin = rhs*lhs.max;  tmax = rhs*lhs.min; }
  return UT_Interval(tmin, tmax);
}

inline UT_Interval operator|(const UT_Interval &lhs, const UT_Interval &rhs)
{
  return UT_Interval((lhs.min < rhs.min)? lhs.min : rhs.min,
                  (lhs.max < rhs.max)? rhs.max : lhs.max);
}

inline UT_Interval operator&(const UT_Interval &lhs, const UT_Interval &rhs)
{
  return UT_Interval((lhs.min < rhs.min)? rhs.min : lhs.min,
                  (lhs.max < rhs.max)? lhs.max : rhs.max);
}
inline UT_Interval operator/(const UT_Interval &lhs, const UT_Interval &rhs)
{
    UT_Interval v;
    rhs.invert(v);
    return lhs * v;
}

inline UT_Interval operator/(fpreal lhs, const UT_Interval &rhs)
{
    UT_Interval v;
    rhs.invert(v);
    v *= lhs;
    return v;
}

inline UT_Interval operator/(const UT_Interval &lhs, fpreal rhs)
{
    if (!rhs) rhs += 0.00001f;
    return UT_Interval(lhs.min / rhs, lhs.max / rhs);
}


inline UT_Interval maxOf(const UT_Interval &arg0, const UT_Interval &arg1)
{
  return UT_Interval((arg0.min < arg1.min)? arg1.min : arg0.min,
                  (arg0.max < arg1.max)? arg1.max : arg0.max);
}

inline UT_Interval minOf(const UT_Interval &arg0, const UT_Interval &arg1)
{
  return UT_Interval((arg0.min < arg1.min)? arg0.min : arg1.min,
                  (arg0.max < arg1.max)? arg0.max : arg1.max);
}

#endif // __UT_Interval_h__

---