Qwt User's Guide: qwt_double_interval.cpp Source File

- Main Page
- Classes
- Files
- Related Pages

# qwt_double_interval.cpp

    00001 /* -*- mode: C++ ; c-file-style: "stroustrup" -*- *****************************
    00002  * Qwt Widget Library
    00003  * Copyright (C) 1997   Josef Wilgen
    00004  * Copyright (C) 2002   Uwe Rathmann
    00005  *
    00006  * This library is free software; you can redistribute it and/or
    00007  * modify it under the terms of the Qwt License, Version 1.0
    00008  *****************************************************************************/
    00009
    00010 #include <qglobal.h>
    00011 #if QT_VERSION >= 0x040000
    00012 #include <qalgorithms.h>
    00013 #else
    00014 #include <qtl.h>
    00015 #endif
    00016
    00017 #include "qwt_math.h"
    00018 #include "qwt_double_interval.h"
    00019
    00028 QwtDoubleInterval QwtDoubleInterval::normalized() const
    00029 {
    00030     if ( !isValid() )
    00031     {
    00032         return QwtDoubleInterval(d_maxValue, d_minValue);
    00033     }
    00034     else
    00035         return *this;
    00036 }
    00037
    00043 QwtDoubleInterval QwtDoubleInterval::inverted() const
    00044 {
    00045     return QwtDoubleInterval(d_maxValue, d_minValue);
    00046 }
    00047
    00054 bool QwtDoubleInterval::contains(double value) const
    00055 {
    00056     if ( !isValid() )
    00057         return false;
    00058
    00059     return (value >= d_minValue) && (value <= d_maxValue);
    00060 }
    00061
    00063 QwtDoubleInterval QwtDoubleInterval::unite(
    00064     const QwtDoubleInterval &interval) const
    00065 {
    00066     if ( !isValid() )
    00067     {
    00068         if ( !interval.isValid() )
    00069             return QwtDoubleInterval();
    00070         else
    00071             return interval;
    00072     }
    00073     if ( !interval.isValid() )
    00074         return *this;
    00075
    00076     const double minValue = qwtMin(d_minValue, interval.minValue());
    00077     const double maxValue = qwtMax(d_maxValue, interval.maxValue());
    00078
    00079     return QwtDoubleInterval(minValue, maxValue);
    00080 }
    00081
    00083 QwtDoubleInterval QwtDoubleInterval::intersect(
    00084     const QwtDoubleInterval &interval) const
    00085 {
    00086     if ( !interval.isValid() || !isValid() )
    00087         return QwtDoubleInterval();
    00088
    00089     QwtDoubleInterval i1 = *this;
    00090     QwtDoubleInterval i2 = interval;
    00091
    00092     if ( i1.minValue() > i2.minValue() )
    00093         qSwap(i1, i2);
    00094
    00095     if ( i1.maxValue() < i2.minValue() )
    00096         return QwtDoubleInterval();
    00097
    00098     return QwtDoubleInterval(i2.minValue(),
    00099                 qwtMin(i1.maxValue(), i2.maxValue()));
    00100 }
    00101
    00102 QwtDoubleInterval& QwtDoubleInterval::operator|=(
    00103     const QwtDoubleInterval &interval)
    00104 {
    00105     *this = *this | interval;
    00106     return *this;
    00107 }
    00108
    00109 QwtDoubleInterval& QwtDoubleInterval::operator&=(
    00110     const QwtDoubleInterval &interval)
    00111 {
    00112     *this = *this & interval;
    00113     return *this;
    00114 }
    00115
    00119 bool QwtDoubleInterval::intersects(const QwtDoubleInterval &interval) const
    00120 {
    00121     if ( !isValid() || !interval.isValid() )
    00122         return false;
    00123
    00124     QwtDoubleInterval i1 = *this;
    00125     QwtDoubleInterval i2 = interval;
    00126
    00127     if ( i1.minValue() > i2.minValue() )
    00128         qSwap(i1, i2);
    00129
    00130     return i1.maxValue() >= i2.minValue();
    00131 }
    00132
    00140 QwtDoubleInterval QwtDoubleInterval::symmetrize(double value) const
    00141 {
    00142     if ( !isValid() )
    00143         return *this;
    00144
    00145     const double delta =
    00146         qwtMax(qwtAbs(value - d_maxValue), qwtAbs(value - d_minValue));
    00147
    00148     return QwtDoubleInterval(value - delta, value + delta);
    00149 }
    00150
    00159 QwtDoubleInterval QwtDoubleInterval::limited(
    00160     double lBound, double hBound) const
    00161 {
    00162     if ( !isValid() || lBound > hBound )
    00163         return QwtDoubleInterval();
    00164
    00165     double minValue = qwtMax(d_minValue, lBound);
    00166     minValue = qwtMin(minValue, hBound);
    00167
    00168     double maxValue = qwtMax(d_maxValue, lBound);
    00169     maxValue = qwtMin(maxValue, hBound);
    00170
    00171     return QwtDoubleInterval(minValue, maxValue);
    00172 }
    00173
    00185 QwtDoubleInterval QwtDoubleInterval::extend(double value) const
    00186 {
    00187     if ( !isValid() )
    00188         return *this;
    00189
    00190     return QwtDoubleInterval(
    00191         qwtMin(value, d_minValue), qwtMax(value, d_maxValue) );
    00192 }
    00193
    00194 QwtDoubleInterval& QwtDoubleInterval::operator|=(double value)
    00195 {
    00196     *this = *this | value;
    00197     return *this;
    00198 }