---
name: "QwtInterval"
section: "3"
platform: "linux"
package: "libqwt-doc"
version: "6.1.4-2"
release: "Debian 13 (Trixie)"
platforms: ["linux"]
url: "https://new.carta.tech/QwtInterval"
---

# QwtInterval(3)

A class representing an interval.

## NAME

QwtInterval - A class representing an interval.

## SYNOPSIS

`#include <qwt_interval.h>`

### Public Types

enum **BorderFlag** { **IncludeBorders** = 0x00, **ExcludeMinimum** = 0x01, **ExcludeMaximum** = 0x02, **ExcludeBorders** = ExcludeMinimum \| ExcludeMaximum }\
 typedef QFlags\< **BorderFlag** \> **BorderFlags**\
 Border flags.

### Public Member Functions

**QwtInterval** ()\
 Default Constructor.  **QwtInterval** (double **minValue**, double **maxValue**, **BorderFlags**=**IncludeBorders**)\
 void **setInterval** (double **minValue**, double **maxValue**, **BorderFlags**=**IncludeBorders**)\
 **QwtInterval** **normalized** () const\
 Normalize the limits of the interval.  **QwtInterval** **inverted** () const\
 **QwtInterval** **limited** (double lowerBound, double upperBound) const\
 bool **operator==** (const **QwtInterval** &) const\
 Compare two intervals.  bool **operator!=** (const **QwtInterval** &) const\
 Compare two intervals.  void **setBorderFlags** (**BorderFlags**)\
 **BorderFlags** **borderFlags** () const\
 double **minValue** () const\
 double **maxValue** () const\
 double **width** () const\
 Return the width of an interval.  void **setMinValue** (double)\
 void **setMaxValue** (double)\
 bool **contains** (double value) const\
 bool **intersects** (const **QwtInterval** &) const\
 Test if two intervals overlap.  **QwtInterval** **intersect** (const **QwtInterval** &) const\
 Intersect 2 intervals.  **QwtInterval** **unite** (const **QwtInterval** &) const\
 Unite 2 intervals.  **QwtInterval** **operator\|** (const **QwtInterval** &) const\
 **QwtInterval** **operator &** (const **QwtInterval** &) const\
 **QwtInterval** & **operator\|=** (const **QwtInterval** &)\
 Unite this interval with the given interval.  **QwtInterval** & **operator &=** (const **QwtInterval** &)\
 **QwtInterval** **extend** (double value) const\
 Extend the interval.  **QwtInterval** **operator\|** (double) const\
 **QwtInterval** & **operator\|=** (double)\
 bool **isValid** () const\
 bool **isNull** () const\
 void **invalidate** ()\
 **QwtInterval** **symmetrize** (double value) const\

## Detailed Description

A class representing an interval.

The interval is represented by 2 doubles, the lower and the upper limit.

## Member Enumeration Documentation

### enum QwtInterval::BorderFlag

Flag indicating if a border is included or excluded

**See also:**

**setBorderFlags()**, **borderFlags()**

**Enumerator**

- *IncludeBorders*

  *Min/Max values are inside the interval.*

- *ExcludeMinimum*

  *Min value is not included in the interval.*

- *ExcludeMaximum*

  *Max value is not included in the interval.*

- *ExcludeBorders*

  *Min/Max values are not included in the interval.*

## Constructor & Destructor Documentation

### QwtInterval::QwtInterval ()` [inline]`

*Default Constructor. Creates an invalid interval \[0.0, -1.0\]*

**See also:**

**setInterval()***,* **isValid()**

### QwtInterval::QwtInterval (double minValue, double maxValue, BorderFlags borderFlags = IncludeBorders)` [inline]`

*Constructor*

*Build an interval with from min/max values*

**Parameters:**

*minValue Minimum value* \
 *maxValue Maximum value* \
 *borderFlags Include/Exclude borders*

## Member Function Documentation

### QwtInterval::BorderFlags QwtInterval::borderFlags () const` [inline]`

**Returns:**

*Border flags*

**See also:**

**setBorderFlags()**

### bool QwtInterval::contains (double value) const

*Test if a value is inside an interval*

**Parameters:**

*value Value*

**Returns:**

*true, if value \>=* **minValue()** *&& value \<=* **maxValue()**

### QwtInterval QwtInterval::extend (double value) const

*Extend the interval. If value is below* **minValue()***, value becomes the lower limit. If value is above* **maxValue()***, value becomes the upper limit.*

**extend()** *has no effect for invalid intervals*

**Parameters:**

*value Value*

**Returns:**

*extended interval*

**See also:**

**isValid()**

### QwtInterval QwtInterval::intersect (const QwtInterval & other) const

*Intersect 2 intervals.*

**Parameters:**

*other Interval to be intersect with*

**Returns:**

*Intersection*

### bool QwtInterval::intersects (const QwtInterval & other) const

*Test if two intervals overlap.*

**Parameters:**

*other Interval*

**Returns:**

*True, when the intervals are intersecting*

### void QwtInterval::invalidate ()` [inline]`

*Invalidate the interval*

*The limits are set to interval \[0.0, -1.0\]*

**See also:**

**isValid()**

### QwtInterval QwtInterval::inverted () const

*Invert the limits of the interval*

**Returns:**

*Inverted interval*

**See also:**

**normalized()**

### bool QwtInterval::isNull () const` [inline]`

**Returns:**

*true, if* **isValid()** *&& (***minValue()** *\>=* **maxValue()***)*

### bool QwtInterval::isValid () const` [inline]`

*A interval is valid when* **minValue()** *\<=* **maxValue()***. In case of* **QwtInterval::ExcludeBorders** *it is true when* **minValue()** *\<* **maxValue()**

**Returns:**

*True, when the interval is valid*

### QwtInterval QwtInterval::limited (double lowerBound, double upperBound) const

*Limit the interval, keeping the border modes*

**Parameters:**

*lowerBound Lower limit* \
 *upperBound Upper limit*

**Returns:**

*Limited interval*

### double QwtInterval::maxValue () const` [inline]`

**Returns:**

*Upper limit of the interval*

### double QwtInterval::minValue () const` [inline]`

**Returns:**

*Lower limit of the interval*

### QwtInterval QwtInterval::normalized () const

*Normalize the limits of the interval. If* **maxValue()** *\<* **minValue()** *the limits will be inverted.*

**Returns:**

*Normalized interval*

**See also:**

**isValid()***,* **inverted()**

### bool QwtInterval::operator!= (const QwtInterval & other) const` [inline]`

*Compare two intervals.*

**Parameters:**

*other Interval to compare with*

**Returns:**

*True, when this and other are not equal*

### bool QwtInterval::operator== (const QwtInterval & other) const` [inline]`

*Compare two intervals.*

**Parameters:**

*other Interval to compare with*

**Returns:**

*True, when this and other are equal*

### QwtInterval QwtInterval::operator\| (const QwtInterval & other) const` [inline]`

*Union of two intervals*

**Parameters:**

*other Interval to unite with*

**Returns:**

*Union of this and other*

**See also:**

**unite()**

### QwtInterval QwtInterval::operator\| (double value) const` [inline]`

*Extend an interval*

**Parameters:**

*value Value*

**Returns:**

*Extended interval*

**See also:**

**extend()**

### QwtInterval & QwtInterval::operator\|= (const QwtInterval & other)

*Unite this interval with the given interval.*

**Parameters:**

*other Interval to be united with*

**Returns:**

*This interval*

### QwtInterval & QwtInterval::operator\|= (double value)

*Extend an interval*

**Parameters:**

*value Value*

**Returns:**

*Reference of the extended interval*

**See also:**

**extend()**

### void QwtInterval::setBorderFlags (BorderFlags borderFlags)` [inline]`

*Change the border flags*

**Parameters:**

*borderFlags Or'd BorderMode flags*

**See also:**

**borderFlags()**

### void QwtInterval::setInterval (double minValue, double maxValue, BorderFlags borderFlags = IncludeBorders)` [inline]`

*Assign the limits of the interval*

**Parameters:**

*minValue Minimum value* \
 *maxValue Maximum value* \
 *borderFlags Include/Exclude borders*

### void QwtInterval::setMaxValue (double maxValue)` [inline]`

*Assign the upper limit of the interval*

**Parameters:**

*maxValue Maximum value*

### void QwtInterval::setMinValue (double minValue)` [inline]`

*Assign the lower limit of the interval*

**Parameters:**

*minValue Minimum value*

### QwtInterval QwtInterval::symmetrize (double value) const

*Adjust the limit that is closer to value, so that value becomes the center of the interval.*

**Parameters:**

*value Center*

**Returns:**

*Interval with value as center*

### double QwtInterval::width () const` [inline]`

*Return the width of an interval. The width of invalid intervals is 0.0, otherwise the result is* **maxValue()** *-* **minValue()***.*

**Returns:**

*Interval width*

**See also:**

**isValid()**

## Author

*Generated automatically by Doxygen for Qwt User's Guide from the source code.*