Contents of the HP-UX Math Libraries

Several of the most frequently used math functions are implemented in the millicode library as well as in the math library. The millicode versions have a streamlined calling sequence and are usually faster than their counterparts in the math library.

Millicode versions exist for the following Fortran and C functions. They have double-precision versions only, unless otherwise specified.

acos
asin
atan
atan2
cos       (single-precision also)
exp
log       (single-precision also)
log10
pow
sin       (single-precision also)
tan       (single-precision also)

Millicode versions exist for the following Pascal functions:

arctan
cos
exp
ln
sin

To get the millicode versions of any of these functions, compile your program with

With the f90 and f77 compiler commands, the +Olibcalls option is the default at optimization level 2 and above.

The +Olibcalls option is invoked by default when you specify the optimization type ­+Oaggressive; use +Oaggressive +Onolibcalls if you want aggressive optimization without using millicode routines. The millicode versions are implemented in the library /usr/lib/milli.a.

The millicode versions of functions do not provide standard-conforming error handling. This has different implications for different languages. In C programs, if an error occurs, the millicode versions return the same values as their standard library counterparts, but they do not set errno. Because the C and Pascal standards specify error handling for library functions, you should use millicode versions in C and Pascal programs only if your program does not require standard-conforming error handling. The Fortran standards do not specify error handling for math intrinsic functions, so using the millicode versions has no effect on standards compliance. See “Optimizing Your Program” for more information about optimization options.

	NOTE: The libM math library is obsolete. See “Overview of HP-UX Math Libraries” for details.

The C math library, libm, also supports

All of these functions are defined in math.h. However, all of these functions are outside the ANSI C specification, and many of them are outside the XPG4.2 specification. If you compile in strict ANSI mode (with the -Aa option), only the declarations of functions specified by the ANSI C standard are ordinarily visible to your program. Therefore, to make the additional functions visible, do one of the following:

	NOTE: To compile C++ programs that call nonstandard math library functions, use the +a1 option.

For a complete list of the contents of libm, see Appendix A “The C Math Library”. The functions are described in online man pages.

Certain libm math functions are implemented as single-precision functions, accepting float arguments and returning a float result. On HP 9000 systems, the performance of single-precision and double-­precision functions is similar. If your application uses single-­precision data types heavily, you may find it convenient to use the float versions of the math functions the application calls.

The names of the float functions are the same as those of their double-­precision counterparts but with the letter f appended. (For float versions of degree-valued trigonometric functions, the f follows the d.) This naming convention accords with that specified in Section 4.13 of the ANSI C standard, "Future Library Directions."

The supplied functions are as follows:

You must compile in ANSI mode (with -Ae, the default, or with -Aa -D_HPUX_SOURCE) to use these functions. If you compile in ANSI mode, ANSI C rules are followed, and the argument is treated as a float throughout the function call. If you do not compile in ANSI mode, traditional K&R C rules are followed, the compiler generates code to promote the argument to double, and the function call either generates a linker error or produces incorrect results. Therefore, use a command line like the following:

cc program_name.c -lm
 
CC +a1 program_name.C -lm

The Fortran math library defines a set of trigonometric functions whose arguments or results are specified in degrees rather than radians. These functions are also implemented in libm. The names of these functions are the same as the names of the standard versions but with the letter d appended: sind, cosd, and so on. (For float versions of degree-valued trigonometric functions, the f follows the d.)

To use these functions, compile them in any mode except strict ANSI mode (-Aa). Use either extended ANSI mode (-Ae, the default), non-ANSI mode (-Ac), or -Aa -D_HPUX_SOURCE.

The fpclassify macro is the HP version of the class function recommended by the IEEE standard. The ANSI/ISO C committee has also approved this macro for inclusion in the C9X standard. The fpclassify macro accepts either a double or a float argument. It returns an integer value that describes the class of the argument—that is, what kind of floating-point value it is. Table 4-1 “fpclassify Values” shows the values and their meanings, which are defined in math.h.

The list of classes is exhaustive: all IEEE floating-point values fall into one of these classes. The fpclassify macro never causes an exception, regardless of the operand. It is useful, therefore, for classifying an operand without risking an exception trap.

Use the signbit macro to determine whether a value is negative or positive.

To use the fpclassify macro, compile your program in any mode except strict ANSI mode (-Aa). Use either extended ANSI mode (-Ae, the default), non-ANSI mode (-Ac), or -Aa -D_HPUX_SOURCE.

The following C function shows how you might use fpclassify and signbit to display the class and value of a double-precision number:

Example 4-3 Sample Function: print_class.c

#include <math.h> #include <stdio.h> typedef union { double y; struct { unsigned int ym, yl; } i; } DBL_INT; void print_classd(DBL_INT di) { int class, sign; char *posneg[] = {"positive", "negative"}; class = fpclassify(di.y); sign = signbit(di.y); if (class == FP_NORMAL) printf("%19.17g is %s normalized (%08x%08x)\n", di.y, posneg[sign], di.i.ym, di.i.yl); else if (class == FP_ZERO) printf("%19.17g is %s zero (%08x%08x)\n", di.y, posneg[sign], di.i.ym, di.i.yl); else if (class == FP_INFINITE) printf("%19.17g is %s infinity (%08x%08x)\n", di.y, posneg[sign], di.i.ym, di.i.yl); else if (class == FP_SUBNORMAL) printf("%19.17g is %s denormalized (%08x%08x)\n", di.y, posneg[sign], di.i.ym, di.i.yl); else if (class == FP_NAN) printf("%19.17g is NaN (%08x%08x), sign bit is %d\n", di.y, di.i.ym, di.i.yl, sign); }

Other macros that test the class of a floating-point value are

See the online man pages for information about these macros.

The C math library provides several functions that are not specified by the ANSI C standard but that are required by the COSE Common API Specification (Spec 1170) and the XPG4.2 specification. These functions are

To use these functions, compile your program in any mode except strict ANSI mode (-Aa). Use either extended ANSI mode (-Ae, the default), non-ANSI mode (-Ac), or -Aa -D_HPUX_SOURCE.

The fenv(5) suite is a collection of functions in the C math library that allow an application to manipulate various modifiable control modes and status flags in the ­floating-point status register. Most of the functions in the fenv(5) suite have been approved by the ISO/ANSI C committee for inclusion in the C9X draft standard.

For details on how to use these functions, see Chapter 5 “Manipulating the Floating-Point Status Register” and the online man pages. The tables in Appendix A “The C Math Library” also list all of the functions.