A RealBox object is defined by two numeric quantities, a center $c$ and a non-negative radius $r$.

You can access the center of a RealBox b by using the Center( b ) method, and the radius is available by using the Radius( b ) method.

The method Centre is provided as an alias.

Internally, RealBox objects represent the (finite) centre and radius as binary fractions (that is, with powers of 2 as their denominators). You can access the exact centre and radius by supplying the option form = rational.

If the radius is finite, then a RealBox represents a closed and bounded interval of the real line, namely $\left[c-r\,c+r\right]$. In particular, a RealBox with radius equal to $0$ represents the single point $c$.

If the radius is infinite, the corresponding RealBox represents the entire real line.

RealBox objects can be combined using arithmetic operations, and have methods that allow you to apply many mathematical functions to them. These operations are effected using a version of interval arithmetic, adapted to boxes.

Arithmetic and mathematical functions applied to a real box also produce a real box as output. The result of an operation is guaranteed to contain the true value of the result of applying the function or arithmetic operation to any value of the input box or boxes. Thus, if $f$ is an implemented function, then $f\left(\left[c-r\,c+r\right]\right)$ is a box of the form $\left[x-s\,x+s\right]$, where $x$ and $s$ are such that, for any value $t$ in the box $\left[c-r\,c+r\right]$, the value $f\left(t\right)$ lies in the box $\left[x-s\,x+s\right]$.

Operations such as arithmetic and the implemented elementary and special functions are controlled by a quantity called the precision. This is a positive integer value that you can set by assigning a value to the environment variable _EnvBoxPrecision.

Many methods for RealBox objects also accept an option of the form precision = n, for a positive integer n, which allows you to exert local control over precision.

For more details, see BoxPrecision.

The simplest way to create a RealBox object is to pass the RealBox constructor a real constant.

To create a real box with a numeric value c as its center, and with radius equal to $0$, just pass the value c to the RealBox object.

b := RealBox( 0.5 );

$b≔⟨\text{RealBox:}0.5\pm 0⟩$

Center( b );

$0.500000000000000$

Radius( b );

$0.$

This uses the default value of $0$ as the radius, which means that the box object represents the value of its center exactly.

To specify a nonzero radius, the radius argument r can be passed as a second, optional argument.

b := RealBox( 0.5, 1e-5 );

$b≔⟨\text{RealBox:}0.5\pm 1e-05⟩$

Center( b );

$0.500000000000000$

Radius( b );

$0.0000100000000031741$

However, the actual radius of a RealBox object depends upon not only the value passed, but also the precision used for construction, as not all values can be exactly represented in floating point.

The rational number $\frac{3}{2}$ can be represented exactly as a float.

b1 := RealBox( 3/2 );

$\mathrm{b1}≔⟨\text{RealBox:}1.5\pm 0⟩$

Thus, the radius of the resulting box is, in fact, the default value of $0$.

Radius( b1 );

$0.$

On the other hand, the number $\frac{2}{3}$ is not exactly representable, so the radius of a RealBox representation is nonzero.

b2 := RealBox( 2/3 );

$\mathrm{b2}≔⟨\text{RealBox:}0.666667\pm \mathrm{5.82077\ⅇ-11}⟩$

The resulting radius is sufficient to ensure that the exact value $\frac{2}{3}$ is contained within the resulting box.

Radius( b2 );

$5.82076609134674\times {10}^{\mathrm{-11}}$

evalb( Center( b2 ) - Radius( b2 ) <= 2/3 );

$\mathrm{true}$

evalb( 2/3 <= Center( b2 ) + Radius( b2 )  );

$\mathrm{true}$

Increasing the precision results in a box with smaller radius.

b3 := RealBox( 2/3, precision = 100 );

$\mathrm{b3}≔⟨\text{RealBox:}0.666667\pm \mathrm{7.88861\&ExponentialE;-31}⟩$

We can find the exact rational numbers representing the interval using the option form = rational.

cb3 := Center(b3, form = rational);

$\mathrm{cb3}≔\frac{845100400152152934331135470251}{1267650600228229401496703205376}$

evalf(abs(cb3 - 2/3));

$2.629536351\times {10}^{\mathrm{-31}}$

rb3 := Radius(b3, form = rational);

$\mathrm{rb3}≔\frac{1}{1267650600228229401496703205376}$

ifactor(rb3);

$\frac{1}{{\left(2\right)}^{100}}$

evalf(rb3);

$7.888609052\times {10}^{\mathrm{-31}}$

There are several special values and constants implemented that can be passed as an argument to the RealBox object constructor. For some of these, such as infinities, it is not meaningful to specify a nonzero radius. For special constants, the implemented algorithms by default return a RealBox object with a radius determined by the precision.

RealBox( Pi );

$⟨\text{RealBox:}3.14159\pm \mathrm{1.16415\&ExponentialE;-10}⟩$

RealBox( Pi, 0.001 );

$⟨\text{RealBox:}3.14159\pm 0.001⟩$

RealBox( Pi, 'precision' = 1000 );

$⟨\text{RealBox:}3.14159\pm \mathrm{1.86653\&ExponentialE;-301}⟩$

RealBox( sqrt( Pi ) );

$⟨\text{RealBox:}1.77245\pm \mathrm{1.16415\&ExponentialE;-10}⟩$

RealBox( ln( sqrt( 2*Pi ) ) );

$⟨\text{RealBox:}0.918939\pm \mathrm{3.40258\&ExponentialE;-10}⟩$

RealBox( log( 2 ), 'precision' = 100 );

$⟨\text{RealBox:}0.693147\pm \mathrm{3.94430\&ExponentialE;-31}⟩$

RealBox( log( 10 ) );

$⟨\text{RealBox:}2.30259\pm \mathrm{2.32831\&ExponentialE;-10}⟩$

RealBox( exp( 1 ) );

$⟨\text{RealBox:}2.71828\pm \mathrm{2.32831\&ExponentialE;-10}⟩$

RealBox( Catalan );

$⟨\text{RealBox:}0.915966\pm \mathrm{5.82077\&ExponentialE;-11}⟩$

RealBox( gamma );

$⟨\text{RealBox:}0.577216\pm \mathrm{5.82077\&ExponentialE;-11}⟩$

RealBox( Zeta( 3 ) );

$⟨\text{RealBox:}1.20206\pm \mathrm{1.16415\&ExponentialE;-10}⟩$

RealBox( infinity );

$⟨\text{RealBox:}\mathrm{Inf}\pm 0⟩$

RealBox( -infinity );

$⟨\text{RealBox:}\mathrm{-Inf}\pm 0⟩$

RealBox( undefined );

$⟨\text{RealBox:}\mathrm{nan}\pm 0⟩$

Note the following raises an exception.

RealBox( infinity, 0.0001 );

Error, (in RealBox:-ModuleCopy) a non-zero radius is not permitted for special values

A number of predicates are implemented for RealBox objects. Typically, a predicate returns true if the result is certainly true for all real numbers in the box. If a predicate returns the value false, then the result may or may not be true for all values lying within the box. Thus, to determine whether a predicate is certainly false, you must also test whether the negated predicate is true.

Many of the elementary functions are implemented as RealBox methods. A list of the available functions appears below.

The following circular and hyperbolic functions are available as methods for RealBox objects.

Many special and hypergeometric functions have been provided as RealBox object methods, as listed below.

The RealBox command was introduced in Maple 2022.

For more information on Maple 2022 changes, see Updates in Maple 2022.