interval.h

一个用MATLAB语言编写的摄像机标定工具箱,内容丰富

//
// interval.h
//
// $Id: interval.h,v 1.1.1.1 2001/02/28 00:28:36 cstolte Exp $
//

#ifndef SGL_INTERVAL_H
#define SGL_INTERVAL_H

/*
 *	Interval-arithmetic class
 *	D. P. Mitchell  92/04/16.
 */
#include <math.h>
#include <sgl/defs.h>

class Interval {
    double	lo, hi;
public:
    Interval()			{}
    Interval(double a)		{ lo = hi = a; }
    Interval(double a, double b)	{ lo = a; hi = b; }

    double inf() const			{ return lo; }
    double sup() const			{ return hi; }
    double mid() const			{ return 0.5*(lo + hi); }
    double rad() const			{ return 0.5*(hi - lo); }

    /*
     *	Interval extension of ANSI math functions (and others)
     */
    void print(std::ostream &os) const;

    friend Interval acos(const Interval &);
    friend Interval asin(const Interval &);
    friend Interval atan(const Interval &);
    friend Interval atan2(const Interval &, const Interval &);
    friend Interval ceil(const Interval &);
    friend Interval cos(const Interval &);
    friend Interval cosh(const Interval &);
    friend Interval exp(const Interval &);
    friend Interval fabs(const Interval &);
    friend Interval floor(const Interval &);
    friend Interval hypot(const Interval &, const Interval &);
    friend Interval log(const Interval &);
    friend Interval log10(const Interval &);
    friend Interval pow(const Interval &, double);
    friend Interval sin(const Interval &);
    friend Interval sinh(const Interval &);
    friend Interval sqr(const Interval &);
    friend Interval sqrt(const Interval &);
    friend Interval tan(const Interval &);
    friend Interval tanh(const Interval &);

    friend inline Interval operator +(const Interval &, const Interval &);
    friend inline Interval operator +(const Interval &, double);
    friend inline Interval operator +(double, const Interval &);
    friend inline Interval operator -(const Interval &, const Interval &);
    friend inline Interval operator -(const Interval &, double);
    friend inline Interval operator -(double, const Interval &);
    friend inline Interval operator -(const Interval &);
    friend Interval operator *(const Interval &, const Interval &);
    friend inline Interval operator *(const Interval &, double);
    friend inline Interval operator *(double, const Interval &);
    friend Interval operator /(const Interval &, const Interval &);
    friend inline Interval operator /(const Interval &, double);

    friend inline int operator ==(const Interval &, const Interval &);
    friend inline int operator !=(const Interval &, const Interval &);
    friend inline int operator  <(const Interval &, const Interval &);
    friend inline int operator  <(const Interval &, double);
    friend inline int operator  <(double, const Interval &);
    friend inline int operator  >(const Interval &, const Interval &);
    friend inline int operator  >(const Interval &, double);
    friend inline int operator  >(double, const Interval &);
    friend inline int subset(const Interval &, const Interval &);
    friend inline int subset(double, const Interval &);
    friend int disjoint(const Interval &, const Interval &);
    friend Interval intersect(const Interval &, const Interval &);
    friend Interval convexHull(const Interval &, const Interval &);

    void operator +=(const Interval &);
    void operator -=(const Interval &);
    void operator *=(const Interval &);
    void operator /=(const Interval &);
};

/* ------------------------- inline functions ------------------------- */

inline Interval operator +(const Interval &a, const Interval &b)
{
    return Interval(a.lo + b.lo , a.hi + b.hi);
}

inline Interval operator +(const Interval &a, double b)
{
    return Interval(a.lo + b, a.hi + b);
}

inline Interval operator +(double b, const Interval &a)
{
    return Interval(a.lo + b, a.hi + b);
}

inline Interval operator -(const Interval &a, const Interval &b)
{
    return Interval(a.lo - b.hi, a.hi - b.lo);
}

inline Interval operator -(const Interval &a, double b)
{
    return Interval(a.lo - b, a.hi - b);
}

inline Interval operator -(double a, const Interval &b)
{
    return Interval(a-b.hi, a-b.lo);
}

inline Interval operator -(const Interval &a)
{
    return Interval(-a.hi, -a.lo);
}

inline Interval operator *(const Interval &a, double b)
{
    return (b < 0) ? Interval(a.hi*b, a.lo*b) : Interval(a.lo*b, a.hi*b);
}

inline Interval operator *(double b, const Interval &a)
{
    return (b < 0) ? Interval(a.hi*b, a.lo*b) : Interval(a.lo*b, a.hi*b);
}

inline Interval operator /(const Interval &a, double b)
{
    return (b < 0) ? Interval(a.hi/b, a.lo/b) : Interval(a.lo/b, a.hi/b);
}

inline void Interval::operator +=(const Interval &a)
{
    lo += a.lo;
    hi += a.hi;
}

inline void Interval::operator -=(const Interval &a)
{
    lo -= a.hi;
    hi -= a.lo;
}

inline int operator ==(const Interval &a, const Interval &b)
{
    return a.lo == b.lo && a.hi == b.hi;
}

inline int operator !=(const Interval &a, const Interval &b)
{
    return a.lo != b.lo || a.hi != b.hi;
}

inline int operator <(const Interval &a, const Interval &b)
{
    return a.hi < b.lo;
}

inline int operator <(const Interval &a, double b)
{
    return a.hi < b;
}

inline int operator <(double a, const Interval &b)
{
    return a < b.lo;
}

inline int operator >(const Interval &a, const Interval &b)
{
    return a.lo > b.hi;
}

inline int operator >(const Interval &a, double b)
{
    return a.lo > b;
}

inline int operator >(double a, const Interval &b)
{
    return a > b.hi;
}

inline int subset(const Interval &a, const Interval &b)
{
    return a.lo >= b.lo && a.hi <= b.hi;
}

inline int subset(double a, const Interval &b)
{
    return a >= b.lo && a <= b.hi;
}

#endif /* SGL_INTERVAL_H */