C H A P T E R 2 
C++ Interval Arithmetic Library Reference 
This chapter is a reference for the syntax and semantics of the interval arithmetic library implemented in Sun Studio C++. The sections can be read in any order.
Throughout this document, unless explicitly stated otherwise, integer and floatingpoint constants mean literal constants. Literal constants are represented using strings, because class types do not support literal constants. Section 2.1.1, String Representation of an Interval Constant (SRIC).
TABLE 21 shows the character set notation used for code and mathematics.

Note  Pay close attention to font usage. Different fonts represent an interval's exact, external mathematical value and an interval's machinerepresentable, internal approximation. 
In C++, it is possible to define variables of a class type, but not literal constants. So that a literal interval constant can be represented, the C++ interval class uses a string to represent an interval constant. A string representation of an interval constant (SRIC) is a character string containing one of the following:
Quotation marks delimit the string. If a degenerate interval is not machine representable, directed rounding is used to round the exact mathematical value to an internal machine representable interval known to satisfy the containment constraint.
A SRIC, such as "[0.1]" or "[0.1,0.2]", is associated with the two values: its external value and its internal approximation. The numerical value of a SRIC is its internal approximation. The external value of a SRIC is always explicitly labelled as such, by using the notation ev(SRIC). For example, the SRIC "[1, 2]" and its external value ev("[1, 2]") are both equal to the mathematical value [1, 2]. However, while ev("[0.1, 0.2]") = [0.1, 0.2], interval<double>("[0.1, 0.2]") is only an internal machine approximation containing [0.1, 0.2], because the numbers 0.1 and 0.2 are not machine representable.
Like any mathematical constant, the external value of a SRIC is invariant.
Because intervals are opaque, there is no language requirement to use any particular interval storage format to save the information needed to internally approximate an interval. Functions are provided to access the infimum and supremum of an interval. In a SRIC containing two interval endpoints, the first number is the infimum or lower bound, and the second is the supremum or upper bound.
If a SRIC contains only one integer or real number in square brackets, the represented interval is degenerate, with equal infimum and supremum. In this case, an internal interval approximation is constructed that is guaranteed to contain the SRIC's single decimal external value. If a SRIC contains only one integer or real number without square brackets, single number conversion is used. See Section 2.8.1, Input.
A valid interval must have an infimum that is less than or equal to its supremum. Similarly, a SRIC must also have an infimum that is less than or equal to its supremum. For example, the following code fragment must evaluate to true:
inf(interval<double>("[0.1]") <= sup(interval<double>("[0.1]"))
CODE EXAMPLE 21 contains examples of valid and invalid SRICs.
For additional information regarding SRICs, see the supplementary paper [4] cited in Section 2.12, References.
Constructing an interval approximation from a SRIC is an inefficient operation that should be avoided, if possible. In CODE EXAMPLE 22, the interval<double> constant Y is constructed only once at the start of the program, and then its internal representation is used thereafter.
The internal approximation of a floatingpoint constant does not necessarily equal the constant's external value. For example, because the decimal number 0.1 is not a member of the set of binary floatingpoint numbers, this value can only be approximated by a binary floatingpoint number that is close to 0.1. For floatingpoint data items, the approximation accuracy is unspecified in the C++ standard. For interval data items, a pair of floatingpoint values is used that is known to contain the set of mathematical values defined by the decimal numbers used to symbolically represent an interval constant. For example, the mathematical interval [0.1, 0.2] is represented by a string "[0.1,0.2]".
Just as there is no C++ language requirement to accurately approximate floatingpoint constants, there is also no language requirement to approximate an interval's external value with a narrow width interval internal representation. There is a requirement for an interval internal representation to contain its external value.
ev(inf(interval<double>("[0.1,0.2]")))
inf(ev("[0.1,0.2]")) = inf([0.1, 0.2])
sup([0.1, 0.2]) = sup(ev("[0.1,0.2]")) ev(sup(interval<double>("[0.1,0.2]")))
C++ interval internal representations are sharp. This is a quality of implementation feature.
The following interval constructors are supported:
The following interval constructors guarantee containment:
interval( const char*) ; interval( const interval<float>& ) ; interval( const interval<double>& ) interval( const interval<long double>& ) ; 
The argument interval is rounded outward, if necessary.
The interval constructor with noninterval arguments returns [inf,inf] if either the second argument is less then the first, or if either argument is not a mathematical real number, such as when one or both arguments is a NaN.
Interval constructors with floatingpoint or integer arguments might not return an interval that contains the external value of constant arguments.
For example, use interval<double>("[1.1,1.3]") to sharply contain the mathematical interval [1.1, 1.3]. However, interval<double>(1.1,1.3) might not contain [1.1, 1.3], because the internal values of floatingpoint literal constants are approximated with unknown accuracy.
The result value of an interval constructor is always a valid interval.
The interval_hull function can be used with an interval constructor to construct an interval containing two floatingpoint numbers, as shown in CODE EXAMPLE 24.
The three examples in this section illustrate how to use the interval constructor to perform conversions from floatingpoint to intervaltype data items. CODE EXAMPLE 25 shows that floatingpoint expression arguments of the interval constructor are evaluated using floatingpoint arithmetic.
CODE EXAMPLE 25 notes:
CODE EXAMPLE 26 shows how the interval constructor can be used to create the smallest possible interval, Y, such that the endpoints of Y are not elements of a given interval, X.
Given an interval X, a sharp interval Y satisfying the condition in_interior(X,Y) is constructed. For information on the interior set relation, Section 2.6.3, Interior: in_interior(X,Y).
CODE EXAMPLE 27 illustrates when the interval constructor returns the interval
[inf, inf] and [max_float, inf].
CODE EXAMPLE 27 notes:
interval arithmetic expressions are constructed from the same arithmetic operators as other numerical data types. The fundamental difference between interval and noninterval (point) expressions is that the result of any possible interval expression is a valid interval that satisfies the containment constraint of interval arithmetic. In contrast, point expression results can be any approximate value.
TABLE 22 lists the operators and functions that can be used with intervals. In TABLE 22, X and Y are intervals.
Some intervalspecific functions have no point analogs. These can be grouped into three categories: set, certainly, and possibly, as shown in TABLE 23. A number of unique setoperators have no certainly or possibly analogs.


Except for the in function, interval relational functions can only be applied to two interval operands with the same type.
The first argument of the in function is of any integer or floatingpoint type. The second argument can have any interval type.
All the interval relational functions and operators return an interval_booltype result.
Formulas for computing the endpoints of interval arithmetic operations on finite floatingpoint intervals are motivated by the requirement to produce the narrowest interval that is guaranteed to contain the set of all possible point results. Ramon Moore independently developed these formulas and more importantly, was the first to develop the analysis needed to apply interval arithmetic. For more information, see Interval Analysis by R. Moore (PrenticeHall, 1966).
The set of all possible values was originally defined by performing the operation in question on any element of the operand intervals. Therefore, given finite intervals, [a, b] and [c, d], with ,
with division by zero being excluded. Implementation formulas, or their logical equivalent, are:
Directed rounding is used when computing with finite precision arithmetic to guarantee the set of all possible values is contained in the resulting interval.
The set of values that any interval result must contain is called the containment set (cset) of the operation or expression that produces the result.
To include extended intervals (with infinite endpoints) and division by zero, csets can only indirectly depend on the value of arithmetic operations on real operands. For extended intervals, csets are required for operations on points that are normally undefined. Undefined operations include the indeterminate forms:
The containmentset closure identity solves the problem of identifying the value of containment sets of expressions at singular or indeterminate points. The identity states that containment sets are function closures. The closure of a function at a point on the boundary of its domain includes all limit or accumulation points. For details, see the Glossary and the supplementary papers [1], [3], [10], and [11] cited in Section 2.12, References.
The following is an intuitive way to justify the values included in an expression's cset. Consider the function
The question is: what is the cset of h(x_{0}), for x_{0} = 0 ? To answer this question, consider the function
Clearly, f(x_{0}) = 0, for x_{0} = 0. But, what about
The function g(x_{0}) is undefined for x_{0} = 0, because h(x_{0}) is undefined. The cset of h(x_{0}) for x_{0} = 0 is the smallest set of values for which g(x_{0}) = f(x_{0}). Moreover, this must be true for all composite functions of h. For example if
then g(x) = g'(h(x)). In this case, it can be proved that the cset of h(x_{0}) = if x_{0}= 0, where denotes the setconsisting of the two values, and .
TABLE 24 through TABLE 27, contain the csets for the basic arithmetic operations. It is convenient to adopt the notation that an expression denoted by f(x) simply means its cset. Similarly, if
the containment set of f over the interval X, then hull(f(x)) is the sharp interval that contains f(X).














All inputs in the tables are shown as sets. Results are shown as sets or intervals. Customary notation, such as , , and , is used, with the understanding that csets are implied when needed. Results for general set (or interval) inputs are the union of the results of the singlepoint results as they range over the input sets (or intervals).
In one case, division by zero, the result is not an interval, but the set, . In this case, the narrowest interval in the current system that does not violate the containment constraint of interval arithmetic is the interval .
Sign changes produce the expected results.
To incorporate these results into the formulas for computing interval endpoints, it is only necessary to identify the desired endpoint, which is also encoded in the rounding direction. Using to denote rounding down (towards ) and to denote rounding up (towards +),
Finally, the empty interval is represented in C++ by the character string [empty] and has the same properties as the empty set, denoted in the algebra of sets. Any arithmetic operation on an empty interval produces an empty interval result. For additional information regarding the use of empty intervals, see the supplementary papers [6] and [7] cited in Section 2.12, References.
Using these results, C++ implements the closed interval system. The system is closed because all arithmetic operations and functions always produce valid interval results. See the supplementary papers [2] and [8] cited in Section 2.12, References.
The power function can be used with integer or continuous exponents. With a continuous exponent, the power function has indeterminate forms, similar to the four arithmetic operators.
In the integer exponents case, the set of all values that an enclosure of must contain is .
Monotonicity can be used to construct a sharp interval enclosure of the integer power function. When n= 0, Xn, which represents the cset of Xn,is 1 for all , and for all n.
In the continuous exponents case, the set of all values that an interval enclosure of X**Y must contain is
where and exp(y(ln(x))) are their respective containment sets. The function exp(y(ln(x))) makes explicit that only values of x 0 need be considered, and is consistent with the definition of X**Ywith REALarguments in C++.
The result is empty if either interval argument is empty, or if sup(X) < 0.
TABLE 28 displays the containment sets for all the singularities and indeterminate forms of exp(y(ln(x))).
The results in TABLE 28 can be obtained in two ways:
For most compositions, the second option is much easier. If sufficient conditions are satisfied, the closure of a composition can be computed from the composition of its closures. That is, the closure of each subexpression can be used to compute the closure of the entire expression. In the present case,
exp(y(ln(x))) = exp(y_{0} × ln(x_{0})).
That is, the cset of the expression on the left is equal to the composition of csets on the right.
exp(y(ln(x))) exp(y_{0} × ln(x_{0})).
Note that this is exactly how interval arithmetic works on intervals. The needed closures of the ln and exp functions are:
A necessary condition for closurecomposition equality is that the expression must be a singleuse expression (or SUE), which means that each independent variable can appear only once in the expression.
In the present case, the expression is clearly a SUE.
The entries in TABLE 28 follow directly from using the containment set of the basic multiply operation in TABLE 26 on the closures of the ln and exp functions. For example, with x_{0 }= 1 and y_{0 }= , ln(x_{0}) = 0. For the closure of multiplication on the values  and 0 in TABLE 26, the result is [, +]. Finally, exp([, +]) = [0, +], the second entry in TABLE 28. Remaining entries are obtained using the same steps. These same results are obtained from the direct derivation of the containment set of exp(y(ln(x))). At this time, sufficient conditions for closurecomposition equality of any expression have not been identified. Nevertheless, the following statements apply:
C++ supports the following set theoretic functions for determining the interval hull and intersection of two intervals.
CODE EXAMPLE 28 demonstrates the use of the intervalspecific functions listed in TABLE 29.


Description: Interval hull of two intervals. The interval hull is the smallest interval that contains all the elements of the operand intervals.
Arguments: X and Y must be intervals with the same type.
Description: Intersection of two intervals.
Mathematical and operational definitions:
Arguments: X and Y must be intervals with the same type.
C++ provides the following set relations that have been extended to support intervals.
Description: Test if two intervals are disjoint.
Mathematical and operational definitions:
Arguments: X and Y must be intervals with the same type.
Description: Test if the number, r, is an element of the interval, Y.
Mathematical and operational definitions:
Arguments: The type of r is an integer or floatingpoint type, and the type of Y is interval.
The following comments refer to the set relation:
Description: Test if X is in interior of Y.
The interior of a set in topological space is the union of all open subsets of the set.
For intervals, the function in_interior(X,Y) means that X is a subset of Y, and both of the following relations are false:
Note also that, , but in_interior([empty],[empty])= true
The empty set is open and therefore is a subset of the interior of itself.
Mathematical and operational definitions:
Arguments: X and Y must be intervals with the same type.
Description: Test if X is a proper subset of Y
Mathematical and operational definitions:
Arguments: X and Y must be intervals with the same type.
Description:Seeproper subset with .
Description: Test if X is a subset of Y
Mathematical and operational definitions:
Arguments: X and Y must be intervals with the same type.
Ordering intervals is more complicated than ordering points. Testing whether 2 is less than 3 is unambiguous. With intervals, while the interval [2,3] is certainly less than the interval [4,5], what should be said about [2,3] and [3,4]?
Three different classes of interval relational functions are implemented:
For a certainlyrelation to be true, every element of the operand intervals must satisfy the relation. A possiblyrelation is true if it is satisfied by any elements of the operand intervals. The setrelations treat intervals as sets. The three classes of interval relational functions converge to the normal relational functions on points if both operand intervals are degenerate.
To distinguish the three function classes, the twoletter relation mnemonics (lt, le, eq, ne, ge, and gt) are prefixed with the letters c, p, or s. The functions seq(X,Y) and sne(X,Y) correspond to the operators == and !=. In all other cases, the relational function class must be explicitly identified, as for example in:
See Section 2.4, Operators and Functions for the syntax and semantics of all interval functions.
The following program demonstrates the use of a setequality test.
CODE EXAMPLE 29 uses the setequality test to verify that X+Y is equal to the interval [6, 8] using the == operator.
Use CODE EXAMPLE 210 and CODE EXAMPLE 28 to explore the result of intervalspecific relational functions.
An interval relational function, denoted qop, is composed by concatenating both of the following:
In place of seq(X,Y) and sne(X,Y), == and != operators are accepted. To eliminate code ambiguity, all other interval relational functions must be made explicit by specifying a prefix.
Letting "nop" stand for the complement of the operator op, the certainly and possibly functions are related as follows:
Assuming neither argument is empty, TABLE 210 contains the C++ operational definitions of all interval relational functions of the form:
qop(X,Y), given X = [x,x] and Y = [y,y]).
The first column contains the value of the prefix, and the first row contains the value of the operator suffix. If the tabled condition holds, the result is true.
For an affirmative order relation with
between two points x and y, the mathematical definition of the corresponding setrelation, Sop, between two nonempty intervals X and Y is:
For the relation between two points x and y, the corresponding set relation, sne(X,Y), between two nonempty intervals X and Y is:
Empty intervals are explicitly considered in each of the following relations. In each case:
Arguments: X and Y must be intervals with the same type.
Description: Test if two intervals are setequal.
Mathematical and operational definitions:
Any interval is setequal to itself, including the empty interval. Therefore, seq([a,b],[a,b]) is true.
Description:See setlessorequal with .
Description:See setless with .
Description: Test if one interval is setlessorequal to another.
Mathematical and operational definitions:
Any interval is setequal to itself, including the empty interval. Therefore sle([X,X]) is true.
Description: Test if one interval is setless than another.
Description: Test if two intervals are not setequal.
Mathematical and operational definitions:
Any interval is setequal to itself, including the empty interval. Therefore sne([X,X]) is false.
Thecertainly relational functions are true if the underlying relation is true for every element of the operand intervals. For example, clt([a,b],[c,d])is true if x< yfor all and . This is equivalent to b< c.
For an affirmative order relation with
between two points x and y, the corresponding certainlytrue relation cop between two intervals, X and Y, is
With the exception of the antiaffirmative certainlynotequal relation, if either operand of a certainly relation is empty, the result is false. The one exception is the certainlynotequal relation, cne(X,Y), which is true in this case.
Mathematical and operational definitions cne(X,Y):
For each of the certainly relational functions:
Arguments: X and Y must be intervals with the same type.
The possibly relational functions are true if any element of the operand intervals satisfy the underlying relation. For example, plt([X,Y])is true if there exists an and a such that x< y. This is equivalent to .
For an affirmative order relation with
between two points x and y, the corresponding possiblytrue relation Pop between two intervals X and Y is defined as follows:
If the empty interval is an operand of a possibly relation then the result is false. The one exception is the antiaffirmative possiblynotequal relation, pne(X,Y), which is true in this case.
Mathematical and operational definitions pne(X,Y):
For each of the possibly relational functions:
Arguments: X and Y must be intervals with the same type.
The process of performing interval stream input/output is the same as for other noninterval data types.
Note  Floatingpoint stream manipulations do not influence interval input/output. 
When using the singlenumber form of an interval, the last displayed digit is used to determine the interval's width. See Section 2.8.2, SingleNumber Output. For more detailed information, see M. Schulte, V. Zelov, G.W. Walster, D. Chiriaev, "SingleNumber Interval I/O," Developments in Reliable Computing, T. Csendes (ed.), (Kluwer 1999).
If an infimum is not internally representable, it is rounded down to an internal approximation known to be less than the exact value. If a supremum is not internally representable, it is rounded up to an internal approximations known to be greater than the exact input value. If the degenerate interval is not internally representable, it is rounded down and rounded up to form an internal interval approximation known to contain the exact input value. These results are shown in CODE EXAMPLE 211.
The function single_number_output() is used to display intervals in the singlenumber form and has the following syntax, where cout is an output stream.
single_number_output(interval<float> X, ostream& out=cout) single_number_output(interval<double> X, ostream& out=cout) single_number_output(interval<long double> X, ostream& out=cout) 
If the external interval value is not degenerate, the output format is a floatingpoint or integer literal (X without square brackets, "["..."]"). The external value is interpreted as a nondegenerate mathematical interval [x] + [1,1]_{uld}.
The singlenumber interval representation is often less precise than the [inf, sup] representation. This is particularly true when an interval or its singlenumber representation contains zero or infinity.
For example, the external value of the singlenumber representation for [15, +75] is ev([0E2]) = [100, +100]. The external value of the singlenumber representation for [1, ] is ev([0E+inf]) = .
In these cases, to produce a narrower external representation of the internal approximation, the [inf, sup] form is used to display the maximum possible number of significant digits within the output field.
If it is possible to represent a degenerate interval within the output field, the output string for a single number is enclosed in obligatory square brackets, "[", ... "]" to signify that the result is a point.
An example of using ndigits to display the maximum number of significant decimal digits in the singlenumber representation of the nonempty interval X is shown in CODE EXAMPLE 213.
Note  If the argument of ndigits is a degenerate interval, the result is int_max. 
Increasing interval width decreases the number of digits displayed in the singlenumber representation. When the interval is degenerate all remaining positions are filled with zeros and brackets are added if the degenerate interval value is represented exactly.
Singlenumber interval input, immediately followed by output, can appear to suggest that a decimal digit of accuracy has been lost, when in fact radix conversion has caused a 1 or 2 ulp increase in the width of the stored input interval. For example, an input of 1.37 followed by an immediate print will result in 1.3 being output.
As shown in CODE EXAMPLE 16, programs must use character input and output to exactly echo input values and internal reads to convert input character strings into valid internal approximations.
This section lists the typeconversion, trigonometric, and other functions that accept intervalarguments. The symbols and in the interval are used to denote its ordered elements, the infimum, or lower bound and supremum, or upper bound, respectively. In point (noninterval) function definitions, lowercase letters xand yare used to denote floatingpoint or integer values.
When evaluating a function, f, of an interval argument, X, the interval result, f(X), must be an enclosure of its containment set, f(x). Therefore,
A similar result holds for functions of nvariables. Determining the containment set of values that must be included when the interval contains values outside the domain of fis discussed in the supplementary paper [1] cited in Section 2.12, References. The results therein are needed to determine the set of values that a function can produce when evaluated on the boundary of, or outside its domain of definition. This set of values, called the containment setis the key to defining interval systems that return valid results, no matter what the value of a function's arguments or an operator's operands. As a consequence, there are no argument restrictions on any intervalfunctions in C++.
This sections provides additional information about the inverse tangent function. For further details, see the supplementary paper [9] cited in Section 2.12, References.
Description: Interval enclosure of the inverse tangent function over a pair of intervals.
Special values: TABLE 211 and CODE EXAMPLE 214 display the atan2 indeterminate forms.














Result value: The interval result value is an enclosure for the specified interval. An ideal enclosure is an interval of minimum width that contains the exact mathematical interval in the description.
The result is empty if one or both arguments are empty.
In the case where x< 0 and , to get a sharp interval enclosure (denoted by ), the following convention uniquely defines the set of all possible returned interval angles:
This convention, together with
results in a unique definition of the interval angles that atan2(Y,X) must include.
TABLE 212 contains the tests and arguments of the floatingpoint atan2 function that are used to compute the endpoints of in the algorithm that satisfies the constraints required to produce sharp interval angles. The first two columns define the distinguishing cases. The third column contains the range of possible values of the midpoint, m(), of the interval . The last two columns show how the endpoints of are computed using the floatingpoint atan2 function. Directed rounding must be used to guarantee containment.










Description: Range of maximum.
The containment set for max(X_{1},..., X_{n}) is:
The implementation of the max function must satisfy:
maximum(X1,X2,[X3,...]){max(X_{1}, ..., X_{n})}.
Description: Range of minimum.
The containment set for min(X_{1},..., X_{n}) is:
The implementation of the min function must satisfy:
minimum(X1,X2,[X3,...]){min(X_{1}, ..., X_{n})}.
TABLE 214 through TABLE 218 list the properties of functions that accept interval arguments. TABLE 213 lists the tabulated properties of interval functions in these tables.
Because indeterminate forms are possible, special values of the pow and atan2 function are contained in Section 2.4.2, Power Function pow(X,n) and pow(X,Y) and Section 2.9.1, Inverse Tangent Function atan2(Y,X), repectively. The remaining functions do not require this treatment.
interval<float>, interval<double>, or interval<long double> for each argument type. 
^{(1) The minimum and maximum functions ignore empty interval arguments unless all arguments are empty, in which case, the empty interval is returned.} 

^{(1) arctan(a/b) = , given a = h sin, b = h cos, and h2 = a2 + b2.} 

When interval types are used as template arguments for STL classes, a blank must be inserted between two consecutive > symbols, as shown on the line marked note 1 in CODE EXAMPLE 215.
Otherwise, >> is incorrectly interpreted as the right shift operator, as shown on the line marked note 1 in CODE EXAMPLE 216.
Note  Interpreting >> as a right shift operator is a general design problem in C++. 
The C++ interval arithmetic library includes the nvector<T> and nmatrix<T> template classes. The nvector<T> class represents and manipulates onedimensional arrays of values. The nmatrix<T> class represents and manipulates twodimensional arrays of values.
The nvector<T> class represents and manipulates onedimensional arrays of values. Elements in a vector are indexed sequentially beginning with zero.
Template specializations are available for the following types:
To write applications that use objects and operations of nvector<T> class, use the following header files and namespace:
#include <suninterval_vector.h>
using namespace SUNW_interval;
Note  Because these classes are based on the C++ standard library, the classes are not available in compatibility mode (compat). 
For a detailed description of the nvector<T> class, see the nvector(3C++) man page.
CODE EXAMPLE 217 illustrates the nvector class usage.
The nmatrix<T> class represents and manipulates twodimensional arrays of values. Arrays are stored internally in columnmajor order (FORTRANstyle). Indexes of matrix elements begin with zero.
Template specializations are available for the following types:
To write applications that use objects and operations of nmatrix<T> class use the following header files and namespace:
#include <suninterval_matrix.h>
using namespace SUNW_interval;
Note  Because these classes are based on the C++ standard library, the classes are not available in compatibility mode (compat). 
For a detailed description of the nmatrix<T> class, see the nmatrix(3C++) man page.
CODE EXAMPLE 218 illustrates the nvector class usage.
The following technical reports are available online. See the interval arithmetic readme for the location of these files.
1. G.W. Walster, E.R. Hansen, and J.D. Pryce, "Extended Real Intervals and the Topological Closure of Extended Real Relations," Technical Report, Sun Microsystems. February 2000.
2. G. William Walster, "Empty Intervals," Technical Report, Sun Microsystems. April 1998.
3. G. William Walster, "Closed Interval Systems," Technical Report, Sun Microsystems. August 1999.
4. G. William Walster, "Literal Interval Constants," Technical Report, Sun Microsystems. August 1999.
5. G. William Walster, "WidestNeed Interval Expression Evaluation," Technical Report, Sun Microsystems. August 1999.
6. G. William Walster, "Compiler Support of Interval Arithmetic With Inline Code Generation and Nonstop Exception Handling," Technical Report, Sun Microsystems. February 2000.
7. G. William Walster, "Finding Roots on the Edge of a Function's Domain," Technical Report, Sun Microsystems. February 2000.
8. G. William Walster, "Implementing the `Simple' Closed Interval System," Technical Report, Sun Microsystems. February 2000.
9. G. William Walster, "Interval Angles and the Fortran ATAN2 Intrinsic Function," Technical Report, Sun Microsystems. February 2000.
10. G. William Walster, "The `Simple' Closed Interval System," Technical Report, Sun Microsystems. February 2000.
11. G. William Walster, Margaret S. Bierman, "Interval Arithmetic in Forte Developer Fortran," Technical Report, Sun Microsystems. March 2000.
Copyright © 2005, Sun Microsystems, Inc. All Rights Reserved.