qwt_double_interval.cpp

Go to the documentation of this file.

/* -*- mode: C++ ; c-file-style: "stroustrup" -*- *****************************
 * Qwt Widget Library
 * Copyright (C) 1997   Josef Wilgen
 * Copyright (C) 2002   Uwe Rathmann
 * 
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the Qwt License, Version 1.0
 *****************************************************************************/

#include <qglobal.h>
#if QT_VERSION >= 0x040000
#include <qalgorithms.h>
#else
#include <qtl.h>
#endif

#include "qwt_math.h"
#include "qwt_double_interval.h"

QwtDoubleInterval QwtDoubleInterval::normalized() const
{
    if ( d_minValue > d_maxValue )
    {
        return inverted();
    }
    if ( d_minValue == d_maxValue && d_borderFlags == ExcludeMinimum )
    {
        return inverted();
    }

    return *this;
}

QwtDoubleInterval QwtDoubleInterval::inverted() const
{
    int borderFlags = 0;
    if ( d_borderFlags & ExcludeMinimum )
        borderFlags |= ExcludeMaximum;
    if ( d_borderFlags & ExcludeMaximum )
        borderFlags |= ExcludeMinimum;

    return QwtDoubleInterval(d_maxValue, d_minValue, borderFlags);
}

bool QwtDoubleInterval::contains(double value) const
{
    if ( !isValid() )
        return false;

    if ( value < d_minValue || value > d_maxValue )
        return false;

    if ( value == d_minValue && d_borderFlags & ExcludeMinimum )
        return false;

    if ( value == d_maxValue && d_borderFlags & ExcludeMaximum )
        return false;

    return true;
}

QwtDoubleInterval QwtDoubleInterval::unite(
    const QwtDoubleInterval &other) const
{
    /*
     If one of the intervals is invalid return the other one.
     If both are invalid return an invalid default interval
     */
    if ( !isValid() )
    {
        if ( !other.isValid() )
            return QwtDoubleInterval();
        else
            return other;
    }
    if ( !other.isValid() )
        return *this;

    QwtDoubleInterval united;
    int flags = 0;

    // minimum
    if ( d_minValue < other.minValue() )
    {
        united.setMinValue(d_minValue);
        flags &= d_borderFlags & ExcludeMinimum;
    }
    else if ( other.minValue() < d_minValue )
    {
        united.setMinValue(other.minValue());
        flags &= other.borderFlags() & ExcludeMinimum;
    }
    else // d_minValue == other.minValue()
    {
        united.setMinValue(d_minValue);
        flags &= (d_borderFlags & other.borderFlags()) & ExcludeMinimum;
    }

    // maximum
    if ( d_maxValue > other.maxValue() )
    {
        united.setMaxValue(d_maxValue);
        flags &= d_borderFlags & ExcludeMaximum;
    }
    else if ( other.maxValue() > d_maxValue )
    {
        united.setMaxValue(other.maxValue());
        flags &= other.borderFlags() & ExcludeMaximum;
    }
    else // d_maxValue == other.maxValue() )
    {
        united.setMaxValue(d_maxValue);
        flags &= d_borderFlags & other.borderFlags() & ExcludeMaximum;
    }

    united.setBorderFlags(flags);
    return united;
}

QwtDoubleInterval QwtDoubleInterval::intersect(
    const QwtDoubleInterval &other) const
{
    if ( !other.isValid() || !isValid() )
        return QwtDoubleInterval();

    QwtDoubleInterval i1 = *this;
    QwtDoubleInterval i2 = other;

    // swap i1/i2, so that the minimum of i1
    // is smaller then the minimum of i2

    if ( i1.minValue() > i2.minValue() ) 
    {
        qSwap(i1, i2);
    }
    else if ( i1.minValue() == i2.minValue() )
    {
        if ( i1.borderFlags() & ExcludeMinimum )
            qSwap(i1, i2);
    }

    if ( i1.maxValue() < i2.minValue() )
    {
        return QwtDoubleInterval();
    }

    if ( i1.maxValue() == i2.minValue() )
    {
        if ( i1.borderFlags() & ExcludeMaximum ||
            i2.borderFlags() & ExcludeMinimum )
        {
            return QwtDoubleInterval();
        }
    }

    QwtDoubleInterval intersected;
    int flags = 0;

    intersected.setMinValue(i2.minValue());
    flags |= i2.borderFlags() & ExcludeMinimum;

    if ( i1.maxValue() < i2.maxValue() )
    {
        intersected.setMaxValue(i1.maxValue());
        flags |= i1.borderFlags() & ExcludeMaximum;
    }
    else if ( i2.maxValue() < i1.maxValue() )
    {
        intersected.setMaxValue(i2.maxValue());
        flags |= i2.borderFlags() & ExcludeMaximum;
    }
    else // i1.maxValue() == i2.maxValue()
    {
        intersected.setMaxValue(i1.maxValue() );
        flags |= i1.borderFlags() & i2.borderFlags() & ExcludeMaximum;
    }

    intersected.setBorderFlags(flags);
    return intersected;
}

QwtDoubleInterval& QwtDoubleInterval::operator|=(
    const QwtDoubleInterval &interval)
{
    *this = *this | interval;
    return *this;
}

QwtDoubleInterval& QwtDoubleInterval::operator&=(
    const QwtDoubleInterval &interval) 
{
    *this = *this & interval;
    return *this;
}

bool QwtDoubleInterval::intersects(const QwtDoubleInterval &other) const
{
    if ( !isValid() || !other.isValid() )
        return false;

    QwtDoubleInterval i1 = *this;
    QwtDoubleInterval i2 = other;

    // swap i1/i2, so that the minimum of i1
    // is smaller then the minimum of i2

    if ( i1.minValue() > i2.minValue() ) 
    {
        qSwap(i1, i2);
    }
    else if ( i1.minValue() == i2.minValue() &&
            i1.borderFlags() & ExcludeMinimum )
    {
        qSwap(i1, i2);
    }

    if ( i1.maxValue() > i2.minValue() )
    {
        return true;
    }
    if ( i1.maxValue() == i2.minValue() )
    {
        return !( (i1.borderFlags() & ExcludeMaximum) || 
            (i2.borderFlags() & ExcludeMinimum) );
    }
    return false;
}

QwtDoubleInterval QwtDoubleInterval::symmetrize(double value) const
{
    if ( !isValid() )
        return *this;

    const double delta =
        qwtMax(qwtAbs(value - d_maxValue), qwtAbs(value - d_minValue));

    return QwtDoubleInterval(value - delta, value + delta);
}

QwtDoubleInterval QwtDoubleInterval::limited(
    double lowerBound, double upperBound) const
{
    if ( !isValid() || lowerBound > upperBound )
        return QwtDoubleInterval();

    double minValue = qwtMax(d_minValue, lowerBound);
    minValue = qwtMin(minValue, upperBound);

    double maxValue = qwtMax(d_maxValue, lowerBound);
    maxValue = qwtMin(maxValue, upperBound);

    return QwtDoubleInterval(minValue, maxValue, d_borderFlags);
}

QwtDoubleInterval QwtDoubleInterval::extend(double value) const
{
    if ( !isValid() )
        return *this;

    return QwtDoubleInterval( qwtMin(value, d_minValue), 
        qwtMax(value, d_maxValue), d_borderFlags );
}

QwtDoubleInterval& QwtDoubleInterval::operator|=(double value)
{
    *this = *this | value;
    return *this;
}