gfiber / toolchains / mindspeed / 3836abf28a546a4a9a1b739cff0d1cb8ee89ee8a / . / arm-buildroot-linux-gnueabi / sysroot / usr / share / info / libc.info-8

This is libc.info, produced by makeinfo version 5.2 from libc.texinfo. | |

This file documents the GNU C Library. | |

This is 'The GNU C Library Reference Manual', for version 2.19 | |

(Buildroot). | |

Copyright (C) 1993-2014 Free Software Foundation, Inc. | |

Permission is granted to copy, distribute and/or modify this document | |

under the terms of the GNU Free Documentation License, Version 1.3 or | |

any later version published by the Free Software Foundation; with the | |

Invariant Sections being "Free Software Needs Free Documentation" and | |

"GNU Lesser General Public License", the Front-Cover texts being "A GNU | |

Manual", and with the Back-Cover Texts as in (a) below. A copy of the | |

license is included in the section entitled "GNU Free Documentation | |

License". | |

(a) The FSF's Back-Cover Text is: "You have the freedom to copy and | |

modify this GNU manual. Buying copies from the FSF supports it in | |

developing GNU and promoting software freedom." | |

INFO-DIR-SECTION Software libraries | |

START-INFO-DIR-ENTRY | |

* Libc: (libc). C library. | |

END-INFO-DIR-ENTRY | |

INFO-DIR-SECTION GNU C library functions and macros | |

START-INFO-DIR-ENTRY | |

* ALTWERASE: (libc)Local Modes. | |

* ARGP_ERR_UNKNOWN: (libc)Argp Parser Functions. | |

* ARG_MAX: (libc)General Limits. | |

* BC_BASE_MAX: (libc)Utility Limits. | |

* BC_DIM_MAX: (libc)Utility Limits. | |

* BC_SCALE_MAX: (libc)Utility Limits. | |

* BC_STRING_MAX: (libc)Utility Limits. | |

* BRKINT: (libc)Input Modes. | |

* BUFSIZ: (libc)Controlling Buffering. | |

* CCTS_OFLOW: (libc)Control Modes. | |

* CHILD_MAX: (libc)General Limits. | |

* CIGNORE: (libc)Control Modes. | |

* CLK_TCK: (libc)Processor Time. | |

* CLOCAL: (libc)Control Modes. | |

* CLOCKS_PER_SEC: (libc)CPU Time. | |

* COLL_WEIGHTS_MAX: (libc)Utility Limits. | |

* CPU_CLR: (libc)CPU Affinity. | |

* CPU_ISSET: (libc)CPU Affinity. | |

* CPU_SET: (libc)CPU Affinity. | |

* CPU_SETSIZE: (libc)CPU Affinity. | |

* CPU_ZERO: (libc)CPU Affinity. | |

* CREAD: (libc)Control Modes. | |

* CRTS_IFLOW: (libc)Control Modes. | |

* CS5: (libc)Control Modes. | |

* CS6: (libc)Control Modes. | |

* CS7: (libc)Control Modes. | |

* CS8: (libc)Control Modes. | |

* CSIZE: (libc)Control Modes. | |

* CSTOPB: (libc)Control Modes. | |

* DES_FAILED: (libc)DES Encryption. | |

* DTTOIF: (libc)Directory Entries. | |

* E2BIG: (libc)Error Codes. | |

* EACCES: (libc)Error Codes. | |

* EADDRINUSE: (libc)Error Codes. | |

* EADDRNOTAVAIL: (libc)Error Codes. | |

* EADV: (libc)Error Codes. | |

* EAFNOSUPPORT: (libc)Error Codes. | |

* EAGAIN: (libc)Error Codes. | |

* EALREADY: (libc)Error Codes. | |

* EAUTH: (libc)Error Codes. | |

* EBACKGROUND: (libc)Error Codes. | |

* EBADE: (libc)Error Codes. | |

* EBADF: (libc)Error Codes. | |

* EBADFD: (libc)Error Codes. | |

* EBADMSG: (libc)Error Codes. | |

* EBADR: (libc)Error Codes. | |

* EBADRPC: (libc)Error Codes. | |

* EBADRQC: (libc)Error Codes. | |

* EBADSLT: (libc)Error Codes. | |

* EBFONT: (libc)Error Codes. | |

* EBUSY: (libc)Error Codes. | |

* ECANCELED: (libc)Error Codes. | |

* ECHILD: (libc)Error Codes. | |

* ECHO: (libc)Local Modes. | |

* ECHOCTL: (libc)Local Modes. | |

* ECHOE: (libc)Local Modes. | |

* ECHOK: (libc)Local Modes. | |

* ECHOKE: (libc)Local Modes. | |

* ECHONL: (libc)Local Modes. | |

* ECHOPRT: (libc)Local Modes. | |

* ECHRNG: (libc)Error Codes. | |

* ECOMM: (libc)Error Codes. | |

* ECONNABORTED: (libc)Error Codes. | |

* ECONNREFUSED: (libc)Error Codes. | |

* ECONNRESET: (libc)Error Codes. | |

* ED: (libc)Error Codes. | |

* EDEADLK: (libc)Error Codes. | |

* EDEADLOCK: (libc)Error Codes. | |

* EDESTADDRREQ: (libc)Error Codes. | |

* EDIED: (libc)Error Codes. | |

* EDOM: (libc)Error Codes. | |

* EDOTDOT: (libc)Error Codes. | |

* EDQUOT: (libc)Error Codes. | |

* EEXIST: (libc)Error Codes. | |

* EFAULT: (libc)Error Codes. | |

* EFBIG: (libc)Error Codes. | |

* EFTYPE: (libc)Error Codes. | |

* EGRATUITOUS: (libc)Error Codes. | |

* EGREGIOUS: (libc)Error Codes. | |

* EHOSTDOWN: (libc)Error Codes. | |

* EHOSTUNREACH: (libc)Error Codes. | |

* EHWPOISON: (libc)Error Codes. | |

* EIDRM: (libc)Error Codes. | |

* EIEIO: (libc)Error Codes. | |

* EILSEQ: (libc)Error Codes. | |

* EINPROGRESS: (libc)Error Codes. | |

* EINTR: (libc)Error Codes. | |

* EINVAL: (libc)Error Codes. | |

* EIO: (libc)Error Codes. | |

* EISCONN: (libc)Error Codes. | |

* EISDIR: (libc)Error Codes. | |

* EISNAM: (libc)Error Codes. | |

* EKEYEXPIRED: (libc)Error Codes. | |

* EKEYREJECTED: (libc)Error Codes. | |

* EKEYREVOKED: (libc)Error Codes. | |

* EL2HLT: (libc)Error Codes. | |

* EL2NSYNC: (libc)Error Codes. | |

* EL3HLT: (libc)Error Codes. | |

* EL3RST: (libc)Error Codes. | |

* ELIBACC: (libc)Error Codes. | |

* ELIBBAD: (libc)Error Codes. | |

* ELIBEXEC: (libc)Error Codes. | |

* ELIBMAX: (libc)Error Codes. | |

* ELIBSCN: (libc)Error Codes. | |

* ELNRNG: (libc)Error Codes. | |

* ELOOP: (libc)Error Codes. | |

* EMEDIUMTYPE: (libc)Error Codes. | |

* EMFILE: (libc)Error Codes. | |

* EMLINK: (libc)Error Codes. | |

* EMSGSIZE: (libc)Error Codes. | |

* EMULTIHOP: (libc)Error Codes. | |

* ENAMETOOLONG: (libc)Error Codes. | |

* ENAVAIL: (libc)Error Codes. | |

* ENEEDAUTH: (libc)Error Codes. | |

* ENETDOWN: (libc)Error Codes. | |

* ENETRESET: (libc)Error Codes. | |

* ENETUNREACH: (libc)Error Codes. | |

* ENFILE: (libc)Error Codes. | |

* ENOANO: (libc)Error Codes. | |

* ENOBUFS: (libc)Error Codes. | |

* ENOCSI: (libc)Error Codes. | |

* ENODATA: (libc)Error Codes. | |

* ENODEV: (libc)Error Codes. | |

* ENOENT: (libc)Error Codes. | |

* ENOEXEC: (libc)Error Codes. | |

* ENOKEY: (libc)Error Codes. | |

* ENOLCK: (libc)Error Codes. | |

* ENOLINK: (libc)Error Codes. | |

* ENOMEDIUM: (libc)Error Codes. | |

* ENOMEM: (libc)Error Codes. | |

* ENOMSG: (libc)Error Codes. | |

* ENONET: (libc)Error Codes. | |

* ENOPKG: (libc)Error Codes. | |

* ENOPROTOOPT: (libc)Error Codes. | |

* ENOSPC: (libc)Error Codes. | |

* ENOSR: (libc)Error Codes. | |

* ENOSTR: (libc)Error Codes. | |

* ENOSYS: (libc)Error Codes. | |

* ENOTBLK: (libc)Error Codes. | |

* ENOTCONN: (libc)Error Codes. | |

* ENOTDIR: (libc)Error Codes. | |

* ENOTEMPTY: (libc)Error Codes. | |

* ENOTNAM: (libc)Error Codes. | |

* ENOTRECOVERABLE: (libc)Error Codes. | |

* ENOTSOCK: (libc)Error Codes. | |

* ENOTSUP: (libc)Error Codes. | |

* ENOTTY: (libc)Error Codes. | |

* ENOTUNIQ: (libc)Error Codes. | |

* ENXIO: (libc)Error Codes. | |

* EOF: (libc)EOF and Errors. | |

* EOPNOTSUPP: (libc)Error Codes. | |

* EOVERFLOW: (libc)Error Codes. | |

* EOWNERDEAD: (libc)Error Codes. | |

* EPERM: (libc)Error Codes. | |

* EPFNOSUPPORT: (libc)Error Codes. | |

* EPIPE: (libc)Error Codes. | |

* EPROCLIM: (libc)Error Codes. | |

* EPROCUNAVAIL: (libc)Error Codes. | |

* EPROGMISMATCH: (libc)Error Codes. | |

* EPROGUNAVAIL: (libc)Error Codes. | |

* EPROTO: (libc)Error Codes. | |

* EPROTONOSUPPORT: (libc)Error Codes. | |

* EPROTOTYPE: (libc)Error Codes. | |

* EQUIV_CLASS_MAX: (libc)Utility Limits. | |

* ERANGE: (libc)Error Codes. | |

* EREMCHG: (libc)Error Codes. | |

* EREMOTE: (libc)Error Codes. | |

* EREMOTEIO: (libc)Error Codes. | |

* ERESTART: (libc)Error Codes. | |

* ERFKILL: (libc)Error Codes. | |

* EROFS: (libc)Error Codes. | |

* ERPCMISMATCH: (libc)Error Codes. | |

* ESHUTDOWN: (libc)Error Codes. | |

* ESOCKTNOSUPPORT: (libc)Error Codes. | |

* ESPIPE: (libc)Error Codes. | |

* ESRCH: (libc)Error Codes. | |

* ESRMNT: (libc)Error Codes. | |

* ESTALE: (libc)Error Codes. | |

* ESTRPIPE: (libc)Error Codes. | |

* ETIME: (libc)Error Codes. | |

* ETIMEDOUT: (libc)Error Codes. | |

* ETOOMANYREFS: (libc)Error Codes. | |

* ETXTBSY: (libc)Error Codes. | |

* EUCLEAN: (libc)Error Codes. | |

* EUNATCH: (libc)Error Codes. | |

* EUSERS: (libc)Error Codes. | |

* EWOULDBLOCK: (libc)Error Codes. | |

* EXDEV: (libc)Error Codes. | |

* EXFULL: (libc)Error Codes. | |

* EXIT_FAILURE: (libc)Exit Status. | |

* EXIT_SUCCESS: (libc)Exit Status. | |

* EXPR_NEST_MAX: (libc)Utility Limits. | |

* FD_CLOEXEC: (libc)Descriptor Flags. | |

* FD_CLR: (libc)Waiting for I/O. | |

* FD_ISSET: (libc)Waiting for I/O. | |

* FD_SET: (libc)Waiting for I/O. | |

* FD_SETSIZE: (libc)Waiting for I/O. | |

* FD_ZERO: (libc)Waiting for I/O. | |

* FILENAME_MAX: (libc)Limits for Files. | |

* FLUSHO: (libc)Local Modes. | |

* FOPEN_MAX: (libc)Opening Streams. | |

* FP_ILOGB0: (libc)Exponents and Logarithms. | |

* FP_ILOGBNAN: (libc)Exponents and Logarithms. | |

* F_DUPFD: (libc)Duplicating Descriptors. | |

* F_GETFD: (libc)Descriptor Flags. | |

* F_GETFL: (libc)Getting File Status Flags. | |

* F_GETLK: (libc)File Locks. | |

* F_GETOWN: (libc)Interrupt Input. | |

* F_OK: (libc)Testing File Access. | |

* F_SETFD: (libc)Descriptor Flags. | |

* F_SETFL: (libc)Getting File Status Flags. | |

* F_SETLK: (libc)File Locks. | |

* F_SETLKW: (libc)File Locks. | |

* F_SETOWN: (libc)Interrupt Input. | |

* HUGE_VAL: (libc)Math Error Reporting. | |

* HUGE_VALF: (libc)Math Error Reporting. | |

* HUGE_VALL: (libc)Math Error Reporting. | |

* HUPCL: (libc)Control Modes. | |

* I: (libc)Complex Numbers. | |

* ICANON: (libc)Local Modes. | |

* ICRNL: (libc)Input Modes. | |

* IEXTEN: (libc)Local Modes. | |

* IFNAMSIZ: (libc)Interface Naming. | |

* IFTODT: (libc)Directory Entries. | |

* IGNBRK: (libc)Input Modes. | |

* IGNCR: (libc)Input Modes. | |

* IGNPAR: (libc)Input Modes. | |

* IMAXBEL: (libc)Input Modes. | |

* INADDR_ANY: (libc)Host Address Data Type. | |

* INADDR_BROADCAST: (libc)Host Address Data Type. | |

* INADDR_LOOPBACK: (libc)Host Address Data Type. | |

* INADDR_NONE: (libc)Host Address Data Type. | |

* INFINITY: (libc)Infinity and NaN. | |

* INLCR: (libc)Input Modes. | |

* INPCK: (libc)Input Modes. | |

* IPPORT_RESERVED: (libc)Ports. | |

* IPPORT_USERRESERVED: (libc)Ports. | |

* ISIG: (libc)Local Modes. | |

* ISTRIP: (libc)Input Modes. | |

* IXANY: (libc)Input Modes. | |

* IXOFF: (libc)Input Modes. | |

* IXON: (libc)Input Modes. | |

* LINE_MAX: (libc)Utility Limits. | |

* LINK_MAX: (libc)Limits for Files. | |

* L_ctermid: (libc)Identifying the Terminal. | |

* L_cuserid: (libc)Who Logged In. | |

* L_tmpnam: (libc)Temporary Files. | |

* MAXNAMLEN: (libc)Limits for Files. | |

* MAXSYMLINKS: (libc)Symbolic Links. | |

* MAX_CANON: (libc)Limits for Files. | |

* MAX_INPUT: (libc)Limits for Files. | |

* MB_CUR_MAX: (libc)Selecting the Conversion. | |

* MB_LEN_MAX: (libc)Selecting the Conversion. | |

* MDMBUF: (libc)Control Modes. | |

* MSG_DONTROUTE: (libc)Socket Data Options. | |

* MSG_OOB: (libc)Socket Data Options. | |

* MSG_PEEK: (libc)Socket Data Options. | |

* NAME_MAX: (libc)Limits for Files. | |

* NAN: (libc)Infinity and NaN. | |

* NCCS: (libc)Mode Data Types. | |

* NGROUPS_MAX: (libc)General Limits. | |

* NOFLSH: (libc)Local Modes. | |

* NOKERNINFO: (libc)Local Modes. | |

* NSIG: (libc)Standard Signals. | |

* NULL: (libc)Null Pointer Constant. | |

* ONLCR: (libc)Output Modes. | |

* ONOEOT: (libc)Output Modes. | |

* OPEN_MAX: (libc)General Limits. | |

* OPOST: (libc)Output Modes. | |

* OXTABS: (libc)Output Modes. | |

* O_ACCMODE: (libc)Access Modes. | |

* O_APPEND: (libc)Operating Modes. | |

* O_ASYNC: (libc)Operating Modes. | |

* O_CREAT: (libc)Open-time Flags. | |

* O_EXCL: (libc)Open-time Flags. | |

* O_EXEC: (libc)Access Modes. | |

* O_EXLOCK: (libc)Open-time Flags. | |

* O_FSYNC: (libc)Operating Modes. | |

* O_IGNORE_CTTY: (libc)Open-time Flags. | |

* O_NDELAY: (libc)Operating Modes. | |

* O_NOATIME: (libc)Operating Modes. | |

* O_NOCTTY: (libc)Open-time Flags. | |

* O_NOLINK: (libc)Open-time Flags. | |

* O_NONBLOCK: (libc)Open-time Flags. | |

* O_NONBLOCK: (libc)Operating Modes. | |

* O_NOTRANS: (libc)Open-time Flags. | |

* O_RDONLY: (libc)Access Modes. | |

* O_RDWR: (libc)Access Modes. | |

* O_READ: (libc)Access Modes. | |

* O_SHLOCK: (libc)Open-time Flags. | |

* O_SYNC: (libc)Operating Modes. | |

* O_TRUNC: (libc)Open-time Flags. | |

* O_WRITE: (libc)Access Modes. | |

* O_WRONLY: (libc)Access Modes. | |

* PARENB: (libc)Control Modes. | |

* PARMRK: (libc)Input Modes. | |

* PARODD: (libc)Control Modes. | |

* PATH_MAX: (libc)Limits for Files. | |

* PA_FLAG_MASK: (libc)Parsing a Template String. | |

* PENDIN: (libc)Local Modes. | |

* PF_FILE: (libc)Local Namespace Details. | |

* PF_INET6: (libc)Internet Namespace. | |

* PF_INET: (libc)Internet Namespace. | |

* PF_LOCAL: (libc)Local Namespace Details. | |

* PF_UNIX: (libc)Local Namespace Details. | |

* PIPE_BUF: (libc)Limits for Files. | |

* P_tmpdir: (libc)Temporary Files. | |

* RAND_MAX: (libc)ISO Random. | |

* RE_DUP_MAX: (libc)General Limits. | |

* RLIM_INFINITY: (libc)Limits on Resources. | |

* R_OK: (libc)Testing File Access. | |

* SA_NOCLDSTOP: (libc)Flags for Sigaction. | |

* SA_ONSTACK: (libc)Flags for Sigaction. | |

* SA_RESTART: (libc)Flags for Sigaction. | |

* SEEK_CUR: (libc)File Positioning. | |

* SEEK_END: (libc)File Positioning. | |

* SEEK_SET: (libc)File Positioning. | |

* SIGABRT: (libc)Program Error Signals. | |

* SIGALRM: (libc)Alarm Signals. | |

* SIGBUS: (libc)Program Error Signals. | |

* SIGCHLD: (libc)Job Control Signals. | |

* SIGCLD: (libc)Job Control Signals. | |

* SIGCONT: (libc)Job Control Signals. | |

* SIGEMT: (libc)Program Error Signals. | |

* SIGFPE: (libc)Program Error Signals. | |

* SIGHUP: (libc)Termination Signals. | |

* SIGILL: (libc)Program Error Signals. | |

* SIGINFO: (libc)Miscellaneous Signals. | |

* SIGINT: (libc)Termination Signals. | |

* SIGIO: (libc)Asynchronous I/O Signals. | |

* SIGIOT: (libc)Program Error Signals. | |

* SIGKILL: (libc)Termination Signals. | |

* SIGLOST: (libc)Operation Error Signals. | |

* SIGPIPE: (libc)Operation Error Signals. | |

* SIGPOLL: (libc)Asynchronous I/O Signals. | |

* SIGPROF: (libc)Alarm Signals. | |

* SIGQUIT: (libc)Termination Signals. | |

* SIGSEGV: (libc)Program Error Signals. | |

* SIGSTOP: (libc)Job Control Signals. | |

* SIGSYS: (libc)Program Error Signals. | |

* SIGTERM: (libc)Termination Signals. | |

* SIGTRAP: (libc)Program Error Signals. | |

* SIGTSTP: (libc)Job Control Signals. | |

* SIGTTIN: (libc)Job Control Signals. | |

* SIGTTOU: (libc)Job Control Signals. | |

* SIGURG: (libc)Asynchronous I/O Signals. | |

* SIGUSR1: (libc)Miscellaneous Signals. | |

* SIGUSR2: (libc)Miscellaneous Signals. | |

* SIGVTALRM: (libc)Alarm Signals. | |

* SIGWINCH: (libc)Miscellaneous Signals. | |

* SIGXCPU: (libc)Operation Error Signals. | |

* SIGXFSZ: (libc)Operation Error Signals. | |

* SIG_ERR: (libc)Basic Signal Handling. | |

* SOCK_DGRAM: (libc)Communication Styles. | |

* SOCK_RAW: (libc)Communication Styles. | |

* SOCK_RDM: (libc)Communication Styles. | |

* SOCK_SEQPACKET: (libc)Communication Styles. | |

* SOCK_STREAM: (libc)Communication Styles. | |

* SOL_SOCKET: (libc)Socket-Level Options. | |

* SSIZE_MAX: (libc)General Limits. | |

* STREAM_MAX: (libc)General Limits. | |

* SUN_LEN: (libc)Local Namespace Details. | |

* SV_INTERRUPT: (libc)BSD Handler. | |

* SV_ONSTACK: (libc)BSD Handler. | |

* SV_RESETHAND: (libc)BSD Handler. | |

* S_IFMT: (libc)Testing File Type. | |

* S_ISBLK: (libc)Testing File Type. | |

* S_ISCHR: (libc)Testing File Type. | |

* S_ISDIR: (libc)Testing File Type. | |

* S_ISFIFO: (libc)Testing File Type. | |

* S_ISLNK: (libc)Testing File Type. | |

* S_ISREG: (libc)Testing File Type. | |

* S_ISSOCK: (libc)Testing File Type. | |

* S_TYPEISMQ: (libc)Testing File Type. | |

* S_TYPEISSEM: (libc)Testing File Type. | |

* S_TYPEISSHM: (libc)Testing File Type. | |

* TMP_MAX: (libc)Temporary Files. | |

* TOSTOP: (libc)Local Modes. | |

* TZNAME_MAX: (libc)General Limits. | |

* VDISCARD: (libc)Other Special. | |

* VDSUSP: (libc)Signal Characters. | |

* VEOF: (libc)Editing Characters. | |

* VEOL2: (libc)Editing Characters. | |

* VEOL: (libc)Editing Characters. | |

* VERASE: (libc)Editing Characters. | |

* VINTR: (libc)Signal Characters. | |

* VKILL: (libc)Editing Characters. | |

* VLNEXT: (libc)Other Special. | |

* VMIN: (libc)Noncanonical Input. | |

* VQUIT: (libc)Signal Characters. | |

* VREPRINT: (libc)Editing Characters. | |

* VSTART: (libc)Start/Stop Characters. | |

* VSTATUS: (libc)Other Special. | |

* VSTOP: (libc)Start/Stop Characters. | |

* VSUSP: (libc)Signal Characters. | |

* VTIME: (libc)Noncanonical Input. | |

* VWERASE: (libc)Editing Characters. | |

* WCHAR_MAX: (libc)Extended Char Intro. | |

* WCHAR_MIN: (libc)Extended Char Intro. | |

* WCOREDUMP: (libc)Process Completion Status. | |

* WEOF: (libc)EOF and Errors. | |

* WEOF: (libc)Extended Char Intro. | |

* WEXITSTATUS: (libc)Process Completion Status. | |

* WIFEXITED: (libc)Process Completion Status. | |

* WIFSIGNALED: (libc)Process Completion Status. | |

* WIFSTOPPED: (libc)Process Completion Status. | |

* WSTOPSIG: (libc)Process Completion Status. | |

* WTERMSIG: (libc)Process Completion Status. | |

* W_OK: (libc)Testing File Access. | |

* X_OK: (libc)Testing File Access. | |

* _Complex_I: (libc)Complex Numbers. | |

* _Exit: (libc)Termination Internals. | |

* _IOFBF: (libc)Controlling Buffering. | |

* _IOLBF: (libc)Controlling Buffering. | |

* _IONBF: (libc)Controlling Buffering. | |

* _Imaginary_I: (libc)Complex Numbers. | |

* _PATH_UTMP: (libc)Manipulating the Database. | |

* _PATH_WTMP: (libc)Manipulating the Database. | |

* _POSIX2_C_DEV: (libc)System Options. | |

* _POSIX2_C_VERSION: (libc)Version Supported. | |

* _POSIX2_FORT_DEV: (libc)System Options. | |

* _POSIX2_FORT_RUN: (libc)System Options. | |

* _POSIX2_LOCALEDEF: (libc)System Options. | |

* _POSIX2_SW_DEV: (libc)System Options. | |

* _POSIX_CHOWN_RESTRICTED: (libc)Options for Files. | |

* _POSIX_JOB_CONTROL: (libc)System Options. | |

* _POSIX_NO_TRUNC: (libc)Options for Files. | |

* _POSIX_SAVED_IDS: (libc)System Options. | |

* _POSIX_VDISABLE: (libc)Options for Files. | |

* _POSIX_VERSION: (libc)Version Supported. | |

* __fbufsize: (libc)Controlling Buffering. | |

* __flbf: (libc)Controlling Buffering. | |

* __fpending: (libc)Controlling Buffering. | |

* __fpurge: (libc)Flushing Buffers. | |

* __freadable: (libc)Opening Streams. | |

* __freading: (libc)Opening Streams. | |

* __fsetlocking: (libc)Streams and Threads. | |

* __fwritable: (libc)Opening Streams. | |

* __fwriting: (libc)Opening Streams. | |

* __gconv_end_fct: (libc)glibc iconv Implementation. | |

* __gconv_fct: (libc)glibc iconv Implementation. | |

* __gconv_init_fct: (libc)glibc iconv Implementation. | |

* __ppc_get_timebase: (libc)PowerPC. | |

* __ppc_get_timebase_freq: (libc)PowerPC. | |

* __ppc_mdoio: (libc)PowerPC. | |

* __ppc_mdoom: (libc)PowerPC. | |

* __ppc_set_ppr_low: (libc)PowerPC. | |

* __ppc_set_ppr_med: (libc)PowerPC. | |

* __ppc_set_ppr_med_low: (libc)PowerPC. | |

* __ppc_yield: (libc)PowerPC. | |

* __va_copy: (libc)Argument Macros. | |

* _exit: (libc)Termination Internals. | |

* _flushlbf: (libc)Flushing Buffers. | |

* _tolower: (libc)Case Conversion. | |

* _toupper: (libc)Case Conversion. | |

* a64l: (libc)Encode Binary Data. | |

* abort: (libc)Aborting a Program. | |

* abs: (libc)Absolute Value. | |

* accept: (libc)Accepting Connections. | |

* access: (libc)Testing File Access. | |

* acos: (libc)Inverse Trig Functions. | |

* acosf: (libc)Inverse Trig Functions. | |

* acosh: (libc)Hyperbolic Functions. | |

* acoshf: (libc)Hyperbolic Functions. | |

* acoshl: (libc)Hyperbolic Functions. | |

* acosl: (libc)Inverse Trig Functions. | |

* addmntent: (libc)mtab. | |

* addseverity: (libc)Adding Severity Classes. | |

* adjtime: (libc)High-Resolution Calendar. | |

* adjtimex: (libc)High-Resolution Calendar. | |

* aio_cancel64: (libc)Cancel AIO Operations. | |

* aio_cancel: (libc)Cancel AIO Operations. | |

* aio_error64: (libc)Status of AIO Operations. | |

* aio_error: (libc)Status of AIO Operations. | |

* aio_fsync64: (libc)Synchronizing AIO Operations. | |

* aio_fsync: (libc)Synchronizing AIO Operations. | |

* aio_init: (libc)Configuration of AIO. | |

* aio_read64: (libc)Asynchronous Reads/Writes. | |

* aio_read: (libc)Asynchronous Reads/Writes. | |

* aio_return64: (libc)Status of AIO Operations. | |

* aio_return: (libc)Status of AIO Operations. | |

* aio_suspend64: (libc)Synchronizing AIO Operations. | |

* aio_suspend: (libc)Synchronizing AIO Operations. | |

* aio_write64: (libc)Asynchronous Reads/Writes. | |

* aio_write: (libc)Asynchronous Reads/Writes. | |

* alarm: (libc)Setting an Alarm. | |

* aligned_alloc: (libc)Aligned Memory Blocks. | |

* alloca: (libc)Variable Size Automatic. | |

* alphasort64: (libc)Scanning Directory Content. | |

* alphasort: (libc)Scanning Directory Content. | |

* argp_error: (libc)Argp Helper Functions. | |

* argp_failure: (libc)Argp Helper Functions. | |

* argp_help: (libc)Argp Help. | |

* argp_parse: (libc)Argp. | |

* argp_state_help: (libc)Argp Helper Functions. | |

* argp_usage: (libc)Argp Helper Functions. | |

* argz_add: (libc)Argz Functions. | |

* argz_add_sep: (libc)Argz Functions. | |

* argz_append: (libc)Argz Functions. | |

* argz_count: (libc)Argz Functions. | |

* argz_create: (libc)Argz Functions. | |

* argz_create_sep: (libc)Argz Functions. | |

* argz_delete: (libc)Argz Functions. | |

* argz_extract: (libc)Argz Functions. | |

* argz_insert: (libc)Argz Functions. | |

* argz_next: (libc)Argz Functions. | |

* argz_replace: (libc)Argz Functions. | |

* argz_stringify: (libc)Argz Functions. | |

* asctime: (libc)Formatting Calendar Time. | |

* asctime_r: (libc)Formatting Calendar Time. | |

* asin: (libc)Inverse Trig Functions. | |

* asinf: (libc)Inverse Trig Functions. | |

* asinh: (libc)Hyperbolic Functions. | |

* asinhf: (libc)Hyperbolic Functions. | |

* asinhl: (libc)Hyperbolic Functions. | |

* asinl: (libc)Inverse Trig Functions. | |

* asprintf: (libc)Dynamic Output. | |

* assert: (libc)Consistency Checking. | |

* assert_perror: (libc)Consistency Checking. | |

* atan2: (libc)Inverse Trig Functions. | |

* atan2f: (libc)Inverse Trig Functions. | |

* atan2l: (libc)Inverse Trig Functions. | |

* atan: (libc)Inverse Trig Functions. | |

* atanf: (libc)Inverse Trig Functions. | |

* atanh: (libc)Hyperbolic Functions. | |

* atanhf: (libc)Hyperbolic Functions. | |

* atanhl: (libc)Hyperbolic Functions. | |

* atanl: (libc)Inverse Trig Functions. | |

* atexit: (libc)Cleanups on Exit. | |

* atof: (libc)Parsing of Floats. | |

* atoi: (libc)Parsing of Integers. | |

* atol: (libc)Parsing of Integers. | |

* atoll: (libc)Parsing of Integers. | |

* backtrace: (libc)Backtraces. | |

* backtrace_symbols: (libc)Backtraces. | |

* backtrace_symbols_fd: (libc)Backtraces. | |

* basename: (libc)Finding Tokens in a String. | |

* basename: (libc)Finding Tokens in a String. | |

* bcmp: (libc)String/Array Comparison. | |

* bcopy: (libc)Copying and Concatenation. | |

* bind: (libc)Setting Address. | |

* bind_textdomain_codeset: (libc)Charset conversion in gettext. | |

* bindtextdomain: (libc)Locating gettext catalog. | |

* brk: (libc)Resizing the Data Segment. | |

* bsearch: (libc)Array Search Function. | |

* btowc: (libc)Converting a Character. | |

* bzero: (libc)Copying and Concatenation. | |

* cabs: (libc)Absolute Value. | |

* cabsf: (libc)Absolute Value. | |

* cabsl: (libc)Absolute Value. | |

* cacos: (libc)Inverse Trig Functions. | |

* cacosf: (libc)Inverse Trig Functions. | |

* cacosh: (libc)Hyperbolic Functions. | |

* cacoshf: (libc)Hyperbolic Functions. | |

* cacoshl: (libc)Hyperbolic Functions. | |

* cacosl: (libc)Inverse Trig Functions. | |

* calloc: (libc)Allocating Cleared Space. | |

* canonicalize_file_name: (libc)Symbolic Links. | |

* carg: (libc)Operations on Complex. | |

* cargf: (libc)Operations on Complex. | |

* cargl: (libc)Operations on Complex. | |

* casin: (libc)Inverse Trig Functions. | |

* casinf: (libc)Inverse Trig Functions. | |

* casinh: (libc)Hyperbolic Functions. | |

* casinhf: (libc)Hyperbolic Functions. | |

* casinhl: (libc)Hyperbolic Functions. | |

* casinl: (libc)Inverse Trig Functions. | |

* catan: (libc)Inverse Trig Functions. | |

* catanf: (libc)Inverse Trig Functions. | |

* catanh: (libc)Hyperbolic Functions. | |

* catanhf: (libc)Hyperbolic Functions. | |

* catanhl: (libc)Hyperbolic Functions. | |

* catanl: (libc)Inverse Trig Functions. | |

* catclose: (libc)The catgets Functions. | |

* catgets: (libc)The catgets Functions. | |

* catopen: (libc)The catgets Functions. | |

* cbc_crypt: (libc)DES Encryption. | |

* cbrt: (libc)Exponents and Logarithms. | |

* cbrtf: (libc)Exponents and Logarithms. | |

* cbrtl: (libc)Exponents and Logarithms. | |

* ccos: (libc)Trig Functions. | |

* ccosf: (libc)Trig Functions. | |

* ccosh: (libc)Hyperbolic Functions. | |

* ccoshf: (libc)Hyperbolic Functions. | |

* ccoshl: (libc)Hyperbolic Functions. | |

* ccosl: (libc)Trig Functions. | |

* ceil: (libc)Rounding Functions. | |

* ceilf: (libc)Rounding Functions. | |

* ceill: (libc)Rounding Functions. | |

* cexp: (libc)Exponents and Logarithms. | |

* cexpf: (libc)Exponents and Logarithms. | |

* cexpl: (libc)Exponents and Logarithms. | |

* cfgetispeed: (libc)Line Speed. | |

* cfgetospeed: (libc)Line Speed. | |

* cfmakeraw: (libc)Noncanonical Input. | |

* cfree: (libc)Freeing after Malloc. | |

* cfsetispeed: (libc)Line Speed. | |

* cfsetospeed: (libc)Line Speed. | |

* cfsetspeed: (libc)Line Speed. | |

* chdir: (libc)Working Directory. | |

* chmod: (libc)Setting Permissions. | |

* chown: (libc)File Owner. | |

* cimag: (libc)Operations on Complex. | |

* cimagf: (libc)Operations on Complex. | |

* cimagl: (libc)Operations on Complex. | |

* clearenv: (libc)Environment Access. | |

* clearerr: (libc)Error Recovery. | |

* clearerr_unlocked: (libc)Error Recovery. | |

* clock: (libc)CPU Time. | |

* clog10: (libc)Exponents and Logarithms. | |

* clog10f: (libc)Exponents and Logarithms. | |

* clog10l: (libc)Exponents and Logarithms. | |

* clog: (libc)Exponents and Logarithms. | |

* clogf: (libc)Exponents and Logarithms. | |

* clogl: (libc)Exponents and Logarithms. | |

* close: (libc)Opening and Closing Files. | |

* closedir: (libc)Reading/Closing Directory. | |

* closelog: (libc)closelog. | |

* confstr: (libc)String Parameters. | |

* conj: (libc)Operations on Complex. | |

* conjf: (libc)Operations on Complex. | |

* conjl: (libc)Operations on Complex. | |

* connect: (libc)Connecting. | |

* copysign: (libc)FP Bit Twiddling. | |

* copysignf: (libc)FP Bit Twiddling. | |

* copysignl: (libc)FP Bit Twiddling. | |

* cos: (libc)Trig Functions. | |

* cosf: (libc)Trig Functions. | |

* cosh: (libc)Hyperbolic Functions. | |

* coshf: (libc)Hyperbolic Functions. | |

* coshl: (libc)Hyperbolic Functions. | |

* cosl: (libc)Trig Functions. | |

* cpow: (libc)Exponents and Logarithms. | |

* cpowf: (libc)Exponents and Logarithms. | |

* cpowl: (libc)Exponents and Logarithms. | |

* cproj: (libc)Operations on Complex. | |

* cprojf: (libc)Operations on Complex. | |

* cprojl: (libc)Operations on Complex. | |

* creal: (libc)Operations on Complex. | |

* crealf: (libc)Operations on Complex. | |

* creall: (libc)Operations on Complex. | |

* creat64: (libc)Opening and Closing Files. | |

* creat: (libc)Opening and Closing Files. | |

* crypt: (libc)crypt. | |

* crypt_r: (libc)crypt. | |

* csin: (libc)Trig Functions. | |

* csinf: (libc)Trig Functions. | |

* csinh: (libc)Hyperbolic Functions. | |

* csinhf: (libc)Hyperbolic Functions. | |

* csinhl: (libc)Hyperbolic Functions. | |

* csinl: (libc)Trig Functions. | |

* csqrt: (libc)Exponents and Logarithms. | |

* csqrtf: (libc)Exponents and Logarithms. | |

* csqrtl: (libc)Exponents and Logarithms. | |

* ctan: (libc)Trig Functions. | |

* ctanf: (libc)Trig Functions. | |

* ctanh: (libc)Hyperbolic Functions. | |

* ctanhf: (libc)Hyperbolic Functions. | |

* ctanhl: (libc)Hyperbolic Functions. | |

* ctanl: (libc)Trig Functions. | |

* ctermid: (libc)Identifying the Terminal. | |

* ctime: (libc)Formatting Calendar Time. | |

* ctime_r: (libc)Formatting Calendar Time. | |

* cuserid: (libc)Who Logged In. | |

* dcgettext: (libc)Translation with gettext. | |

* dcngettext: (libc)Advanced gettext functions. | |

* des_setparity: (libc)DES Encryption. | |

* dgettext: (libc)Translation with gettext. | |

* difftime: (libc)Elapsed Time. | |

* dirfd: (libc)Opening a Directory. | |

* dirname: (libc)Finding Tokens in a String. | |

* div: (libc)Integer Division. | |

* dngettext: (libc)Advanced gettext functions. | |

* drand48: (libc)SVID Random. | |

* drand48_r: (libc)SVID Random. | |

* drem: (libc)Remainder Functions. | |

* dremf: (libc)Remainder Functions. | |

* dreml: (libc)Remainder Functions. | |

* dup2: (libc)Duplicating Descriptors. | |

* dup: (libc)Duplicating Descriptors. | |

* ecb_crypt: (libc)DES Encryption. | |

* ecvt: (libc)System V Number Conversion. | |

* ecvt_r: (libc)System V Number Conversion. | |

* encrypt: (libc)DES Encryption. | |

* encrypt_r: (libc)DES Encryption. | |

* endfsent: (libc)fstab. | |

* endgrent: (libc)Scanning All Groups. | |

* endhostent: (libc)Host Names. | |

* endmntent: (libc)mtab. | |

* endnetent: (libc)Networks Database. | |

* endnetgrent: (libc)Lookup Netgroup. | |

* endprotoent: (libc)Protocols Database. | |

* endpwent: (libc)Scanning All Users. | |

* endservent: (libc)Services Database. | |

* endutent: (libc)Manipulating the Database. | |

* endutxent: (libc)XPG Functions. | |

* envz_add: (libc)Envz Functions. | |

* envz_entry: (libc)Envz Functions. | |

* envz_get: (libc)Envz Functions. | |

* envz_merge: (libc)Envz Functions. | |

* envz_strip: (libc)Envz Functions. | |

* erand48: (libc)SVID Random. | |

* erand48_r: (libc)SVID Random. | |

* erf: (libc)Special Functions. | |

* erfc: (libc)Special Functions. | |

* erfcf: (libc)Special Functions. | |

* erfcl: (libc)Special Functions. | |

* erff: (libc)Special Functions. | |

* erfl: (libc)Special Functions. | |

* err: (libc)Error Messages. | |

* errno: (libc)Checking for Errors. | |

* error: (libc)Error Messages. | |

* error_at_line: (libc)Error Messages. | |

* errx: (libc)Error Messages. | |

* execl: (libc)Executing a File. | |

* execle: (libc)Executing a File. | |

* execlp: (libc)Executing a File. | |

* execv: (libc)Executing a File. | |

* execve: (libc)Executing a File. | |

* execvp: (libc)Executing a File. | |

* exit: (libc)Normal Termination. | |

* exp10: (libc)Exponents and Logarithms. | |

* exp10f: (libc)Exponents and Logarithms. | |

* exp10l: (libc)Exponents and Logarithms. | |

* exp2: (libc)Exponents and Logarithms. | |

* exp2f: (libc)Exponents and Logarithms. | |

* exp2l: (libc)Exponents and Logarithms. | |

* exp: (libc)Exponents and Logarithms. | |

* expf: (libc)Exponents and Logarithms. | |

* expl: (libc)Exponents and Logarithms. | |

* expm1: (libc)Exponents and Logarithms. | |

* expm1f: (libc)Exponents and Logarithms. | |

* expm1l: (libc)Exponents and Logarithms. | |

* fabs: (libc)Absolute Value. | |

* fabsf: (libc)Absolute Value. | |

* fabsl: (libc)Absolute Value. | |

* fchdir: (libc)Working Directory. | |

* fchmod: (libc)Setting Permissions. | |

* fchown: (libc)File Owner. | |

* fclose: (libc)Closing Streams. | |

* fcloseall: (libc)Closing Streams. | |

* fcntl: (libc)Control Operations. | |

* fcvt: (libc)System V Number Conversion. | |

* fcvt_r: (libc)System V Number Conversion. | |

* fdatasync: (libc)Synchronizing I/O. | |

* fdim: (libc)Misc FP Arithmetic. | |

* fdimf: (libc)Misc FP Arithmetic. | |

* fdiml: (libc)Misc FP Arithmetic. | |

* fdopen: (libc)Descriptors and Streams. | |

* fdopendir: (libc)Opening a Directory. | |

* feclearexcept: (libc)Status bit operations. | |

* fedisableexcept: (libc)Control Functions. | |

* feenableexcept: (libc)Control Functions. | |

* fegetenv: (libc)Control Functions. | |

* fegetexcept: (libc)Control Functions. | |

* fegetexceptflag: (libc)Status bit operations. | |

* fegetround: (libc)Rounding. | |

* feholdexcept: (libc)Control Functions. | |

* feof: (libc)EOF and Errors. | |

* feof_unlocked: (libc)EOF and Errors. | |

* feraiseexcept: (libc)Status bit operations. | |

* ferror: (libc)EOF and Errors. | |

* ferror_unlocked: (libc)EOF and Errors. | |

* fesetenv: (libc)Control Functions. | |

* fesetexceptflag: (libc)Status bit operations. | |

* fesetround: (libc)Rounding. | |

* fetestexcept: (libc)Status bit operations. | |

* feupdateenv: (libc)Control Functions. | |

* fflush: (libc)Flushing Buffers. | |

* fflush_unlocked: (libc)Flushing Buffers. | |

* fgetc: (libc)Character Input. | |

* fgetc_unlocked: (libc)Character Input. | |

* fgetgrent: (libc)Scanning All Groups. | |

* fgetgrent_r: (libc)Scanning All Groups. | |

* fgetpos64: (libc)Portable Positioning. | |

* fgetpos: (libc)Portable Positioning. | |

* fgetpwent: (libc)Scanning All Users. | |

* fgetpwent_r: (libc)Scanning All Users. | |

* fgets: (libc)Line Input. | |

* fgets_unlocked: (libc)Line Input. | |

* fgetwc: (libc)Character Input. | |

* fgetwc_unlocked: (libc)Character Input. | |

* fgetws: (libc)Line Input. | |

* fgetws_unlocked: (libc)Line Input. | |

* fileno: (libc)Descriptors and Streams. | |

* fileno_unlocked: (libc)Descriptors and Streams. | |

* finite: (libc)Floating Point Classes. | |

* finitef: (libc)Floating Point Classes. | |

* finitel: (libc)Floating Point Classes. | |

* flockfile: (libc)Streams and Threads. | |

* floor: (libc)Rounding Functions. | |

* floorf: (libc)Rounding Functions. | |

* floorl: (libc)Rounding Functions. | |

* fma: (libc)Misc FP Arithmetic. | |

* fmaf: (libc)Misc FP Arithmetic. | |

* fmal: (libc)Misc FP Arithmetic. | |

* fmax: (libc)Misc FP Arithmetic. | |

* fmaxf: (libc)Misc FP Arithmetic. | |

* fmaxl: (libc)Misc FP Arithmetic. | |

* fmemopen: (libc)String Streams. | |

* fmin: (libc)Misc FP Arithmetic. | |

* fminf: (libc)Misc FP Arithmetic. | |

* fminl: (libc)Misc FP Arithmetic. | |

* fmod: (libc)Remainder Functions. | |

* fmodf: (libc)Remainder Functions. | |

* fmodl: (libc)Remainder Functions. | |

* fmtmsg: (libc)Printing Formatted Messages. | |

* fnmatch: (libc)Wildcard Matching. | |

* fopen64: (libc)Opening Streams. | |

* fopen: (libc)Opening Streams. | |

* fopencookie: (libc)Streams and Cookies. | |

* fork: (libc)Creating a Process. | |

* forkpty: (libc)Pseudo-Terminal Pairs. | |

* fpathconf: (libc)Pathconf. | |

* fpclassify: (libc)Floating Point Classes. | |

* fprintf: (libc)Formatted Output Functions. | |

* fputc: (libc)Simple Output. | |

* fputc_unlocked: (libc)Simple Output. | |

* fputs: (libc)Simple Output. | |

* fputs_unlocked: (libc)Simple Output. | |

* fputwc: (libc)Simple Output. | |

* fputwc_unlocked: (libc)Simple Output. | |

* fputws: (libc)Simple Output. | |

* fputws_unlocked: (libc)Simple Output. | |

* fread: (libc)Block Input/Output. | |

* fread_unlocked: (libc)Block Input/Output. | |

* free: (libc)Freeing after Malloc. | |

* freopen64: (libc)Opening Streams. | |

* freopen: (libc)Opening Streams. | |

* frexp: (libc)Normalization Functions. | |

* frexpf: (libc)Normalization Functions. | |

* frexpl: (libc)Normalization Functions. | |

* fscanf: (libc)Formatted Input Functions. | |

* fseek: (libc)File Positioning. | |

* fseeko64: (libc)File Positioning. | |

* fseeko: (libc)File Positioning. | |

* fsetpos64: (libc)Portable Positioning. | |

* fsetpos: (libc)Portable Positioning. | |

* fstat64: (libc)Reading Attributes. | |

* fstat: (libc)Reading Attributes. | |

* fsync: (libc)Synchronizing I/O. | |

* ftell: (libc)File Positioning. | |

* ftello64: (libc)File Positioning. | |

* ftello: (libc)File Positioning. | |

* ftruncate64: (libc)File Size. | |

* ftruncate: (libc)File Size. | |

* ftrylockfile: (libc)Streams and Threads. | |

* ftw64: (libc)Working with Directory Trees. | |

* ftw: (libc)Working with Directory Trees. | |

* funlockfile: (libc)Streams and Threads. | |

* futimes: (libc)File Times. | |

* fwide: (libc)Streams and I18N. | |

* fwprintf: (libc)Formatted Output Functions. | |

* fwrite: (libc)Block Input/Output. | |

* fwrite_unlocked: (libc)Block Input/Output. | |

* fwscanf: (libc)Formatted Input Functions. | |

* gamma: (libc)Special Functions. | |

* gammaf: (libc)Special Functions. | |

* gammal: (libc)Special Functions. | |

* gcvt: (libc)System V Number Conversion. | |

* get_avphys_pages: (libc)Query Memory Parameters. | |

* get_current_dir_name: (libc)Working Directory. | |

* get_nprocs: (libc)Processor Resources. | |

* get_nprocs_conf: (libc)Processor Resources. | |

* get_phys_pages: (libc)Query Memory Parameters. | |

* getauxval: (libc)Auxiliary Vector. | |

* getc: (libc)Character Input. | |

* getc_unlocked: (libc)Character Input. | |

* getchar: (libc)Character Input. | |

* getchar_unlocked: (libc)Character Input. | |

* getcontext: (libc)System V contexts. | |

* getcwd: (libc)Working Directory. | |

* getdate: (libc)General Time String Parsing. | |

* getdate_r: (libc)General Time String Parsing. | |

* getdelim: (libc)Line Input. | |

* getdomainnname: (libc)Host Identification. | |

* getegid: (libc)Reading Persona. | |

* getenv: (libc)Environment Access. | |

* geteuid: (libc)Reading Persona. | |

* getfsent: (libc)fstab. | |

* getfsfile: (libc)fstab. | |

* getfsspec: (libc)fstab. | |

* getgid: (libc)Reading Persona. | |

* getgrent: (libc)Scanning All Groups. | |

* getgrent_r: (libc)Scanning All Groups. | |

* getgrgid: (libc)Lookup Group. | |

* getgrgid_r: (libc)Lookup Group. | |

* getgrnam: (libc)Lookup Group. | |

* getgrnam_r: (libc)Lookup Group. | |

* getgrouplist: (libc)Setting Groups. | |

* getgroups: (libc)Reading Persona. | |

* gethostbyaddr: (libc)Host Names. | |

* gethostbyaddr_r: (libc)Host Names. | |

* gethostbyname2: (libc)Host Names. | |

* gethostbyname2_r: (libc)Host Names. | |

* gethostbyname: (libc)Host Names. | |

* gethostbyname_r: (libc)Host Names. | |

* gethostent: (libc)Host Names. | |

* gethostid: (libc)Host Identification. | |

* gethostname: (libc)Host Identification. | |

* getitimer: (libc)Setting an Alarm. | |

* getline: (libc)Line Input. | |

* getloadavg: (libc)Processor Resources. | |

* getlogin: (libc)Who Logged In. | |

* getmntent: (libc)mtab. | |

* getmntent_r: (libc)mtab. | |

* getnetbyaddr: (libc)Networks Database. | |

* getnetbyname: (libc)Networks Database. | |

* getnetent: (libc)Networks Database. | |

* getnetgrent: (libc)Lookup Netgroup. | |

* getnetgrent_r: (libc)Lookup Netgroup. | |

* getopt: (libc)Using Getopt. | |

* getopt_long: (libc)Getopt Long Options. | |

* getopt_long_only: (libc)Getopt Long Options. | |

* getpagesize: (libc)Query Memory Parameters. | |

* getpass: (libc)getpass. | |

* getpeername: (libc)Who is Connected. | |

* getpgid: (libc)Process Group Functions. | |

* getpgrp: (libc)Process Group Functions. | |

* getpid: (libc)Process Identification. | |

* getppid: (libc)Process Identification. | |

* getpriority: (libc)Traditional Scheduling Functions. | |

* getprotobyname: (libc)Protocols Database. | |

* getprotobynumber: (libc)Protocols Database. | |

* getprotoent: (libc)Protocols Database. | |

* getpt: (libc)Allocation. | |

* getpwent: (libc)Scanning All Users. | |

* getpwent_r: (libc)Scanning All Users. | |

* getpwnam: (libc)Lookup User. | |

* getpwnam_r: (libc)Lookup User. | |

* getpwuid: (libc)Lookup User. | |

* getpwuid_r: (libc)Lookup User. | |

* getrlimit64: (libc)Limits on Resources. | |

* getrlimit: (libc)Limits on Resources. | |

* getrusage: (libc)Resource Usage. | |

* gets: (libc)Line Input. | |

* getservbyname: (libc)Services Database. | |

* getservbyport: (libc)Services Database. | |

* getservent: (libc)Services Database. | |

* getsid: (libc)Process Group Functions. | |

* getsockname: (libc)Reading Address. | |

* getsockopt: (libc)Socket Option Functions. | |

* getsubopt: (libc)Suboptions. | |

* gettext: (libc)Translation with gettext. | |

* gettimeofday: (libc)High-Resolution Calendar. | |

* getuid: (libc)Reading Persona. | |

* getumask: (libc)Setting Permissions. | |

* getutent: (libc)Manipulating the Database. | |

* getutent_r: (libc)Manipulating the Database. | |

* getutid: (libc)Manipulating the Database. | |

* getutid_r: (libc)Manipulating the Database. | |

* getutline: (libc)Manipulating the Database. | |

* getutline_r: (libc)Manipulating the Database. | |

* getutmp: (libc)XPG Functions. | |

* getutmpx: (libc)XPG Functions. | |

* getutxent: (libc)XPG Functions. | |

* getutxid: (libc)XPG Functions. | |

* getutxline: (libc)XPG Functions. | |

* getw: (libc)Character Input. | |

* getwc: (libc)Character Input. | |

* getwc_unlocked: (libc)Character Input. | |

* getwchar: (libc)Character Input. | |

* getwchar_unlocked: (libc)Character Input. | |

* getwd: (libc)Working Directory. | |

* glob64: (libc)Calling Glob. | |

* glob: (libc)Calling Glob. | |

* globfree64: (libc)More Flags for Globbing. | |

* globfree: (libc)More Flags for Globbing. | |

* gmtime: (libc)Broken-down Time. | |

* gmtime_r: (libc)Broken-down Time. | |

* grantpt: (libc)Allocation. | |

* gsignal: (libc)Signaling Yourself. | |

* gtty: (libc)BSD Terminal Modes. | |

* hasmntopt: (libc)mtab. | |

* hcreate: (libc)Hash Search Function. | |

* hcreate_r: (libc)Hash Search Function. | |

* hdestroy: (libc)Hash Search Function. | |

* hdestroy_r: (libc)Hash Search Function. | |

* hsearch: (libc)Hash Search Function. | |

* hsearch_r: (libc)Hash Search Function. | |

* htonl: (libc)Byte Order. | |

* htons: (libc)Byte Order. | |

* hypot: (libc)Exponents and Logarithms. | |

* hypotf: (libc)Exponents and Logarithms. | |

* hypotl: (libc)Exponents and Logarithms. | |

* iconv: (libc)Generic Conversion Interface. | |

* iconv_close: (libc)Generic Conversion Interface. | |

* iconv_open: (libc)Generic Conversion Interface. | |

* if_freenameindex: (libc)Interface Naming. | |

* if_indextoname: (libc)Interface Naming. | |

* if_nameindex: (libc)Interface Naming. | |

* if_nametoindex: (libc)Interface Naming. | |

* ilogb: (libc)Exponents and Logarithms. | |

* ilogbf: (libc)Exponents and Logarithms. | |

* ilogbl: (libc)Exponents and Logarithms. | |

* imaxabs: (libc)Absolute Value. | |

* imaxdiv: (libc)Integer Division. | |

* in6addr_any: (libc)Host Address Data Type. | |

* in6addr_loopback: (libc)Host Address Data Type. | |

* index: (libc)Search Functions. | |

* inet_addr: (libc)Host Address Functions. | |

* inet_aton: (libc)Host Address Functions. | |

* inet_lnaof: (libc)Host Address Functions. | |

* inet_makeaddr: (libc)Host Address Functions. | |

* inet_netof: (libc)Host Address Functions. | |

* inet_network: (libc)Host Address Functions. | |

* inet_ntoa: (libc)Host Address Functions. | |

* inet_ntop: (libc)Host Address Functions. | |

* inet_pton: (libc)Host Address Functions. | |

* initgroups: (libc)Setting Groups. | |

* initstate: (libc)BSD Random. | |

* initstate_r: (libc)BSD Random. | |

* innetgr: (libc)Netgroup Membership. | |

* ioctl: (libc)IOCTLs. | |

* isalnum: (libc)Classification of Characters. | |

* isalpha: (libc)Classification of Characters. | |

* isascii: (libc)Classification of Characters. | |

* isatty: (libc)Is It a Terminal. | |

* isblank: (libc)Classification of Characters. | |

* iscntrl: (libc)Classification of Characters. | |

* isdigit: (libc)Classification of Characters. | |

* isfinite: (libc)Floating Point Classes. | |

* isgraph: (libc)Classification of Characters. | |

* isgreater: (libc)FP Comparison Functions. | |

* isgreaterequal: (libc)FP Comparison Functions. | |

* isinf: (libc)Floating Point Classes. | |

* isinff: (libc)Floating Point Classes. | |

* isinfl: (libc)Floating Point Classes. | |

* isless: (libc)FP Comparison Functions. | |

* islessequal: (libc)FP Comparison Functions. | |

* islessgreater: (libc)FP Comparison Functions. | |

* islower: (libc)Classification of Characters. | |

* isnan: (libc)Floating Point Classes. | |

* isnan: (libc)Floating Point Classes. | |

* isnanf: (libc)Floating Point Classes. | |

* isnanl: (libc)Floating Point Classes. | |

* isnormal: (libc)Floating Point Classes. | |

* isprint: (libc)Classification of Characters. | |

* ispunct: (libc)Classification of Characters. | |

* issignaling: (libc)Floating Point Classes. | |

* isspace: (libc)Classification of Characters. | |

* isunordered: (libc)FP Comparison Functions. | |

* isupper: (libc)Classification of Characters. | |

* iswalnum: (libc)Classification of Wide Characters. | |

* iswalpha: (libc)Classification of Wide Characters. | |

* iswblank: (libc)Classification of Wide Characters. | |

* iswcntrl: (libc)Classification of Wide Characters. | |

* iswctype: (libc)Classification of Wide Characters. | |

* iswdigit: (libc)Classification of Wide Characters. | |

* iswgraph: (libc)Classification of Wide Characters. | |

* iswlower: (libc)Classification of Wide Characters. | |

* iswprint: (libc)Classification of Wide Characters. | |

* iswpunct: (libc)Classification of Wide Characters. | |

* iswspace: (libc)Classification of Wide Characters. | |

* iswupper: (libc)Classification of Wide Characters. | |

* iswxdigit: (libc)Classification of Wide Characters. | |

* isxdigit: (libc)Classification of Characters. | |

* j0: (libc)Special Functions. | |

* j0f: (libc)Special Functions. | |

* j0l: (libc)Special Functions. | |

* j1: (libc)Special Functions. | |

* j1f: (libc)Special Functions. | |

* j1l: (libc)Special Functions. | |

* jn: (libc)Special Functions. | |

* jnf: (libc)Special Functions. | |

* jnl: (libc)Special Functions. | |

* jrand48: (libc)SVID Random. | |

* jrand48_r: (libc)SVID Random. | |

* kill: (libc)Signaling Another Process. | |

* killpg: (libc)Signaling Another Process. | |

* l64a: (libc)Encode Binary Data. | |

* labs: (libc)Absolute Value. | |

* lcong48: (libc)SVID Random. | |

* lcong48_r: (libc)SVID Random. | |

* ldexp: (libc)Normalization Functions. | |

* ldexpf: (libc)Normalization Functions. | |

* ldexpl: (libc)Normalization Functions. | |

* ldiv: (libc)Integer Division. | |

* lfind: (libc)Array Search Function. | |

* lgamma: (libc)Special Functions. | |

* lgamma_r: (libc)Special Functions. | |

* lgammaf: (libc)Special Functions. | |

* lgammaf_r: (libc)Special Functions. | |

* lgammal: (libc)Special Functions. | |

* lgammal_r: (libc)Special Functions. | |

* link: (libc)Hard Links. | |

* lio_listio64: (libc)Asynchronous Reads/Writes. | |

* lio_listio: (libc)Asynchronous Reads/Writes. | |

* listen: (libc)Listening. | |

* llabs: (libc)Absolute Value. | |

* lldiv: (libc)Integer Division. | |

* llrint: (libc)Rounding Functions. | |

* llrintf: (libc)Rounding Functions. | |

* llrintl: (libc)Rounding Functions. | |

* llround: (libc)Rounding Functions. | |

* llroundf: (libc)Rounding Functions. | |

* llroundl: (libc)Rounding Functions. | |

* localeconv: (libc)The Lame Way to Locale Data. | |

* localtime: (libc)Broken-down Time. | |

* localtime_r: (libc)Broken-down Time. | |

* log10: (libc)Exponents and Logarithms. | |

* log10f: (libc)Exponents and Logarithms. | |

* log10l: (libc)Exponents and Logarithms. | |

* log1p: (libc)Exponents and Logarithms. | |

* log1pf: (libc)Exponents and Logarithms. | |

* log1pl: (libc)Exponents and Logarithms. | |

* log2: (libc)Exponents and Logarithms. | |

* log2f: (libc)Exponents and Logarithms. | |

* log2l: (libc)Exponents and Logarithms. | |

* log: (libc)Exponents and Logarithms. | |

* logb: (libc)Exponents and Logarithms. | |

* logbf: (libc)Exponents and Logarithms. | |

* logbl: (libc)Exponents and Logarithms. | |

* logf: (libc)Exponents and Logarithms. | |

* login: (libc)Logging In and Out. | |

* login_tty: (libc)Logging In and Out. | |

* logl: (libc)Exponents and Logarithms. | |

* logout: (libc)Logging In and Out. | |

* logwtmp: (libc)Logging In and Out. | |

* longjmp: (libc)Non-Local Details. | |

* lrand48: (libc)SVID Random. | |

* lrand48_r: (libc)SVID Random. | |

* lrint: (libc)Rounding Functions. | |

* lrintf: (libc)Rounding Functions. | |

* lrintl: (libc)Rounding Functions. | |

* lround: (libc)Rounding Functions. | |

* lroundf: (libc)Rounding Functions. | |

* lroundl: (libc)Rounding Functions. | |

* lsearch: (libc)Array Search Function. | |

* lseek64: (libc)File Position Primitive. | |

* lseek: (libc)File Position Primitive. | |

* lstat64: (libc)Reading Attributes. | |

* lstat: (libc)Reading Attributes. | |

* lutimes: (libc)File Times. | |

* madvise: (libc)Memory-mapped I/O. | |

* makecontext: (libc)System V contexts. | |

* mallinfo: (libc)Statistics of Malloc. | |

* malloc: (libc)Basic Allocation. | |

* mallopt: (libc)Malloc Tunable Parameters. | |

* mblen: (libc)Non-reentrant Character Conversion. | |

* mbrlen: (libc)Converting a Character. | |

* mbrtowc: (libc)Converting a Character. | |

* mbsinit: (libc)Keeping the state. | |

* mbsnrtowcs: (libc)Converting Strings. | |

* mbsrtowcs: (libc)Converting Strings. | |

* mbstowcs: (libc)Non-reentrant String Conversion. | |

* mbtowc: (libc)Non-reentrant Character Conversion. | |

* mcheck: (libc)Heap Consistency Checking. | |

* memalign: (libc)Aligned Memory Blocks. | |

* memccpy: (libc)Copying and Concatenation. | |

* memchr: (libc)Search Functions. | |

* memcmp: (libc)String/Array Comparison. | |

* memcpy: (libc)Copying and Concatenation. | |

* memfrob: (libc)Trivial Encryption. | |

* memmem: (libc)Search Functions. | |

* memmove: (libc)Copying and Concatenation. | |

* mempcpy: (libc)Copying and Concatenation. | |

* memrchr: (libc)Search Functions. | |

* memset: (libc)Copying and Concatenation. | |

* mkdir: (libc)Creating Directories. | |

* mkdtemp: (libc)Temporary Files. | |

* mkfifo: (libc)FIFO Special Files. | |

* mknod: (libc)Making Special Files. | |

* mkstemp: (libc)Temporary Files. | |

* mktemp: (libc)Temporary Files. | |

* mktime: (libc)Broken-down Time. | |

* mlock: (libc)Page Lock Functions. | |

* mlockall: (libc)Page Lock Functions. | |

* mmap64: (libc)Memory-mapped I/O. | |

* mmap: (libc)Memory-mapped I/O. | |

* modf: (libc)Rounding Functions. | |

* modff: (libc)Rounding Functions. | |

* modfl: (libc)Rounding Functions. | |

* mount: (libc)Mount-Unmount-Remount. | |

* mprobe: (libc)Heap Consistency Checking. | |

* mrand48: (libc)SVID Random. | |

* mrand48_r: (libc)SVID Random. | |

* mremap: (libc)Memory-mapped I/O. | |

* msync: (libc)Memory-mapped I/O. | |

* mtrace: (libc)Tracing malloc. | |

* munlock: (libc)Page Lock Functions. | |

* munlockall: (libc)Page Lock Functions. | |

* munmap: (libc)Memory-mapped I/O. | |

* muntrace: (libc)Tracing malloc. | |

* nan: (libc)FP Bit Twiddling. | |

* nanf: (libc)FP Bit Twiddling. | |

* nanl: (libc)FP Bit Twiddling. | |

* nanosleep: (libc)Sleeping. | |

* nearbyint: (libc)Rounding Functions. | |

* nearbyintf: (libc)Rounding Functions. | |

* nearbyintl: (libc)Rounding Functions. | |

* nextafter: (libc)FP Bit Twiddling. | |

* nextafterf: (libc)FP Bit Twiddling. | |

* nextafterl: (libc)FP Bit Twiddling. | |

* nexttoward: (libc)FP Bit Twiddling. | |

* nexttowardf: (libc)FP Bit Twiddling. | |

* nexttowardl: (libc)FP Bit Twiddling. | |

* nftw64: (libc)Working with Directory Trees. | |

* nftw: (libc)Working with Directory Trees. | |

* ngettext: (libc)Advanced gettext functions. | |

* nice: (libc)Traditional Scheduling Functions. | |

* nl_langinfo: (libc)The Elegant and Fast Way. | |

* nrand48: (libc)SVID Random. | |

* nrand48_r: (libc)SVID Random. | |

* ntohl: (libc)Byte Order. | |

* ntohs: (libc)Byte Order. | |

* ntp_adjtime: (libc)High Accuracy Clock. | |

* ntp_gettime: (libc)High Accuracy Clock. | |

* obstack_1grow: (libc)Growing Objects. | |

* obstack_1grow_fast: (libc)Extra Fast Growing. | |

* obstack_alignment_mask: (libc)Obstacks Data Alignment. | |

* obstack_alloc: (libc)Allocation in an Obstack. | |

* obstack_base: (libc)Status of an Obstack. | |

* obstack_blank: (libc)Growing Objects. | |

* obstack_blank_fast: (libc)Extra Fast Growing. | |

* obstack_chunk_size: (libc)Obstack Chunks. | |

* obstack_copy0: (libc)Allocation in an Obstack. | |

* obstack_copy: (libc)Allocation in an Obstack. | |

* obstack_finish: (libc)Growing Objects. | |

* obstack_free: (libc)Freeing Obstack Objects. | |

* obstack_grow0: (libc)Growing Objects. | |

* obstack_grow: (libc)Growing Objects. | |

* obstack_init: (libc)Preparing for Obstacks. | |

* obstack_int_grow: (libc)Growing Objects. | |

* obstack_int_grow_fast: (libc)Extra Fast Growing. | |

* obstack_next_free: (libc)Status of an Obstack. | |

* obstack_object_size: (libc)Growing Objects. | |

* obstack_object_size: (libc)Status of an Obstack. | |

* obstack_printf: (libc)Dynamic Output. | |

* obstack_ptr_grow: (libc)Growing Objects. | |

* obstack_ptr_grow_fast: (libc)Extra Fast Growing. | |

* obstack_room: (libc)Extra Fast Growing. | |

* obstack_vprintf: (libc)Variable Arguments Output. | |

* offsetof: (libc)Structure Measurement. | |

* on_exit: (libc)Cleanups on Exit. | |

* open64: (libc)Opening and Closing Files. | |

* open: (libc)Opening and Closing Files. | |

* open_memstream: (libc)String Streams. | |

* opendir: (libc)Opening a Directory. | |

* openlog: (libc)openlog. | |

* openpty: (libc)Pseudo-Terminal Pairs. | |

* parse_printf_format: (libc)Parsing a Template String. | |

* pathconf: (libc)Pathconf. | |

* pause: (libc)Using Pause. | |

* pclose: (libc)Pipe to a Subprocess. | |

* perror: (libc)Error Messages. | |

* pipe: (libc)Creating a Pipe. | |

* popen: (libc)Pipe to a Subprocess. | |

* posix_memalign: (libc)Aligned Memory Blocks. | |

* pow10: (libc)Exponents and Logarithms. | |

* pow10f: (libc)Exponents and Logarithms. | |

* pow10l: (libc)Exponents and Logarithms. | |

* pow: (libc)Exponents and Logarithms. | |

* powf: (libc)Exponents and Logarithms. | |

* powl: (libc)Exponents and Logarithms. | |

* pread64: (libc)I/O Primitives. | |

* pread: (libc)I/O Primitives. | |

* printf: (libc)Formatted Output Functions. | |

* printf_size: (libc)Predefined Printf Handlers. | |

* printf_size_info: (libc)Predefined Printf Handlers. | |

* psignal: (libc)Signal Messages. | |

* pthread_getattr_default_np: (libc)Default Thread Attributes. | |

* pthread_getspecific: (libc)Thread-specific Data. | |

* pthread_key_create: (libc)Thread-specific Data. | |

* pthread_key_delete: (libc)Thread-specific Data. | |

* pthread_setattr_default_np: (libc)Default Thread Attributes. | |

* pthread_setspecific: (libc)Thread-specific Data. | |

* ptsname: (libc)Allocation. | |

* ptsname_r: (libc)Allocation. | |

* putc: (libc)Simple Output. | |

* putc_unlocked: (libc)Simple Output. | |

* putchar: (libc)Simple Output. | |

* putchar_unlocked: (libc)Simple Output. | |

* putenv: (libc)Environment Access. | |

* putpwent: (libc)Writing a User Entry. | |

* puts: (libc)Simple Output. | |

* pututline: (libc)Manipulating the Database. | |

* pututxline: (libc)XPG Functions. | |

* putw: (libc)Simple Output. | |

* putwc: (libc)Simple Output. | |

* putwc_unlocked: (libc)Simple Output. | |

* putwchar: (libc)Simple Output. | |

* putwchar_unlocked: (libc)Simple Output. | |

* pwrite64: (libc)I/O Primitives. | |

* pwrite: (libc)I/O Primitives. | |

* qecvt: (libc)System V Number Conversion. | |

* qecvt_r: (libc)System V Number Conversion. | |

* qfcvt: (libc)System V Number Conversion. | |

* qfcvt_r: (libc)System V Number Conversion. | |

* qgcvt: (libc)System V Number Conversion. | |

* qsort: (libc)Array Sort Function. | |

* raise: (libc)Signaling Yourself. | |

* rand: (libc)ISO Random. | |

* rand_r: (libc)ISO Random. | |

* random: (libc)BSD Random. | |

* random_r: (libc)BSD Random. | |

* rawmemchr: (libc)Search Functions. | |

* read: (libc)I/O Primitives. | |

* readdir64: (libc)Reading/Closing Directory. | |

* readdir64_r: (libc)Reading/Closing Directory. | |

* readdir: (libc)Reading/Closing Directory. | |

* readdir_r: (libc)Reading/Closing Directory. | |

* readlink: (libc)Symbolic Links. | |

* readv: (libc)Scatter-Gather. | |

* realloc: (libc)Changing Block Size. | |

* realpath: (libc)Symbolic Links. | |

* recv: (libc)Receiving Data. | |

* recvfrom: (libc)Receiving Datagrams. | |

* recvmsg: (libc)Receiving Datagrams. | |

* regcomp: (libc)POSIX Regexp Compilation. | |

* regerror: (libc)Regexp Cleanup. | |

* regexec: (libc)Matching POSIX Regexps. | |

* regfree: (libc)Regexp Cleanup. | |

* register_printf_function: (libc)Registering New Conversions. | |

* remainder: (libc)Remainder Functions. | |

* remainderf: (libc)Remainder Functions. | |

* remainderl: (libc)Remainder Functions. | |

* remove: (libc)Deleting Files. | |

* rename: (libc)Renaming Files. | |

* rewind: (libc)File Positioning. | |

* rewinddir: (libc)Random Access Directory. | |

* rindex: (libc)Search Functions. | |

* rint: (libc)Rounding Functions. | |

* rintf: (libc)Rounding Functions. | |

* rintl: (libc)Rounding Functions. | |

* rmdir: (libc)Deleting Files. | |

* round: (libc)Rounding Functions. | |

* roundf: (libc)Rounding Functions. | |

* roundl: (libc)Rounding Functions. | |

* rpmatch: (libc)Yes-or-No Questions. | |

* sbrk: (libc)Resizing the Data Segment. | |

* scalb: (libc)Normalization Functions. | |

* scalbf: (libc)Normalization Functions. | |

* scalbl: (libc)Normalization Functions. | |

* scalbln: (libc)Normalization Functions. | |

* scalblnf: (libc)Normalization Functions. | |

* scalblnl: (libc)Normalization Functions. | |

* scalbn: (libc)Normalization Functions. | |

* scalbnf: (libc)Normalization Functions. | |

* scalbnl: (libc)Normalization Functions. | |

* scandir64: (libc)Scanning Directory Content. | |

* scandir: (libc)Scanning Directory Content. | |

* scanf: (libc)Formatted Input Functions. | |

* sched_get_priority_max: (libc)Basic Scheduling Functions. | |

* sched_get_priority_min: (libc)Basic Scheduling Functions. | |

* sched_getaffinity: (libc)CPU Affinity. | |

* sched_getparam: (libc)Basic Scheduling Functions. | |

* sched_getscheduler: (libc)Basic Scheduling Functions. | |

* sched_rr_get_interval: (libc)Basic Scheduling Functions. | |

* sched_setaffinity: (libc)CPU Affinity. | |

* sched_setparam: (libc)Basic Scheduling Functions. | |

* sched_setscheduler: (libc)Basic Scheduling Functions. | |

* sched_yield: (libc)Basic Scheduling Functions. | |

* secure_getenv: (libc)Environment Access. | |

* seed48: (libc)SVID Random. | |

* seed48_r: (libc)SVID Random. | |

* seekdir: (libc)Random Access Directory. | |

* select: (libc)Waiting for I/O. | |

* send: (libc)Sending Data. | |

* sendmsg: (libc)Receiving Datagrams. | |

* sendto: (libc)Sending Datagrams. | |

* setbuf: (libc)Controlling Buffering. | |

* setbuffer: (libc)Controlling Buffering. | |

* setcontext: (libc)System V contexts. | |

* setdomainname: (libc)Host Identification. | |

* setegid: (libc)Setting Groups. | |

* setenv: (libc)Environment Access. | |

* seteuid: (libc)Setting User ID. | |

* setfsent: (libc)fstab. | |

* setgid: (libc)Setting Groups. | |

* setgrent: (libc)Scanning All Groups. | |

* setgroups: (libc)Setting Groups. | |

* sethostent: (libc)Host Names. | |

* sethostid: (libc)Host Identification. | |

* sethostname: (libc)Host Identification. | |

* setitimer: (libc)Setting an Alarm. | |

* setjmp: (libc)Non-Local Details. | |

* setkey: (libc)DES Encryption. | |

* setkey_r: (libc)DES Encryption. | |

* setlinebuf: (libc)Controlling Buffering. | |

* setlocale: (libc)Setting the Locale. | |

* setlogmask: (libc)setlogmask. | |

* setmntent: (libc)mtab. | |

* setnetent: (libc)Networks Database. | |

* setnetgrent: (libc)Lookup Netgroup. | |

* setpgid: (libc)Process Group Functions. | |

* setpgrp: (libc)Process Group Functions. | |

* setpriority: (libc)Traditional Scheduling Functions. | |

* setprotoent: (libc)Protocols Database. | |

* setpwent: (libc)Scanning All Users. | |

* setregid: (libc)Setting Groups. | |

* setreuid: (libc)Setting User ID. | |

* setrlimit64: (libc)Limits on Resources. | |

* setrlimit: (libc)Limits on Resources. | |

* setservent: (libc)Services Database. | |

* setsid: (libc)Process Group Functions. | |

* setsockopt: (libc)Socket Option Functions. | |

* setstate: (libc)BSD Random. | |

* setstate_r: (libc)BSD Random. | |

* settimeofday: (libc)High-Resolution Calendar. | |

* setuid: (libc)Setting User ID. | |

* setutent: (libc)Manipulating the Database. | |

* setutxent: (libc)XPG Functions. | |

* setvbuf: (libc)Controlling Buffering. | |

* shm_open: (libc)Memory-mapped I/O. | |

* shm_unlink: (libc)Memory-mapped I/O. | |

* shutdown: (libc)Closing a Socket. | |

* sigaction: (libc)Advanced Signal Handling. | |

* sigaddset: (libc)Signal Sets. | |

* sigaltstack: (libc)Signal Stack. | |

* sigblock: (libc)Blocking in BSD. | |

* sigdelset: (libc)Signal Sets. | |

* sigemptyset: (libc)Signal Sets. | |

* sigfillset: (libc)Signal Sets. | |

* siginterrupt: (libc)BSD Handler. | |

* sigismember: (libc)Signal Sets. | |

* siglongjmp: (libc)Non-Local Exits and Signals. | |

* sigmask: (libc)Blocking in BSD. | |

* signal: (libc)Basic Signal Handling. | |

* signbit: (libc)FP Bit Twiddling. | |

* significand: (libc)Normalization Functions. | |

* significandf: (libc)Normalization Functions. | |

* significandl: (libc)Normalization Functions. | |

* sigpause: (libc)Blocking in BSD. | |

* sigpending: (libc)Checking for Pending Signals. | |

* sigprocmask: (libc)Process Signal Mask. | |

* sigsetjmp: (libc)Non-Local Exits and Signals. | |

* sigsetmask: (libc)Blocking in BSD. | |

* sigstack: (libc)Signal Stack. | |

* sigsuspend: (libc)Sigsuspend. | |

* sigvec: (libc)BSD Handler. | |

* sin: (libc)Trig Functions. | |

* sincos: (libc)Trig Functions. | |

* sincosf: (libc)Trig Functions. | |

* sincosl: (libc)Trig Functions. | |

* sinf: (libc)Trig Functions. | |

* sinh: (libc)Hyperbolic Functions. | |

* sinhf: (libc)Hyperbolic Functions. | |

* sinhl: (libc)Hyperbolic Functions. | |

* sinl: (libc)Trig Functions. | |

* sleep: (libc)Sleeping. | |

* snprintf: (libc)Formatted Output Functions. | |

* socket: (libc)Creating a Socket. | |

* socketpair: (libc)Socket Pairs. | |

* sprintf: (libc)Formatted Output Functions. | |

* sqrt: (libc)Exponents and Logarithms. | |

* sqrtf: (libc)Exponents and Logarithms. | |

* sqrtl: (libc)Exponents and Logarithms. | |

* srand48: (libc)SVID Random. | |

* srand48_r: (libc)SVID Random. | |

* srand: (libc)ISO Random. | |

* srandom: (libc)BSD Random. | |

* srandom_r: (libc)BSD Random. | |

* sscanf: (libc)Formatted Input Functions. | |

* ssignal: (libc)Basic Signal Handling. | |

* stat64: (libc)Reading Attributes. | |

* stat: (libc)Reading Attributes. | |

* stime: (libc)Simple Calendar Time. | |

* stpcpy: (libc)Copying and Concatenation. | |

* stpncpy: (libc)Copying and Concatenation. | |

* strcasecmp: (libc)String/Array Comparison. | |

* strcasestr: (libc)Search Functions. | |

* strcat: (libc)Copying and Concatenation. | |

* strchr: (libc)Search Functions. | |

* strchrnul: (libc)Search Functions. | |

* strcmp: (libc)String/Array Comparison. | |

* strcoll: (libc)Collation Functions. | |

* strcpy: (libc)Copying and Concatenation. | |

* strcspn: (libc)Search Functions. | |

* strdup: (libc)Copying and Concatenation. | |

* strdupa: (libc)Copying and Concatenation. | |

* strerror: (libc)Error Messages. | |

* strerror_r: (libc)Error Messages. | |

* strfmon: (libc)Formatting Numbers. | |

* strfry: (libc)strfry. | |

* strftime: (libc)Formatting Calendar Time. | |

* strlen: (libc)String Length. | |

* strncasecmp: (libc)String/Array Comparison. | |

* strncat: (libc)Copying and Concatenation. | |

* strncmp: (libc)String/Array Comparison. | |

* strncpy: (libc)Copying and Concatenation. | |

* strndup: (libc)Copying and Concatenation. | |

* strndupa: (libc)Copying and Concatenation. | |

* strnlen: (libc)String Length. | |

* strpbrk: (libc)Search Functions. | |

* strptime: (libc)Low-Level Time String Parsing. | |

* strrchr: (libc)Search Functions. | |

* strsep: (libc)Finding Tokens in a String. | |

* strsignal: (libc)Signal Messages. | |

* strspn: (libc)Search Functions. | |

* strstr: (libc)Search Functions. | |

* strtod: (libc)Parsing of Floats. | |

* strtof: (libc)Parsing of Floats. | |

* strtoimax: (libc)Parsing of Integers. | |

* strtok: (libc)Finding Tokens in a String. | |

* strtok_r: (libc)Finding Tokens in a String. | |

* strtol: (libc)Parsing of Integers. | |

* strtold: (libc)Parsing of Floats. | |

* strtoll: (libc)Parsing of Integers. | |

* strtoq: (libc)Parsing of Integers. | |

* strtoul: (libc)Parsing of Integers. | |

* strtoull: (libc)Parsing of Integers. | |

* strtoumax: (libc)Parsing of Integers. | |

* strtouq: (libc)Parsing of Integers. | |

* strverscmp: (libc)String/Array Comparison. | |

* strxfrm: (libc)Collation Functions. | |

* stty: (libc)BSD Terminal Modes. | |

* swapcontext: (libc)System V contexts. | |

* swprintf: (libc)Formatted Output Functions. | |

* swscanf: (libc)Formatted Input Functions. | |

* symlink: (libc)Symbolic Links. | |

* sync: (libc)Synchronizing I/O. | |

* syscall: (libc)System Calls. | |

* sysconf: (libc)Sysconf Definition. | |

* sysctl: (libc)System Parameters. | |

* syslog: (libc)syslog; vsyslog. | |

* system: (libc)Running a Command. | |

* sysv_signal: (libc)Basic Signal Handling. | |

* tan: (libc)Trig Functions. | |

* tanf: (libc)Trig Functions. | |

* tanh: (libc)Hyperbolic Functions. | |

* tanhf: (libc)Hyperbolic Functions. | |

* tanhl: (libc)Hyperbolic Functions. | |

* tanl: (libc)Trig Functions. | |

* tcdrain: (libc)Line Control. | |

* tcflow: (libc)Line Control. | |

* tcflush: (libc)Line Control. | |

* tcgetattr: (libc)Mode Functions. | |

* tcgetpgrp: (libc)Terminal Access Functions. | |

* tcgetsid: (libc)Terminal Access Functions. | |

* tcsendbreak: (libc)Line Control. | |

* tcsetattr: (libc)Mode Functions. | |

* tcsetpgrp: (libc)Terminal Access Functions. | |

* tdelete: (libc)Tree Search Function. | |

* tdestroy: (libc)Tree Search Function. | |

* telldir: (libc)Random Access Directory. | |

* tempnam: (libc)Temporary Files. | |

* textdomain: (libc)Locating gettext catalog. | |

* tfind: (libc)Tree Search Function. | |

* tgamma: (libc)Special Functions. | |

* tgammaf: (libc)Special Functions. | |

* tgammal: (libc)Special Functions. | |

* time: (libc)Simple Calendar Time. | |

* timegm: (libc)Broken-down Time. | |

* timelocal: (libc)Broken-down Time. | |

* times: (libc)Processor Time. | |

* tmpfile64: (libc)Temporary Files. | |

* tmpfile: (libc)Temporary Files. | |

* tmpnam: (libc)Temporary Files. | |

* tmpnam_r: (libc)Temporary Files. | |

* toascii: (libc)Case Conversion. | |

* tolower: (libc)Case Conversion. | |

* toupper: (libc)Case Conversion. | |

* towctrans: (libc)Wide Character Case Conversion. | |

* towlower: (libc)Wide Character Case Conversion. | |

* towupper: (libc)Wide Character Case Conversion. | |

* trunc: (libc)Rounding Functions. | |

* truncate64: (libc)File Size. | |

* truncate: (libc)File Size. | |

* truncf: (libc)Rounding Functions. | |

* truncl: (libc)Rounding Functions. | |

* tsearch: (libc)Tree Search Function. | |

* ttyname: (libc)Is It a Terminal. | |

* ttyname_r: (libc)Is It a Terminal. | |

* twalk: (libc)Tree Search Function. | |

* tzset: (libc)Time Zone Functions. | |

* ulimit: (libc)Limits on Resources. | |

* umask: (libc)Setting Permissions. | |

* umount2: (libc)Mount-Unmount-Remount. | |

* umount: (libc)Mount-Unmount-Remount. | |

* uname: (libc)Platform Type. | |

* ungetc: (libc)How Unread. | |

* ungetwc: (libc)How Unread. | |

* unlink: (libc)Deleting Files. | |

* unlockpt: (libc)Allocation. | |

* unsetenv: (libc)Environment Access. | |

* updwtmp: (libc)Manipulating the Database. | |

* utime: (libc)File Times. | |

* utimes: (libc)File Times. | |

* utmpname: (libc)Manipulating the Database. | |

* utmpxname: (libc)XPG Functions. | |

* va_arg: (libc)Argument Macros. | |

* va_copy: (libc)Argument Macros. | |

* va_end: (libc)Argument Macros. | |

* va_start: (libc)Argument Macros. | |

* valloc: (libc)Aligned Memory Blocks. | |

* vasprintf: (libc)Variable Arguments Output. | |

* verr: (libc)Error Messages. | |

* verrx: (libc)Error Messages. | |

* versionsort64: (libc)Scanning Directory Content. | |

* versionsort: (libc)Scanning Directory Content. | |

* vfork: (libc)Creating a Process. | |

* vfprintf: (libc)Variable Arguments Output. | |

* vfscanf: (libc)Variable Arguments Input. | |

* vfwprintf: (libc)Variable Arguments Output. | |

* vfwscanf: (libc)Variable Arguments Input. | |

* vlimit: (libc)Limits on Resources. | |

* vprintf: (libc)Variable Arguments Output. | |

* vscanf: (libc)Variable Arguments Input. | |

* vsnprintf: (libc)Variable Arguments Output. | |

* vsprintf: (libc)Variable Arguments Output. | |

* vsscanf: (libc)Variable Arguments Input. | |

* vswprintf: (libc)Variable Arguments Output. | |

* vswscanf: (libc)Variable Arguments Input. | |

* vsyslog: (libc)syslog; vsyslog. | |

* vtimes: (libc)Resource Usage. | |

* vwarn: (libc)Error Messages. | |

* vwarnx: (libc)Error Messages. | |

* vwprintf: (libc)Variable Arguments Output. | |

* vwscanf: (libc)Variable Arguments Input. | |

* wait3: (libc)BSD Wait Functions. | |

* wait4: (libc)Process Completion. | |

* wait: (libc)Process Completion. | |

* waitpid: (libc)Process Completion. | |

* warn: (libc)Error Messages. | |

* warnx: (libc)Error Messages. | |

* wcpcpy: (libc)Copying and Concatenation. | |

* wcpncpy: (libc)Copying and Concatenation. | |

* wcrtomb: (libc)Converting a Character. | |

* wcscasecmp: (libc)String/Array Comparison. | |

* wcscat: (libc)Copying and Concatenation. | |

* wcschr: (libc)Search Functions. | |

* wcschrnul: (libc)Search Functions. | |

* wcscmp: (libc)String/Array Comparison. | |

* wcscoll: (libc)Collation Functions. | |

* wcscpy: (libc)Copying and Concatenation. | |

* wcscspn: (libc)Search Functions. | |

* wcsdup: (libc)Copying and Concatenation. | |

* wcsftime: (libc)Formatting Calendar Time. | |

* wcslen: (libc)String Length. | |

* wcsncasecmp: (libc)String/Array Comparison. | |

* wcsncat: (libc)Copying and Concatenation. | |

* wcsncmp: (libc)String/Array Comparison. | |

* wcsncpy: (libc)Copying and Concatenation. | |

* wcsnlen: (libc)String Length. | |

* wcsnrtombs: (libc)Converting Strings. | |

* wcspbrk: (libc)Search Functions. | |

* wcsrchr: (libc)Search Functions. | |

* wcsrtombs: (libc)Converting Strings. | |

* wcsspn: (libc)Search Functions. | |

* wcsstr: (libc)Search Functions. | |

* wcstod: (libc)Parsing of Floats. | |

* wcstof: (libc)Parsing of Floats. | |

* wcstoimax: (libc)Parsing of Integers. | |

* wcstok: (libc)Finding Tokens in a String. | |

* wcstol: (libc)Parsing of Integers. | |

* wcstold: (libc)Parsing of Floats. | |

* wcstoll: (libc)Parsing of Integers. | |

* wcstombs: (libc)Non-reentrant String Conversion. | |

* wcstoq: (libc)Parsing of Integers. | |

* wcstoul: (libc)Parsing of Integers. | |

* wcstoull: (libc)Parsing of Integers. | |

* wcstoumax: (libc)Parsing of Integers. | |

* wcstouq: (libc)Parsing of Integers. | |

* wcswcs: (libc)Search Functions. | |

* wcsxfrm: (libc)Collation Functions. | |

* wctob: (libc)Converting a Character. | |

* wctomb: (libc)Non-reentrant Character Conversion. | |

* wctrans: (libc)Wide Character Case Conversion. | |

* wctype: (libc)Classification of Wide Characters. | |

* wmemchr: (libc)Search Functions. | |

* wmemcmp: (libc)String/Array Comparison. | |

* wmemcpy: (libc)Copying and Concatenation. | |

* wmemmove: (libc)Copying and Concatenation. | |

* wmempcpy: (libc)Copying and Concatenation. | |

* wmemset: (libc)Copying and Concatenation. | |

* wordexp: (libc)Calling Wordexp. | |

* wordfree: (libc)Calling Wordexp. | |

* wprintf: (libc)Formatted Output Functions. | |

* write: (libc)I/O Primitives. | |

* writev: (libc)Scatter-Gather. | |

* wscanf: (libc)Formatted Input Functions. | |

* y0: (libc)Special Functions. | |

* y0f: (libc)Special Functions. | |

* y0l: (libc)Special Functions. | |

* y1: (libc)Special Functions. | |

* y1f: (libc)Special Functions. | |

* y1l: (libc)Special Functions. | |

* yn: (libc)Special Functions. | |

* ynf: (libc)Special Functions. | |

* ynl: (libc)Special Functions. | |

END-INFO-DIR-ENTRY | |

File: libc.info, Node: Arithmetic, Next: Date and Time, Prev: Mathematics, Up: Top | |

20 Arithmetic Functions | |

*********************** | |

This chapter contains information about functions for doing basic | |

arithmetic operations, such as splitting a float into its integer and | |

fractional parts or retrieving the imaginary part of a complex value. | |

These functions are declared in the header files 'math.h' and | |

'complex.h'. | |

* Menu: | |

* Integers:: Basic integer types and concepts | |

* Integer Division:: Integer division with guaranteed rounding. | |

* Floating Point Numbers:: Basic concepts. IEEE 754. | |

* Floating Point Classes:: The five kinds of floating-point number. | |

* Floating Point Errors:: When something goes wrong in a calculation. | |

* Rounding:: Controlling how results are rounded. | |

* Control Functions:: Saving and restoring the FPU's state. | |

* Arithmetic Functions:: Fundamental operations provided by the library. | |

* Complex Numbers:: The types. Writing complex constants. | |

* Operations on Complex:: Projection, conjugation, decomposition. | |

* Parsing of Numbers:: Converting strings to numbers. | |

* System V Number Conversion:: An archaic way to convert numbers to strings. | |

File: libc.info, Node: Integers, Next: Integer Division, Up: Arithmetic | |

20.1 Integers | |

============= | |

The C language defines several integer data types: integer, short | |

integer, long integer, and character, all in both signed and unsigned | |

varieties. The GNU C compiler extends the language to contain long long | |

integers as well. | |

The C integer types were intended to allow code to be portable among | |

machines with different inherent data sizes (word sizes), so each type | |

may have different ranges on different machines. The problem with this | |

is that a program often needs to be written for a particular range of | |

integers, and sometimes must be written for a particular size of | |

storage, regardless of what machine the program runs on. | |

To address this problem, the GNU C Library contains C type | |

definitions you can use to declare integers that meet your exact needs. | |

Because the GNU C Library header files are customized to a specific | |

machine, your program source code doesn't have to be. | |

These 'typedef's are in 'stdint.h'. | |

If you require that an integer be represented in exactly N bits, use | |

one of the following types, with the obvious mapping to bit size and | |

signedness: | |

* int8_t | |

* int16_t | |

* int32_t | |

* int64_t | |

* uint8_t | |

* uint16_t | |

* uint32_t | |

* uint64_t | |

If your C compiler and target machine do not allow integers of a | |

certain size, the corresponding above type does not exist. | |

If you don't need a specific storage size, but want the smallest data | |

structure with _at least_ N bits, use one of these: | |

* int_least8_t | |

* int_least16_t | |

* int_least32_t | |

* int_least64_t | |

* uint_least8_t | |

* uint_least16_t | |

* uint_least32_t | |

* uint_least64_t | |

If you don't need a specific storage size, but want the data | |

structure that allows the fastest access while having at least N bits | |

(and among data structures with the same access speed, the smallest | |

one), use one of these: | |

* int_fast8_t | |

* int_fast16_t | |

* int_fast32_t | |

* int_fast64_t | |

* uint_fast8_t | |

* uint_fast16_t | |

* uint_fast32_t | |

* uint_fast64_t | |

If you want an integer with the widest range possible on the platform | |

on which it is being used, use one of the following. If you use these, | |

you should write code that takes into account the variable size and | |

range of the integer. | |

* intmax_t | |

* uintmax_t | |

The GNU C Library also provides macros that tell you the maximum and | |

minimum possible values for each integer data type. The macro names | |

follow these examples: 'INT32_MAX', 'UINT8_MAX', 'INT_FAST32_MIN', | |

'INT_LEAST64_MIN', 'UINTMAX_MAX', 'INTMAX_MAX', 'INTMAX_MIN'. Note that | |

there are no macros for unsigned integer minima. These are always zero. | |

There are similar macros for use with C's built in integer types | |

which should come with your C compiler. These are described in *note | |

Data Type Measurements::. | |

Don't forget you can use the C 'sizeof' function with any of these | |

data types to get the number of bytes of storage each uses. | |

File: libc.info, Node: Integer Division, Next: Floating Point Numbers, Prev: Integers, Up: Arithmetic | |

20.2 Integer Division | |

===================== | |

This section describes functions for performing integer division. These | |

functions are redundant when GNU CC is used, because in GNU C the '/' | |

operator always rounds towards zero. But in other C implementations, | |

'/' may round differently with negative arguments. 'div' and 'ldiv' are | |

useful because they specify how to round the quotient: towards zero. | |

The remainder has the same sign as the numerator. | |

These functions are specified to return a result R such that the | |

value 'R.quot*DENOMINATOR + R.rem' equals NUMERATOR. | |

To use these facilities, you should include the header file | |

'stdlib.h' in your program. | |

-- Data Type: div_t | |

This is a structure type used to hold the result returned by the | |

'div' function. It has the following members: | |

'int quot' | |

The quotient from the division. | |

'int rem' | |

The remainder from the division. | |

-- Function: div_t div (int NUMERATOR, int DENOMINATOR) | |

Preliminary: | MT-Safe | AS-Safe | AC-Safe | *Note POSIX Safety | |

Concepts::. | |

This function 'div' computes the quotient and remainder from the | |

division of NUMERATOR by DENOMINATOR, returning the result in a | |

structure of type 'div_t'. | |

If the result cannot be represented (as in a division by zero), the | |

behavior is undefined. | |

Here is an example, albeit not a very useful one. | |

div_t result; | |

result = div (20, -6); | |

Now 'result.quot' is '-3' and 'result.rem' is '2'. | |

-- Data Type: ldiv_t | |

This is a structure type used to hold the result returned by the | |

'ldiv' function. It has the following members: | |

'long int quot' | |

The quotient from the division. | |

'long int rem' | |

The remainder from the division. | |

(This is identical to 'div_t' except that the components are of | |

type 'long int' rather than 'int'.) | |

-- Function: ldiv_t ldiv (long int NUMERATOR, long int DENOMINATOR) | |

Preliminary: | MT-Safe | AS-Safe | AC-Safe | *Note POSIX Safety | |

Concepts::. | |

The 'ldiv' function is similar to 'div', except that the arguments | |

are of type 'long int' and the result is returned as a structure of | |

type 'ldiv_t'. | |

-- Data Type: lldiv_t | |

This is a structure type used to hold the result returned by the | |

'lldiv' function. It has the following members: | |

'long long int quot' | |

The quotient from the division. | |

'long long int rem' | |

The remainder from the division. | |

(This is identical to 'div_t' except that the components are of | |

type 'long long int' rather than 'int'.) | |

-- Function: lldiv_t lldiv (long long int NUMERATOR, long long int | |

DENOMINATOR) | |

Preliminary: | MT-Safe | AS-Safe | AC-Safe | *Note POSIX Safety | |

Concepts::. | |

The 'lldiv' function is like the 'div' function, but the arguments | |

are of type 'long long int' and the result is returned as a | |

structure of type 'lldiv_t'. | |

The 'lldiv' function was added in ISO C99. | |

-- Data Type: imaxdiv_t | |

This is a structure type used to hold the result returned by the | |

'imaxdiv' function. It has the following members: | |

'intmax_t quot' | |

The quotient from the division. | |

'intmax_t rem' | |

The remainder from the division. | |

(This is identical to 'div_t' except that the components are of | |

type 'intmax_t' rather than 'int'.) | |

See *note Integers:: for a description of the 'intmax_t' type. | |

-- Function: imaxdiv_t imaxdiv (intmax_t NUMERATOR, intmax_t | |

DENOMINATOR) | |

Preliminary: | MT-Safe | AS-Safe | AC-Safe | *Note POSIX Safety | |

Concepts::. | |

The 'imaxdiv' function is like the 'div' function, but the | |

arguments are of type 'intmax_t' and the result is returned as a | |

structure of type 'imaxdiv_t'. | |

See *note Integers:: for a description of the 'intmax_t' type. | |

The 'imaxdiv' function was added in ISO C99. | |

File: libc.info, Node: Floating Point Numbers, Next: Floating Point Classes, Prev: Integer Division, Up: Arithmetic | |

20.3 Floating Point Numbers | |

=========================== | |

Most computer hardware has support for two different kinds of numbers: | |

integers (...-3, -2, -1, 0, 1, 2, 3...) and floating-point numbers. | |

Floating-point numbers have three parts: the "mantissa", the "exponent", | |

and the "sign bit". The real number represented by a floating-point | |

value is given by (s ? -1 : 1) * 2^e * M where s is the sign bit, e the | |

exponent, and M the mantissa. *Note Floating Point Concepts::, for | |

details. (It is possible to have a different "base" for the exponent, | |

but all modern hardware uses 2.) | |

Floating-point numbers can represent a finite subset of the real | |

numbers. While this subset is large enough for most purposes, it is | |

important to remember that the only reals that can be represented | |

exactly are rational numbers that have a terminating binary expansion | |

shorter than the width of the mantissa. Even simple fractions such as | |

1/5 can only be approximated by floating point. | |

Mathematical operations and functions frequently need to produce | |

values that are not representable. Often these values can be | |

approximated closely enough for practical purposes, but sometimes they | |

can't. Historically there was no way to tell when the results of a | |

calculation were inaccurate. Modern computers implement the IEEE 754 | |

standard for numerical computations, which defines a framework for | |

indicating to the program when the results of calculation are not | |

trustworthy. This framework consists of a set of "exceptions" that | |

indicate why a result could not be represented, and the special values | |

"infinity" and "not a number" (NaN). | |

File: libc.info, Node: Floating Point Classes, Next: Floating Point Errors, Prev: Floating Point Numbers, Up: Arithmetic | |

20.4 Floating-Point Number Classification Functions | |

=================================================== | |

ISO C99 defines macros that let you determine what sort of | |

floating-point number a variable holds. | |

-- Macro: int fpclassify (_float-type_ X) | |

Preliminary: | MT-Safe | AS-Safe | AC-Safe | *Note POSIX Safety | |

Concepts::. | |

This is a generic macro which works on all floating-point types and | |

which returns a value of type 'int'. The possible values are: | |

'FP_NAN' | |

The floating-point number X is "Not a Number" (*note Infinity | |

and NaN::) | |

'FP_INFINITE' | |

The value of X is either plus or minus infinity (*note | |

Infinity and NaN::) | |

'FP_ZERO' | |

The value of X is zero. In floating-point formats like | |

IEEE 754, where zero can be signed, this value is also | |

returned if X is negative zero. | |

'FP_SUBNORMAL' | |

Numbers whose absolute value is too small to be represented in | |

the normal format are represented in an alternate, | |

"denormalized" format (*note Floating Point Concepts::). This | |

format is less precise but can represent values closer to | |

zero. 'fpclassify' returns this value for values of X in this | |

alternate format. | |

'FP_NORMAL' | |

This value is returned for all other values of X. It | |

indicates that there is nothing special about the number. | |

'fpclassify' is most useful if more than one property of a number | |

must be tested. There are more specific macros which only test one | |

property at a time. Generally these macros execute faster than | |

'fpclassify', since there is special hardware support for them. You | |

should therefore use the specific macros whenever possible. | |

-- Macro: int isfinite (_float-type_ X) | |

Preliminary: | MT-Safe | AS-Safe | AC-Safe | *Note POSIX Safety | |

Concepts::. | |

This macro returns a nonzero value if X is finite: not plus or | |

minus infinity, and not NaN. It is equivalent to | |

(fpclassify (x) != FP_NAN && fpclassify (x) != FP_INFINITE) | |

'isfinite' is implemented as a macro which accepts any | |

floating-point type. | |

-- Macro: int isnormal (_float-type_ X) | |

Preliminary: | MT-Safe | AS-Safe | AC-Safe | *Note POSIX Safety | |

Concepts::. | |

This macro returns a nonzero value if X is finite and normalized. | |

It is equivalent to | |

(fpclassify (x) == FP_NORMAL) | |

-- Macro: int isnan (_float-type_ X) | |

Preliminary: | MT-Safe | AS-Safe | AC-Safe | *Note POSIX Safety | |

Concepts::. | |

This macro returns a nonzero value if X is NaN. It is equivalent to | |

(fpclassify (x) == FP_NAN) | |

-- Macro: int issignaling (_float-type_ X) | |

Preliminary: | MT-Safe | AS-Safe | AC-Safe | *Note POSIX Safety | |

Concepts::. | |

This macro returns a nonzero value if X is a signaling NaN (sNaN). | |

It is based on draft TS 18661 and currently enabled as a GNU | |

extension. | |

Another set of floating-point classification functions was provided | |

by BSD. The GNU C Library also supports these functions; however, we | |

recommend that you use the ISO C99 macros in new code. Those are | |

standard and will be available more widely. Also, since they are | |

macros, you do not have to worry about the type of their argument. | |

-- Function: int isinf (double X) | |

-- Function: int isinff (float X) | |

-- Function: int isinfl (long double X) | |

Preliminary: | MT-Safe | AS-Safe | AC-Safe | *Note POSIX Safety | |

Concepts::. | |

This function returns '-1' if X represents negative infinity, '1' | |

if X represents positive infinity, and '0' otherwise. | |

-- Function: int isnan (double X) | |

-- Function: int isnanf (float X) | |

-- Function: int isnanl (long double X) | |

Preliminary: | MT-Safe | AS-Safe | AC-Safe | *Note POSIX Safety | |

Concepts::. | |

This function returns a nonzero value if X is a "not a number" | |

value, and zero otherwise. | |

*NB:* The 'isnan' macro defined by ISO C99 overrides the BSD | |

function. This is normally not a problem, because the two routines | |

behave identically. However, if you really need to get the BSD | |

function for some reason, you can write | |

(isnan) (x) | |

-- Function: int finite (double X) | |

-- Function: int finitef (float X) | |

-- Function: int finitel (long double X) | |

Preliminary: | MT-Safe | AS-Safe | AC-Safe | *Note POSIX Safety | |

Concepts::. | |

This function returns a nonzero value if X is finite or a "not a | |

number" value, and zero otherwise. | |

*Portability Note:* The functions listed in this section are BSD | |

extensions. | |

File: libc.info, Node: Floating Point Errors, Next: Rounding, Prev: Floating Point Classes, Up: Arithmetic | |

20.5 Errors in Floating-Point Calculations | |

========================================== | |

* Menu: | |

* FP Exceptions:: IEEE 754 math exceptions and how to detect them. | |

* Infinity and NaN:: Special values returned by calculations. | |

* Status bit operations:: Checking for exceptions after the fact. | |

* Math Error Reporting:: How the math functions report errors. | |

File: libc.info, Node: FP Exceptions, Next: Infinity and NaN, Up: Floating Point Errors | |

20.5.1 FP Exceptions | |

-------------------- | |

The IEEE 754 standard defines five "exceptions" that can occur during a | |

calculation. Each corresponds to a particular sort of error, such as | |

overflow. | |

When exceptions occur (when exceptions are "raised", in the language | |

of the standard), one of two things can happen. By default the | |

exception is simply noted in the floating-point "status word", and the | |

program continues as if nothing had happened. The operation produces a | |

default value, which depends on the exception (see the table below). | |

Your program can check the status word to find out which exceptions | |

happened. | |

Alternatively, you can enable "traps" for exceptions. In that case, | |

when an exception is raised, your program will receive the 'SIGFPE' | |

signal. The default action for this signal is to terminate the program. | |

*Note Signal Handling::, for how you can change the effect of the | |

signal. | |

In the System V math library, the user-defined function 'matherr' is | |

called when certain exceptions occur inside math library functions. | |

However, the Unix98 standard deprecates this interface. We support it | |

for historical compatibility, but recommend that you do not use it in | |

new programs. When this interface is used, exceptions may not be | |

raised. | |

The exceptions defined in IEEE 754 are: | |

'Invalid Operation' | |

This exception is raised if the given operands are invalid for the | |

operation to be performed. Examples are (see IEEE 754, section 7): | |

1. Addition or subtraction: oo - oo. (But oo + oo = oo). | |

2. Multiplication: 0 * oo. | |

3. Division: 0/0 or oo/oo. | |

4. Remainder: x REM y, where y is zero or x is infinite. | |

5. Square root if the operand is less then zero. More generally, | |

any mathematical function evaluated outside its domain | |

produces this exception. | |

6. Conversion of a floating-point number to an integer or decimal | |

string, when the number cannot be represented in the target | |

format (due to overflow, infinity, or NaN). | |

7. Conversion of an unrecognizable input string. | |

8. Comparison via predicates involving < or >, when one or other | |

of the operands is NaN. You can prevent this exception by | |

using the unordered comparison functions instead; see *note FP | |

Comparison Functions::. | |

If the exception does not trap, the result of the operation is NaN. | |

'Division by Zero' | |

This exception is raised when a finite nonzero number is divided by | |

zero. If no trap occurs the result is either +oo or -oo, depending | |

on the signs of the operands. | |

'Overflow' | |

This exception is raised whenever the result cannot be represented | |

as a finite value in the precision format of the destination. If | |

no trap occurs the result depends on the sign of the intermediate | |

result and the current rounding mode (IEEE 754, section 7.3): | |

1. Round to nearest carries all overflows to oo with the sign of | |

the intermediate result. | |

2. Round toward 0 carries all overflows to the largest | |

representable finite number with the sign of the intermediate | |

result. | |

3. Round toward -oo carries positive overflows to the largest | |

representable finite number and negative overflows to -oo. | |

4. Round toward oo carries negative overflows to the most | |

negative representable finite number and positive overflows to | |

oo. | |

Whenever the overflow exception is raised, the inexact exception is | |

also raised. | |

'Underflow' | |

The underflow exception is raised when an intermediate result is | |

too small to be calculated accurately, or if the operation's result | |

rounded to the destination precision is too small to be normalized. | |

When no trap is installed for the underflow exception, underflow is | |

signaled (via the underflow flag) only when both tininess and loss | |

of accuracy have been detected. If no trap handler is installed | |

the operation continues with an imprecise small value, or zero if | |

the destination precision cannot hold the small exact result. | |

'Inexact' | |

This exception is signalled if a rounded result is not exact (such | |

as when calculating the square root of two) or a result overflows | |

without an overflow trap. | |

File: libc.info, Node: Infinity and NaN, Next: Status bit operations, Prev: FP Exceptions, Up: Floating Point Errors | |

20.5.2 Infinity and NaN | |

----------------------- | |

IEEE 754 floating point numbers can represent positive or negative | |

infinity, and "NaN" (not a number). These three values arise from | |

calculations whose result is undefined or cannot be represented | |

accurately. You can also deliberately set a floating-point variable to | |

any of them, which is sometimes useful. Some examples of calculations | |

that produce infinity or NaN: | |

1/0 = oo | |

log (0) = -oo | |

sqrt (-1) = NaN | |

When a calculation produces any of these values, an exception also | |

occurs; see *note FP Exceptions::. | |

The basic operations and math functions all accept infinity and NaN | |

and produce sensible output. Infinities propagate through calculations | |

as one would expect: for example, 2 + oo = oo, 4/oo = 0, atan (oo) = | |

pi/2. NaN, on the other hand, infects any calculation that involves it. | |

Unless the calculation would produce the same result no matter what real | |

value replaced NaN, the result is NaN. | |

In comparison operations, positive infinity is larger than all values | |

except itself and NaN, and negative infinity is smaller than all values | |

except itself and NaN. NaN is "unordered": it is not equal to, greater | |

than, or less than anything, _including itself_. 'x == x' is false if | |

the value of 'x' is NaN. You can use this to test whether a value is NaN | |

or not, but the recommended way to test for NaN is with the 'isnan' | |

function (*note Floating Point Classes::). In addition, '<', '>', '<=', | |

and '>=' will raise an exception when applied to NaNs. | |

'math.h' defines macros that allow you to explicitly set a variable | |

to infinity or NaN. | |

-- Macro: float INFINITY | |

An expression representing positive infinity. It is equal to the | |

value produced by mathematical operations like '1.0 / 0.0'. | |

'-INFINITY' represents negative infinity. | |

You can test whether a floating-point value is infinite by | |

comparing it to this macro. However, this is not recommended; you | |

should use the 'isfinite' macro instead. *Note Floating Point | |

Classes::. | |

This macro was introduced in the ISO C99 standard. | |

-- Macro: float NAN | |

An expression representing a value which is "not a number". This | |

macro is a GNU extension, available only on machines that support | |

the "not a number" value--that is to say, on all machines that | |

support IEEE floating point. | |

You can use '#ifdef NAN' to test whether the machine supports NaN. | |

(Of course, you must arrange for GNU extensions to be visible, such | |

as by defining '_GNU_SOURCE', and then you must include 'math.h'.) | |

IEEE 754 also allows for another unusual value: negative zero. This | |

value is produced when you divide a positive number by negative | |

infinity, or when a negative result is smaller than the limits of | |

representation. | |

File: libc.info, Node: Status bit operations, Next: Math Error Reporting, Prev: Infinity and NaN, Up: Floating Point Errors | |

20.5.3 Examining the FPU status word | |

------------------------------------ | |

ISO C99 defines functions to query and manipulate the floating-point | |

status word. You can use these functions to check for untrapped | |

exceptions when it's convenient, rather than worrying about them in the | |

middle of a calculation. | |

These constants represent the various IEEE 754 exceptions. Not all | |

FPUs report all the different exceptions. Each constant is defined if | |

and only if the FPU you are compiling for supports that exception, so | |

you can test for FPU support with '#ifdef'. They are defined in | |

'fenv.h'. | |

'FE_INEXACT' | |

The inexact exception. | |

'FE_DIVBYZERO' | |

The divide by zero exception. | |

'FE_UNDERFLOW' | |

The underflow exception. | |

'FE_OVERFLOW' | |

The overflow exception. | |

'FE_INVALID' | |

The invalid exception. | |

The macro 'FE_ALL_EXCEPT' is the bitwise OR of all exception macros | |

which are supported by the FP implementation. | |

These functions allow you to clear exception flags, test for | |

exceptions, and save and restore the set of exceptions flagged. | |

-- Function: int feclearexcept (int EXCEPTS) | |

Preliminary: | MT-Safe | AS-Safe !posix | AC-Safe !posix | *Note | |

POSIX Safety Concepts::. | |

This function clears all of the supported exception flags indicated | |

by EXCEPTS. | |

The function returns zero in case the operation was successful, a | |

non-zero value otherwise. | |

-- Function: int feraiseexcept (int EXCEPTS) | |

Preliminary: | MT-Safe | AS-Safe | AC-Safe | *Note POSIX Safety | |

Concepts::. | |

This function raises the supported exceptions indicated by EXCEPTS. | |

If more than one exception bit in EXCEPTS is set the order in which | |

the exceptions are raised is undefined except that overflow | |

('FE_OVERFLOW') or underflow ('FE_UNDERFLOW') are raised before | |

inexact ('FE_INEXACT'). Whether for overflow or underflow the | |

inexact exception is also raised is also implementation dependent. | |

The function returns zero in case the operation was successful, a | |

non-zero value otherwise. | |

-- Function: int fetestexcept (int EXCEPTS) | |

Preliminary: | MT-Safe | AS-Safe | AC-Safe | *Note POSIX Safety | |

Concepts::. | |

Test whether the exception flags indicated by the parameter EXCEPT | |

are currently set. If any of them are, a nonzero value is returned | |

which specifies which exceptions are set. Otherwise the result is | |

zero. | |

To understand these functions, imagine that the status word is an | |

integer variable named STATUS. 'feclearexcept' is then equivalent to | |

'status &= ~excepts' and 'fetestexcept' is equivalent to '(status & | |

excepts)'. The actual implementation may be very different, of course. | |

Exception flags are only cleared when the program explicitly requests | |

it, by calling 'feclearexcept'. If you want to check for exceptions | |

from a set of calculations, you should clear all the flags first. Here | |

is a simple example of the way to use 'fetestexcept': | |

{ | |

double f; | |

int raised; | |

feclearexcept (FE_ALL_EXCEPT); | |

f = compute (); | |

raised = fetestexcept (FE_OVERFLOW | FE_INVALID); | |

if (raised & FE_OVERFLOW) { /* ... */ } | |

if (raised & FE_INVALID) { /* ... */ } | |

/* ... */ | |

} | |

You cannot explicitly set bits in the status word. You can, however, | |

save the entire status word and restore it later. This is done with the | |

following functions: | |

-- Function: int fegetexceptflag (fexcept_t *FLAGP, int EXCEPTS) | |

Preliminary: | MT-Safe | AS-Safe | AC-Safe | *Note POSIX Safety | |

Concepts::. | |

This function stores in the variable pointed to by FLAGP an | |

implementation-defined value representing the current setting of | |

the exception flags indicated by EXCEPTS. | |

The function returns zero in case the operation was successful, a | |

non-zero value otherwise. | |

-- Function: int fesetexceptflag (const fexcept_t *FLAGP, int EXCEPTS) | |

Preliminary: | MT-Safe | AS-Safe | AC-Safe | *Note POSIX Safety | |

Concepts::. | |

This function restores the flags for the exceptions indicated by | |

EXCEPTS to the values stored in the variable pointed to by FLAGP. | |

The function returns zero in case the operation was successful, a | |

non-zero value otherwise. | |

Note that the value stored in 'fexcept_t' bears no resemblance to the | |

bit mask returned by 'fetestexcept'. The type may not even be an | |

integer. Do not attempt to modify an 'fexcept_t' variable. | |

File: libc.info, Node: Math Error Reporting, Prev: Status bit operations, Up: Floating Point Errors | |

20.5.4 Error Reporting by Mathematical Functions | |

------------------------------------------------ | |

Many of the math functions are defined only over a subset of the real or | |

complex numbers. Even if they are mathematically defined, their result | |

may be larger or smaller than the range representable by their return | |

type without loss of accuracy. These are known as "domain errors", | |

"overflows", and "underflows", respectively. Math functions do several | |

things when one of these errors occurs. In this manual we will refer to | |

the complete response as "signalling" a domain error, overflow, or | |

underflow. | |

When a math function suffers a domain error, it raises the invalid | |

exception and returns NaN. It also sets ERRNO to 'EDOM'; this is for | |

compatibility with old systems that do not support IEEE 754 exception | |

handling. Likewise, when overflow occurs, math functions raise the | |

overflow exception and, in the default rounding mode, return oo or -oo | |

as appropriate (in other rounding modes, the largest finite value of the | |

appropriate sign is returned when appropriate for that rounding mode). | |

They also set ERRNO to 'ERANGE' if returning oo or -oo; ERRNO may or may | |

not be set to 'ERANGE' when a finite value is returned on overflow. | |

When underflow occurs, the underflow exception is raised, and zero | |

(appropriately signed) or a subnormal value, as appropriate for the | |

mathematical result of the function and the rounding mode, is returned. | |

ERRNO may be set to 'ERANGE', but this is not guaranteed; it is intended | |

that the GNU C Library should set it when the underflow is to an | |

appropriately signed zero, but not necessarily for other underflows. | |

Some of the math functions are defined mathematically to result in a | |

complex value over parts of their domains. The most familiar example of | |

this is taking the square root of a negative number. The complex math | |

functions, such as 'csqrt', will return the appropriate complex value in | |

this case. The real-valued functions, such as 'sqrt', will signal a | |

domain error. | |

Some older hardware does not support infinities. On that hardware, | |

overflows instead return a particular very large number (usually the | |

largest representable number). 'math.h' defines macros you can use to | |

test for overflow on both old and new hardware. | |

-- Macro: double HUGE_VAL | |

-- Macro: float HUGE_VALF | |

-- Macro: long double HUGE_VALL | |

An expression representing a particular very large number. On | |

machines that use IEEE 754 floating point format, 'HUGE_VAL' is | |

infinity. On other machines, it's typically the largest positive | |

number that can be represented. | |

Mathematical functions return the appropriately typed version of | |

'HUGE_VAL' or '-HUGE_VAL' when the result is too large to be | |

represented. | |

File: libc.info, Node: Rounding, Next: Control Functions, Prev: Floating Point Errors, Up: Arithmetic | |

20.6 Rounding Modes | |

=================== | |

Floating-point calculations are carried out internally with extra | |

precision, and then rounded to fit into the destination type. This | |

ensures that results are as precise as the input data. IEEE 754 defines | |

four possible rounding modes: | |

Round to nearest. | |

This is the default mode. It should be used unless there is a | |

specific need for one of the others. In this mode results are | |

rounded to the nearest representable value. If the result is | |

midway between two representable values, the even representable is | |

chosen. "Even" here means the lowest-order bit is zero. This | |

rounding mode prevents statistical bias and guarantees numeric | |

stability: round-off errors in a lengthy calculation will remain | |

smaller than half of 'FLT_EPSILON'. | |

Round toward plus Infinity. | |

All results are rounded to the smallest representable value which | |

is greater than the result. | |

Round toward minus Infinity. | |

All results are rounded to the largest representable value which is | |

less than the result. | |

Round toward zero. | |

All results are rounded to the largest representable value whose | |

magnitude is less than that of the result. In other words, if the | |

result is negative it is rounded up; if it is positive, it is | |

rounded down. | |

'fenv.h' defines constants which you can use to refer to the various | |

rounding modes. Each one will be defined if and only if the FPU | |

supports the corresponding rounding mode. | |

'FE_TONEAREST' | |

Round to nearest. | |

'FE_UPWARD' | |

Round toward +oo. | |

'FE_DOWNWARD' | |

Round toward -oo. | |

'FE_TOWARDZERO' | |

Round toward zero. | |

Underflow is an unusual case. Normally, IEEE 754 floating point | |

numbers are always normalized (*note Floating Point Concepts::). | |

Numbers smaller than 2^r (where r is the minimum exponent, | |

'FLT_MIN_RADIX-1' for FLOAT) cannot be represented as normalized | |

numbers. Rounding all such numbers to zero or 2^r would cause some | |

algorithms to fail at 0. Therefore, they are left in denormalized form. | |

That produces loss of precision, since some bits of the mantissa are | |

stolen to indicate the decimal point. | |

If a result is too small to be represented as a denormalized number, | |

it is rounded to zero. However, the sign of the result is preserved; if | |

the calculation was negative, the result is "negative zero". Negative | |

zero can also result from some operations on infinity, such as 4/-oo. | |

At any time one of the above four rounding modes is selected. You | |

can find out which one with this function: | |

-- Function: int fegetround (void) | |

Preliminary: | MT-Safe | AS-Safe | AC-Safe | *Note POSIX Safety | |

Concepts::. | |

Returns the currently selected rounding mode, represented by one of | |

the values of the defined rounding mode macros. | |

To change the rounding mode, use this function: | |

-- Function: int fesetround (int ROUND) | |

Preliminary: | MT-Safe | AS-Safe | AC-Safe | *Note POSIX Safety | |

Concepts::. | |

Changes the currently selected rounding mode to ROUND. If ROUND | |

does not correspond to one of the supported rounding modes nothing | |

is changed. 'fesetround' returns zero if it changed the rounding | |

mode, a nonzero value if the mode is not supported. | |

You should avoid changing the rounding mode if possible. It can be | |

an expensive operation; also, some hardware requires you to compile your | |

program differently for it to work. The resulting code may run slower. | |

See your compiler documentation for details. | |

File: libc.info, Node: Control Functions, Next: Arithmetic Functions, Prev: Rounding, Up: Arithmetic | |

20.7 Floating-Point Control Functions | |

===================================== | |

IEEE 754 floating-point implementations allow the programmer to decide | |

whether traps will occur for each of the exceptions, by setting bits in | |

the "control word". In C, traps result in the program receiving the | |

'SIGFPE' signal; see *note Signal Handling::. | |

*NB:* IEEE 754 says that trap handlers are given details of the | |

exceptional situation, and can set the result value. C signals do not | |

provide any mechanism to pass this information back and forth. Trapping | |

exceptions in C is therefore not very useful. | |

It is sometimes necessary to save the state of the floating-point | |

unit while you perform some calculation. The library provides functions | |

which save and restore the exception flags, the set of exceptions that | |

generate traps, and the rounding mode. This information is known as the | |

"floating-point environment". | |

The functions to save and restore the floating-point environment all | |

use a variable of type 'fenv_t' to store information. This type is | |

defined in 'fenv.h'. Its size and contents are implementation-defined. | |

You should not attempt to manipulate a variable of this type directly. | |

To save the state of the FPU, use one of these functions: | |

-- Function: int fegetenv (fenv_t *ENVP) | |

Preliminary: | MT-Safe | AS-Safe | AC-Safe | *Note POSIX Safety | |

Concepts::. | |

Store the floating-point environment in the variable pointed to by | |

ENVP. | |

The function returns zero in case the operation was successful, a | |

non-zero value otherwise. | |

-- Function: int feholdexcept (fenv_t *ENVP) | |

Preliminary: | MT-Safe | AS-Safe | AC-Safe | *Note POSIX Safety | |

Concepts::. | |

Store the current floating-point environment in the object pointed | |

to by ENVP. Then clear all exception flags, and set the FPU to | |

trap no exceptions. Not all FPUs support trapping no exceptions; | |

if 'feholdexcept' cannot set this mode, it returns nonzero value. | |

If it succeeds, it returns zero. | |

The functions which restore the floating-point environment can take | |

these kinds of arguments: | |

* Pointers to 'fenv_t' objects, which were initialized previously by | |

a call to 'fegetenv' or 'feholdexcept'. | |

* The special macro 'FE_DFL_ENV' which represents the floating-point | |

environment as it was available at program start. | |

* Implementation defined macros with names starting with 'FE_' and | |

having type 'fenv_t *'. | |

If possible, the GNU C Library defines a macro 'FE_NOMASK_ENV' | |

which represents an environment where every exception raised causes | |

a trap to occur. You can test for this macro using '#ifdef'. It | |

is only defined if '_GNU_SOURCE' is defined. | |

Some platforms might define other predefined environments. | |

To set the floating-point environment, you can use either of these | |

functions: | |

-- Function: int fesetenv (const fenv_t *ENVP) | |

Preliminary: | MT-Safe | AS-Safe | AC-Safe | *Note POSIX Safety | |

Concepts::. | |

Set the floating-point environment to that described by ENVP. | |

The function returns zero in case the operation was successful, a | |

non-zero value otherwise. | |

-- Function: int feupdateenv (const fenv_t *ENVP) | |

Preliminary: | MT-Safe | AS-Safe | AC-Safe | *Note POSIX Safety | |

Concepts::. | |

Like 'fesetenv', this function sets the floating-point environment | |

to that described by ENVP. However, if any exceptions were flagged | |

in the status word before 'feupdateenv' was called, they remain | |

flagged after the call. In other words, after 'feupdateenv' is | |

called, the status word is the bitwise OR of the previous status | |

word and the one saved in ENVP. | |

The function returns zero in case the operation was successful, a | |

non-zero value otherwise. | |

To control for individual exceptions if raising them causes a trap to | |

occur, you can use the following two functions. | |

*Portability Note:* These functions are all GNU extensions. | |

-- Function: int feenableexcept (int EXCEPTS) | |

Preliminary: | MT-Safe | AS-Safe | AC-Safe | *Note POSIX Safety | |

Concepts::. | |

This functions enables traps for each of the exceptions as | |

indicated by the parameter EXCEPT. The individual exceptions are | |

described in *note Status bit operations::. Only the specified | |

exceptions are enabled, the status of the other exceptions is not | |

changed. | |

The function returns the previous enabled exceptions in case the | |

operation was successful, '-1' otherwise. | |

-- Function: int fedisableexcept (int EXCEPTS) | |

Preliminary: | MT-Safe | AS-Safe | AC-Safe | *Note POSIX Safety | |

Concepts::. | |

This functions disables traps for each of the exceptions as | |

indicated by the parameter EXCEPT. The individual exceptions are | |

described in *note Status bit operations::. Only the specified | |

exceptions are disabled, the status of the other exceptions is not | |

changed. | |

The function returns the previous enabled exceptions in case the | |

operation was successful, '-1' otherwise. | |

-- Function: int fegetexcept (void) | |

Preliminary: | MT-Safe | AS-Safe | AC-Safe | *Note POSIX Safety | |

Concepts::. | |

The function returns a bitmask of all currently enabled exceptions. | |

It returns '-1' in case of failure. | |

File: libc.info, Node: Arithmetic Functions, Next: Complex Numbers, Prev: Control Functions, Up: Arithmetic | |

20.8 Arithmetic Functions | |

========================= | |

The C library provides functions to do basic operations on | |

floating-point numbers. These include absolute value, maximum and | |

minimum, normalization, bit twiddling, rounding, and a few others. | |

* Menu: | |

* Absolute Value:: Absolute values of integers and floats. | |

* Normalization Functions:: Extracting exponents and putting them back. | |

* Rounding Functions:: Rounding floats to integers. | |

* Remainder Functions:: Remainders on division, precisely defined. | |

* FP Bit Twiddling:: Sign bit adjustment. Adding epsilon. | |

* FP Comparison Functions:: Comparisons without risk of exceptions. | |

* Misc FP Arithmetic:: Max, min, positive difference, multiply-add. | |

File: libc.info, Node: Absolute Value, Next: Normalization Functions, Up: Arithmetic Functions | |

20.8.1 Absolute Value | |

--------------------- | |

These functions are provided for obtaining the "absolute value" (or | |

"magnitude") of a number. The absolute value of a real number X is X if | |

X is positive, -X if X is negative. For a complex number Z, whose real | |

part is X and whose imaginary part is Y, the absolute value is | |

'sqrt (X*X + Y*Y)'. | |

Prototypes for 'abs', 'labs' and 'llabs' are in 'stdlib.h'; 'imaxabs' | |

is declared in 'inttypes.h'; 'fabs', 'fabsf' and 'fabsl' are declared in | |

'math.h'. 'cabs', 'cabsf' and 'cabsl' are declared in 'complex.h'. | |

-- Function: int abs (int NUMBER) | |

-- Function: long int labs (long int NUMBER) | |

-- Function: long long int llabs (long long int NUMBER) | |

-- Function: intmax_t imaxabs (intmax_t NUMBER) | |

Preliminary: | MT-Safe | AS-Safe | AC-Safe | *Note POSIX Safety | |

Concepts::. | |

These functions return the absolute value of NUMBER. | |

Most computers use a two's complement integer representation, in | |

which the absolute value of 'INT_MIN' (the smallest possible 'int') | |

cannot be represented; thus, 'abs (INT_MIN)' is not defined. | |

'llabs' and 'imaxdiv' are new to ISO C99. | |

See *note Integers:: for a description of the 'intmax_t' type. | |

-- Function: double fabs (double NUMBER) | |

-- Function: float fabsf (float NUMBER) | |

-- Function: long double fabsl (long double NUMBER) | |

Preliminary: | MT-Safe | AS-Safe | AC-Safe | *Note POSIX Safety | |

Concepts::. | |

This function returns the absolute value of the floating-point | |

number NUMBER. | |

-- Function: double cabs (complex double Z) | |

-- Function: float cabsf (complex float Z) | |

-- Function: long double cabsl (complex long double Z) | |

Preliminary: | MT-Safe | AS-Safe | AC-Safe | *Note POSIX Safety | |

Concepts::. | |

These functions return the absolute value of the complex number Z | |

(*note Complex Numbers::). The absolute value of a complex number | |

is: | |

sqrt (creal (Z) * creal (Z) + cimag (Z) * cimag (Z)) | |

This function should always be used instead of the direct formula | |

because it takes special care to avoid losing precision. It may | |

also take advantage of hardware support for this operation. See | |

'hypot' in *note Exponents and Logarithms::. | |

File: libc.info, Node: Normalization Functions, Next: Rounding Functions, Prev: Absolute Value, Up: Arithmetic Functions | |

20.8.2 Normalization Functions | |

------------------------------ | |

The functions described in this section are primarily provided as a way | |

to efficiently perform certain low-level manipulations on floating point | |

numbers that are represented internally using a binary radix; see *note | |

Floating Point Concepts::. These functions are required to have | |

equivalent behavior even if the representation does not use a radix of | |

2, but of course they are unlikely to be particularly efficient in those | |

cases. | |

All these functions are declared in 'math.h'. | |

-- Function: double frexp (double VALUE, int *EXPONENT) | |

-- Function: float frexpf (float VALUE, int *EXPONENT) | |

-- Function: long double frexpl (long double VALUE, int *EXPONENT) | |

Preliminary: | MT-Safe | AS-Safe | AC-Safe | *Note POSIX Safety | |

Concepts::. | |

These functions are used to split the number VALUE into a | |

normalized fraction and an exponent. | |

If the argument VALUE is not zero, the return value is VALUE times | |

a power of two, and its magnitude is always in the range 1/2 | |

(inclusive) to 1 (exclusive). The corresponding exponent is stored | |

in '*EXPONENT'; the return value multiplied by 2 raised to this | |

exponent equals the original number VALUE. | |

For example, 'frexp (12.8, &exponent)' returns '0.8' and stores '4' | |

in 'exponent'. | |

If VALUE is zero, then the return value is zero and zero is stored | |

in '*EXPONENT'. | |

-- Function: double ldexp (double VALUE, int EXPONENT) | |

-- Function: float ldexpf (float VALUE, int EXPONENT) | |

-- Function: long double ldexpl (long double VALUE, int EXPONENT) | |

Preliminary: | MT-Safe | AS-Safe | AC-Safe | *Note POSIX Safety | |

Concepts::. | |

These functions return the result of multiplying the floating-point | |

number VALUE by 2 raised to the power EXPONENT. (It can be used to | |

reassemble floating-point numbers that were taken apart by | |

'frexp'.) | |

For example, 'ldexp (0.8, 4)' returns '12.8'. | |

The following functions, which come from BSD, provide facilities | |

equivalent to those of 'ldexp' and 'frexp'. See also the ISO C function | |

'logb' which originally also appeared in BSD. | |

-- Function: double scalb (double VALUE, double EXPONENT) | |

-- Function: float scalbf (float VALUE, float EXPONENT) | |

-- Function: long double scalbl (long double VALUE, long double | |

EXPONENT) | |

Preliminary: | MT-Safe | AS-Safe | AC-Safe | *Note POSIX Safety | |

Concepts::. | |

The 'scalb' function is the BSD name for 'ldexp'. | |

-- Function: double scalbn (double X, int N) | |

-- Function: float scalbnf (float X, int N) | |

-- Function: long double scalbnl (long double X, int N) | |

Preliminary: | MT-Safe | AS-Safe | AC-Safe | *Note POSIX Safety | |

Concepts::. | |

'scalbn' is identical to 'scalb', except that the exponent N is an | |

'int' instead of a floating-point number. | |

-- Function: double scalbln (double X, long int N) | |

-- Function: float scalblnf (float X, long int N) | |

-- Function: long double scalblnl (long double X, long int N) | |

Preliminary: | MT-Safe | AS-Safe | AC-Safe | *Note POSIX Safety | |

Concepts::. | |

'scalbln' is identical to 'scalb', except that the exponent N is a | |

'long int' instead of a floating-point number. | |

-- Function: double significand (double X) | |

-- Function: float significandf (float X) | |

-- Function: long double significandl (long double X) | |

Preliminary: | MT-Safe | AS-Safe | AC-Safe | *Note POSIX Safety | |

Concepts::. | |

'significand' returns the mantissa of X scaled to the range [1, 2). | |

It is equivalent to 'scalb (X, (double) -ilogb (X))'. | |

This function exists mainly for use in certain standardized tests | |

of IEEE 754 conformance. | |

File: libc.info, Node: Rounding Functions, Next: Remainder Functions, Prev: Normalization Functions, Up: Arithmetic Functions | |

20.8.3 Rounding Functions | |

------------------------- | |

The functions listed here perform operations such as rounding and | |

truncation of floating-point values. Some of these functions convert | |

floating point numbers to integer values. They are all declared in | |

'math.h'. | |

You can also convert floating-point numbers to integers simply by | |

casting them to 'int'. This discards the fractional part, effectively | |

rounding towards zero. However, this only works if the result can | |

actually be represented as an 'int'--for very large numbers, this is | |

impossible. The functions listed here return the result as a 'double' | |

instead to get around this problem. | |

-- Function: double ceil (double X) | |

-- Function: float ceilf (float X) | |

-- Function: long double ceill (long double X) | |

Preliminary: | MT-Safe | AS-Safe | AC-Safe | *Note POSIX Safety | |

Concepts::. | |

These functions round X upwards to the nearest integer, returning | |

that value as a 'double'. Thus, 'ceil (1.5)' is '2.0'. | |

-- Function: double floor (double X) | |

-- Function: float floorf (float X) | |

-- Function: long double floorl (long double X) | |

Preliminary: | MT-Safe | AS-Safe | AC-Safe | *Note POSIX Safety | |

Concepts::. | |

These functions round X downwards to the nearest integer, returning | |

that value as a 'double'. Thus, 'floor (1.5)' is '1.0' and 'floor | |

(-1.5)' is '-2.0'. | |

-- Function: double trunc (double X) | |

-- Function: float truncf (float X) | |

-- Function: long double truncl (long double X) | |

Preliminary: | MT-Safe | AS-Safe | AC-Safe | *Note POSIX Safety | |

Concepts::. | |

The 'trunc' functions round X towards zero to the nearest integer | |

(returned in floating-point format). Thus, 'trunc (1.5)' is '1.0' | |

and 'trunc (-1.5)' is '-1.0'. | |

-- Function: double rint (double X) | |

-- Function: float rintf (float X) | |

-- Function: long double rintl (long double X) | |

Preliminary: | MT-Safe | AS-Safe | AC-Safe | *Note POSIX Safety | |

Concepts::. | |

These functions round X to an integer value according to the | |

current rounding mode. *Note Floating Point Parameters::, for | |

information about the various rounding modes. The default rounding | |

mode is to round to the nearest integer; some machines support | |

other modes, but round-to-nearest is always used unless you | |

explicitly select another. | |

If X was not initially an integer, these functions raise the | |

inexact exception. | |

-- Function: double nearbyint (double X) | |

-- Function: float nearbyintf (float X) | |

-- Function: long double nearbyintl (long double X) | |

Preliminary: | MT-Safe | AS-Safe | AC-Safe | *Note POSIX Safety | |

Concepts::. | |

These functions return the same value as the 'rint' functions, but | |

do not raise the inexact exception if X is not an integer. | |

-- Function: double round (double X) | |

-- Function: float roundf (float X) | |

-- Function: long double roundl (long double X) | |

Preliminary: | MT-Safe | AS-Safe | AC-Safe | *Note POSIX Safety | |

Concepts::. | |

These functions are similar to 'rint', but they round halfway cases | |

away from zero instead of to the nearest integer (or other current | |

rounding mode). | |

-- Function: long int lrint (double X) | |

-- Function: long int lrintf (float X) | |

-- Function: long int lrintl (long double X) | |

Preliminary: | MT-Safe | AS-Safe | AC-Safe | *Note POSIX Safety | |

Concepts::. | |

These functions are just like 'rint', but they return a 'long int' | |

instead of a floating-point number. | |

-- Function: long long int llrint (double X) | |

-- Function: long long int llrintf (float X) | |

-- Function: long long int llrintl (long double X) | |

Preliminary: | MT-Safe | AS-Safe | AC-Safe | *Note POSIX Safety | |

Concepts::. | |

These functions are just like 'rint', but they return a 'long long | |

int' instead of a floating-point number. | |

-- Function: long int lround (double X) | |

-- Function: long int lroundf (float X) | |

-- Function: long int lroundl (long double X) | |

Preliminary: | MT-Safe | AS-Safe | AC-Safe | *Note POSIX Safety | |

Concepts::. | |

These functions are just like 'round', but they return a 'long int' | |

instead of a floating-point number. | |

-- Function: long long int llround (double X) | |

-- Function: long long int llroundf (float X) | |

-- Function: long long int llroundl (long double X) | |

Preliminary: | MT-Safe | AS-Safe | AC-Safe | *Note POSIX Safety | |

Concepts::. | |

These functions are just like 'round', but they return a 'long long | |

int' instead of a floating-point number. | |

-- Function: double modf (double VALUE, double *INTEGER-PART) | |

-- Function: float modff (float VALUE, float *INTEGER-PART) | |

-- Function: long double modfl (long double VALUE, long double | |

*INTEGER-PART) | |

Preliminary: | MT-Safe | AS-Safe | AC-Safe | *Note POSIX Safety | |

Concepts::. | |

These functions break the argument VALUE into an integer part and a | |

fractional part (between '-1' and '1', exclusive). Their sum | |

equals VALUE. Each of the parts has the same sign as VALUE, and | |

the integer part is always rounded toward zero. | |

'modf' stores the integer part in '*INTEGER-PART', and returns the | |

fractional part. For example, 'modf (2.5, &intpart)' returns '0.5' | |

and stores '2.0' into 'intpart'. | |

File: libc.info, Node: Remainder Functions, Next: FP Bit Twiddling, Prev: Rounding Functions, Up: Arithmetic Functions | |

20.8.4 Remainder Functions | |

-------------------------- | |

The functions in this section compute the remainder on division of two | |

floating-point numbers. Each is a little different; pick the one that | |

suits your problem. | |

-- Function: double fmod (double NUMERATOR, double DENOMINATOR) | |

-- Function: float fmodf (float NUMERATOR, float DENOMINATOR) | |

-- Function: long double fmodl (long double NUMERATOR, long double | |

DENOMINATOR) | |

Preliminary: | MT-Safe | AS-Safe | AC-Safe | *Note POSIX Safety | |

Concepts::. | |

These functions compute the remainder from the division of | |

NUMERATOR by DENOMINATOR. Specifically, the return value is | |

'NUMERATOR - N * DENOMINATOR', where N is the quotient of NUMERATOR | |

divided by DENOMINATOR, rounded towards zero to an integer. Thus, 'fmod (6.5, 2.3)' | |

returns '1.9', which is '6.5' minus '4.6'. | |

The result has the same sign as the NUMERATOR and has magnitude | |

less than the magnitude of the DENOMINATOR. | |

If DENOMINATOR is zero, 'fmod' signals a domain error. | |

-- Function: double drem (double NUMERATOR, double DENOMINATOR) | |

-- Function: float dremf (float NUMERATOR, float DENOMINATOR) | |

-- Function: long double dreml (long double NUMERATOR, long double | |

DENOMINATOR) | |

Preliminary: | MT-Safe | AS-Safe | AC-Safe | *Note POSIX Safety | |

Concepts::. | |

These functions are like 'fmod' except that they round the internal | |

quotient N to the nearest integer instead of towards zero to an | |

integer. For example, 'drem (6.5, 2.3)' returns '-0.4', which is | |

'6.5' minus '6.9'. | |

The absolute value of the result is less than or equal to half the | |

absolute value of the DENOMINATOR. The difference between 'fmod | |

(NUMERATOR, DENOMINATOR)' and 'drem (NUMERATOR, DENOMINATOR)' is | |

always either DENOMINATOR, minus DENOMINATOR, or zero. | |

If DENOMINATOR is zero, 'drem' signals a domain error. | |

-- Function: double remainder (double NUMERATOR, double DENOMINATOR) | |

-- Function: float remainderf (float NUMERATOR, float DENOMINATOR) | |

-- Function: long double remainderl (long double NUMERATOR, long double | |

DENOMINATOR) | |

Preliminary: | MT-Safe | AS-Safe | AC-Safe | *Note POSIX Safety | |

Concepts::. | |

This function is another name for 'drem'. | |

File: libc.info, Node: FP Bit Twiddling, Next: FP Comparison Functions, Prev: Remainder Functions, Up: Arithmetic Functions | |

20.8.5 Setting and modifying single bits of FP values | |

----------------------------------------------------- | |

There are some operations that are too complicated or expensive to | |

perform by hand on floating-point numbers. ISO C99 defines functions to | |

do these operations, which mostly involve changing single bits. | |

-- Function: double copysign (double X, double Y) | |

-- Function: float copysignf (float X, float Y) | |

-- Function: long double copysignl (long double X, long double Y) | |

Preliminary: | MT-Safe | AS-Safe | AC-Safe | *Note POSIX Safety | |

Concepts::. | |

These functions return X but with the sign of Y. They work even if | |

X or Y are NaN or zero. Both of these can carry a sign (although | |

not all implementations support it) and this is one of the few | |

operations that can tell the difference. | |

'copysign' never raises an exception. | |

This function is defined in IEC 559 (and the appendix with | |

recommended functions in IEEE 754/IEEE 854). | |

-- Function: int signbit (_float-type_ X) | |

Preliminary: | MT-Safe | AS-Safe | AC-Safe | *Note POSIX Safety | |

Concepts::. | |

'signbit' is a generic macro which can work on all floating-point | |

types. It returns a nonzero value if the value of X has its sign | |

bit set. | |

This is not the same as 'x < 0.0', because IEEE 754 floating point | |

allows zero to be signed. The comparison '-0.0 < 0.0' is false, | |

but 'signbit (-0.0)' will return a nonzero value. | |

-- Function: double nextafter (double X, double Y) | |

-- Function: float nextafterf (float X, float Y) | |

-- Function: long double nextafterl (long double X, long double Y) | |

Preliminary: | MT-Safe | AS-Safe | AC-Safe | *Note POSIX Safety | |

Concepts::. | |

The 'nextafter' function returns the next representable neighbor of | |

X in the direction towards Y. The size of the step between X and | |

the result depends on the type of the result. If X = Y the | |

function simply returns Y. If either value is 'NaN', 'NaN' is | |

returned. Otherwise a value corresponding to the value of the | |

least significant bit in the mantissa is added or subtracted, | |

depending on the direction. 'nextafter' will signal overflow or | |

underflow if the result goes outside of the range of normalized | |

numbers. | |

This function is defined in IEC 559 (and the appendix with | |

recommended functions in IEEE 754/IEEE 854). | |

-- Function: double nexttoward (double X, long double Y) | |

-- Function: float nexttowardf (float X, long double Y) | |

-- Function: long double nexttowardl (long double X, long double Y) | |

Preliminary: | MT-Safe | AS-Safe | AC-Safe | *Note POSIX Safety | |

Concepts::. | |

These functions are identical to the corresponding versions of | |

'nextafter' except that their second argument is a 'long double'. | |

-- Function: double nan (const char *TAGP) | |

-- Function: float nanf (const char *TAGP) | |

-- Function: long double nanl (const char *TAGP) | |

Preliminary: | MT-Safe locale | AS-Safe | AC-Safe | *Note POSIX | |

Safety Concepts::. | |

The 'nan' function returns a representation of NaN, provided that | |

NaN is supported by the target platform. 'nan ("N-CHAR-SEQUENCE")' | |

is equivalent to 'strtod ("NAN(N-CHAR-SEQUENCE)")'. | |

The argument TAGP is used in an unspecified manner. On IEEE 754 | |

systems, there are many representations of NaN, and TAGP selects | |

one. On other systems it may do nothing. | |

File: libc.info, Node: FP Comparison Functions, Next: Misc FP Arithmetic, Prev: FP Bit Twiddling, Up: Arithmetic Functions | |

20.8.6 Floating-Point Comparison Functions | |

------------------------------------------ | |

The standard C comparison operators provoke exceptions when one or other | |

of the operands is NaN. For example, | |

int v = a < 1.0; | |

will raise an exception if A is NaN. (This does _not_ happen with '==' | |

and '!='; those merely return false and true, respectively, when NaN is | |

examined.) Frequently this exception is undesirable. ISO C99 therefore | |

defines comparison functions that do not raise exceptions when NaN is | |

examined. All of the functions are implemented as macros which allow | |

their arguments to be of any floating-point type. The macros are | |

guaranteed to evaluate their arguments only once. | |

-- Macro: int isgreater (_real-floating_ X, _real-floating_ Y) | |

Preliminary: | MT-Safe | AS-Safe | AC-Safe | *Note POSIX Safety | |

Concepts::. | |

This macro determines whether the argument X is greater than Y. It | |

is equivalent to '(X) > (Y)', but no exception is raised if X or Y | |

are NaN. | |

-- Macro: int isgreaterequal (_real-floating_ X, _real-floating_ Y) | |

Preliminary: | MT-Safe | AS-Safe | AC-Safe | *Note POSIX Safety | |

Concepts::. | |

This macro determines whether the argument X is greater than or | |

equal to Y. It is equivalent to '(X) >= (Y)', but no exception is | |

raised if X or Y are NaN. | |

-- Macro: int isless (_real-floating_ X, _real-floating_ Y) | |

Preliminary: | MT-Safe | AS-Safe | AC-Safe | *Note POSIX Safety | |

Concepts::. | |

This macro determines whether the argument X is less than Y. It is | |

equivalent to '(X) < (Y)', but no exception is raised if X or Y are | |

NaN. | |

-- Macro: int islessequal (_real-floating_ X, _real-floating_ Y) | |

Preliminary: | MT-Safe | AS-Safe | AC-Safe | *Note POSIX Safety | |

Concepts::. | |

This macro determines whether the argument X is less than or equal | |

to Y. It is equivalent to '(X) <= (Y)', but no exception is raised | |

if X or Y are NaN. | |

-- Macro: int islessgreater (_real-floating_ X, _real-floating_ Y) | |

Preliminary: | MT-Safe | AS-Safe | AC-Safe | *Note POSIX Safety | |

Concepts::. | |

This macro determines whether the argument X is less or greater | |

than Y. It is equivalent to '(X) < (Y) || (X) > (Y)' (although it | |

only evaluates X and Y once), but no exception is raised if X or Y | |

are NaN. | |

This macro is not equivalent to 'X != Y', because that expression | |

is true if X or Y are NaN. | |

-- Macro: int isunordered (_real-floating_ X, _real-floating_ Y) | |

Preliminary: | MT-Safe | AS-Safe | AC-Safe | *Note POSIX Safety | |

Concepts::. | |

This macro determines whether its arguments are unordered. In | |

other words, it is true if X or Y are NaN, and false otherwise. | |

Not all machines provide hardware support for these operations. On | |

machines that don't, the macros can be very slow. Therefore, you should | |

not use these functions when NaN is not a concern. | |

*NB:* There are no macros 'isequal' or 'isunequal'. They are | |

unnecessary, because the '==' and '!=' operators do _not_ throw an | |

exception if one or both of the operands are NaN. | |

File: libc.info, Node: Misc FP Arithmetic, Prev: FP Comparison Functions, Up: Arithmetic Functions | |

20.8.7 Miscellaneous FP arithmetic functions | |

-------------------------------------------- | |

The functions in this section perform miscellaneous but common | |

operations that are awkward to express with C operators. On some | |

processors these functions can use special machine instructions to | |

perform these operations faster than the equivalent C code. | |

-- Function: double fmin (double X, double Y) | |

-- Function: float fminf (float X, float Y) | |

-- Function: long double fminl (long double X, long double Y) | |

Preliminary: | MT-Safe | AS-Safe | AC-Safe | *Note POSIX Safety | |

Concepts::. | |

The 'fmin' function returns the lesser of the two values X and Y. | |

It is similar to the expression | |

((x) < (y) ? (x) : (y)) | |

except that X and Y are only evaluated once. | |

If an argument is NaN, the other argument is returned. If both | |

arguments are NaN, NaN is returned. | |

-- Function: double fmax (double X, double Y) | |

-- Function: float fmaxf (float X, float Y) | |

-- Function: long double fmaxl (long double X, long double Y) | |

Preliminary: | MT-Safe | AS-Safe | AC-Safe | *Note POSIX Safety | |

Concepts::. | |

The 'fmax' function returns the greater of the two values X and Y. | |

If an argument is NaN, the other argument is returned. If both | |

arguments are NaN, NaN is returned. | |

-- Function: double fdim (double X, double Y) | |

-- Function: float fdimf (float X, float Y) | |

-- Function: long double fdiml (long double X, long double Y) | |

Preliminary: | MT-Safe | AS-Safe | AC-Safe | *Note POSIX Safety | |

Concepts::. | |

The 'fdim' function returns the positive difference between X and | |

Y. The positive difference is X - Y if X is greater than Y, and 0 | |

otherwise. | |

If X, Y, or both are NaN, NaN is returned. | |

-- Function: double fma (double X, double Y, double Z) | |

-- Function: float fmaf (float X, float Y, float Z) | |

-- Function: long double fmal (long double X, long double Y, long | |

double Z) | |

Preliminary: | MT-Safe | AS-Safe | AC-Safe | *Note POSIX Safety | |

Concepts::. | |

The 'fma' function performs floating-point multiply-add. This is | |

the operation (X * Y) + Z, but the intermediate result is not | |

rounded to the destination type. This can sometimes improve the | |

precision of a calculation. | |

This function was introduced because some processors have a special | |

instruction to perform multiply-add. The C compiler cannot use it | |

directly, because the expression 'x*y + z' is defined to round the | |

intermediate result. 'fma' lets you choose when you want to round | |

only once. | |

On processors which do not implement multiply-add in hardware, | |

'fma' can be very slow since it must avoid intermediate rounding. | |

'math.h' defines the symbols 'FP_FAST_FMA', 'FP_FAST_FMAF', and | |

'FP_FAST_FMAL' when the corresponding version of 'fma' is no slower | |

than the expression 'x*y + z'. In the GNU C Library, this always | |

means the operation is implemented in hardware. | |

File: libc.info, Node: Complex Numbers, Next: Operations on Complex, Prev: Arithmetic Functions, Up: Arithmetic | |

20.9 Complex Numbers | |

==================== | |

ISO C99 introduces support for complex numbers in C. This is done with a | |

new type qualifier, 'complex'. It is a keyword if and only if | |

'complex.h' has been included. There are three complex types, | |

corresponding to the three real types: 'float complex', 'double | |

complex', and 'long double complex'. | |

To construct complex numbers you need a way to indicate the imaginary | |

part of a number. There is no standard notation for an imaginary | |

floating point constant. Instead, 'complex.h' defines two macros that | |

can be used to create complex numbers. | |

-- Macro: const float complex _Complex_I | |

This macro is a representation of the complex number "0+1i". | |

Multiplying a real floating-point value by '_Complex_I' gives a | |

complex number whose value is purely imaginary. You can use this | |

to construct complex constants: | |

3.0 + 4.0i = 3.0 + 4.0 * _Complex_I | |

Note that '_Complex_I * _Complex_I' has the value '-1', but the | |

type of that value is 'complex'. | |

'_Complex_I' is a bit of a mouthful. 'complex.h' also defines a shorter | |

name for the same constant. | |

-- Macro: const float complex I | |

This macro has exactly the same value as '_Complex_I'. Most of the | |

time it is preferable. However, it causes problems if you want to | |

use the identifier 'I' for something else. You can safely write | |

#include <complex.h> | |

#undef I | |

if you need 'I' for your own purposes. (In that case we recommend | |

you also define some other short name for '_Complex_I', such as | |

'J'.) | |

File: libc.info, Node: Operations on Complex, Next: Parsing of Numbers, Prev: Complex Numbers, Up: Arithmetic | |

20.10 Projections, Conjugates, and Decomposing of Complex Numbers | |

================================================================= | |

ISO C99 also defines functions that perform basic operations on complex | |

numbers, such as decomposition and conjugation. The prototypes for all | |

these functions are in 'complex.h'. All functions are available in | |

three variants, one for each of the three complex types. | |

-- Function: double creal (complex double Z) | |

-- Function: float crealf (complex float Z) | |

-- Function: long double creall (complex long double Z) | |

Preliminary: | MT-Safe | AS-Safe | AC-Safe | *Note POSIX Safety | |

Concepts::. | |

These functions return the real part of the complex number Z. | |

-- Function: double cimag (complex double Z) | |

-- Function: float cimagf (complex float Z) | |

-- Function: long double cimagl (complex long double Z) | |

Preliminary: | MT-Safe | AS-Safe | AC-Safe | *Note POSIX Safety | |

Concepts::. | |

These functions return the imaginary part of the complex number Z. | |

-- Function: complex double conj (complex double Z) | |

-- Function: complex float conjf (complex float Z) | |

-- Function: complex long double conjl (complex long double Z) | |

Preliminary: | MT-Safe | AS-Safe | AC-Safe | *Note POSIX Safety | |

Concepts::. | |

These functions return the conjugate value of the complex number Z. | |

The conjugate of a complex number has the same real part and a | |

negated imaginary part. In other words, 'conj(a + bi) = a + -bi'. | |

-- Function: double carg (complex double Z) | |

-- Function: float cargf (complex float Z) | |

-- Function: long double cargl (complex long double Z) | |

Preliminary: | MT-Safe | AS-Safe | AC-Safe | *Note POSIX Safety | |

Concepts::. | |

These functions return the argument of the complex number Z. The | |

argument of a complex number is the angle in the complex plane | |

between the positive real axis and a line passing through zero and | |

the number. This angle is measured in the usual fashion and ranges | |

from -pi to pi. | |

'carg' has a branch cut along the negative real axis. | |

-- Function: complex double cproj (complex double Z) | |

-- Function: complex float cprojf (complex float Z) | |

-- Function: complex long double cprojl (complex long double Z) | |

Preliminary: | MT-Safe | AS-Safe | AC-Safe | *Note POSIX Safety | |

Concepts::. | |

These functions return the projection of the complex value Z onto | |

the Riemann sphere. Values with an infinite imaginary part are | |

projected to positive infinity on the real axis, even if the real | |

part is NaN. If the real part is infinite, the result is equivalent | |

to | |

INFINITY + I * copysign (0.0, cimag (z)) | |

File: libc.info, Node: Parsing of Numbers, Next: System V Number Conversion, Prev: Operations on Complex, Up: Arithmetic | |

20.11 Parsing of Numbers | |

======================== | |

This section describes functions for "reading" integer and | |

floating-point numbers from a string. It may be more convenient in some | |

cases to use 'sscanf' or one of the related functions; see *note | |

Formatted Input::. But often you can make a program more robust by | |

finding the tokens in the string by hand, then converting the numbers | |

one by one. | |

* Menu: | |

* Parsing of Integers:: Functions for conversion of integer values. | |

* Parsing of Floats:: Functions for conversion of floating-point | |

values. | |

File: libc.info, Node: Parsing of Integers, Next: Parsing of Floats, Up: Parsing of Numbers | |

20.11.1 Parsing of Integers | |

--------------------------- | |

The 'str' functions are declared in 'stdlib.h' and those beginning with | |

'wcs' are declared in 'wchar.h'. One might wonder about the use of | |

'restrict' in the prototypes of the functions in this section. It is | |

seemingly useless but the ISO C standard uses it (for the functions | |

defined there) so we have to do it as well. | |

-- Function: long int strtol (const char *restrict STRING, char | |

**restrict TAILPTR, int BASE) | |

Preliminary: | MT-Safe locale | AS-Safe | AC-Safe | *Note POSIX | |

Safety Concepts::. | |

The 'strtol' ("string-to-long") function converts the initial part | |

of STRING to a signed integer, which is returned as a value of type | |

'long int'. | |

This function attempts to decompose STRING as follows: | |

* A (possibly empty) sequence of whitespace characters. Which | |

characters are whitespace is determined by the 'isspace' | |

function (*note Classification of Characters::). These are | |

discarded. | |

* An optional plus or minus sign ('+' or '-'). | |

* A nonempty sequence of digits in the radix specified by BASE. | |

If BASE is zero, decimal radix is assumed unless the series of | |

digits begins with '0' (specifying octal radix), or '0x' or | |

'0X' (specifying hexadecimal radix); in other words, the same | |

syntax used for integer constants in C. | |

Otherwise BASE must have a value between '2' and '36'. If | |

BASE is '16', the digits may optionally be preceded by '0x' or | |

'0X'. If base has no legal value the value returned is '0l' | |

and the global variable 'errno' is set to 'EINVAL'. | |

* Any remaining characters in the string. If TAILPTR is not a | |

null pointer, 'strtol' stores a pointer to this tail in | |

'*TAILPTR'. | |

If the string is empty, contains only whitespace, or does not | |

contain an initial substring that has the expected syntax for an | |

integer in the specified BASE, no conversion is performed. In this | |

case, 'strtol' returns a value of zero and the value stored in | |

'*TAILPTR' is the value of STRING. | |

In a locale other than the standard '"C"' locale, this function may | |

recognize additional implementation-dependent syntax. | |

If the string has valid syntax for an integer but the value is not | |

representable because of overflow, 'strtol' returns either | |

'LONG_MAX' or 'LONG_MIN' (*note Range of Type::), as appropriate | |

for the sign of the value. It also sets 'errno' to 'ERANGE' to | |

indicate there was overflow. | |

You should not check for errors by examining the return value of | |

'strtol', because the string might be a valid representation of | |

'0l', 'LONG_MAX', or 'LONG_MIN'. Instead, check whether TAILPTR | |

points to what you expect after the number (e.g. ''\0'' if the | |

string should end after the number). You also need to clear ERRNO | |

before the call and check it afterward, in case there was overflow. | |

There is an example at the end of this section. | |

-- Function: long int wcstol (const wchar_t *restrict STRING, wchar_t | |

**restrict TAILPTR, int BASE) | |

Preliminary: | MT-Safe locale | AS-Safe | AC-Safe | *Note POSIX | |

Safety Concepts::. | |

The 'wcstol' function is equivalent to the 'strtol' function in | |

nearly all aspects but handles wide character strings. | |

The 'wcstol' function was introduced in Amendment 1 of ISO C90. | |

-- Function: unsigned long int strtoul (const char *retrict STRING, | |

char **restrict TAILPTR, int BASE) | |

Preliminary: | MT-Safe locale | AS-Safe | AC-Safe | *Note POSIX | |

Safety Concepts::. | |

The 'strtoul' ("string-to-unsigned-long") function is like 'strtol' | |

except it converts to an 'unsigned long int' value. The syntax is | |

the same as described above for 'strtol'. The value returned on | |

overflow is 'ULONG_MAX' (*note Range of Type::). | |

If STRING depicts a negative number, 'strtoul' acts the same as | |

STRTOL but casts the result to an unsigned integer. That means for | |

example that 'strtoul' on '"-1"' returns 'ULONG_MAX' and an input | |

more negative than 'LONG_MIN' returns ('ULONG_MAX' + 1) / 2. | |

'strtoul' sets ERRNO to 'EINVAL' if BASE is out of range, or | |

'ERANGE' on overflow. | |

-- Function: unsigned long int wcstoul (const wchar_t *restrict STRING, | |

wchar_t **restrict TAILPTR, int BASE) | |

Preliminary: | MT-Safe locale | AS-Safe | AC-Safe | *Note POSIX | |

Safety Concepts::. | |

The 'wcstoul' function is equivalent to the 'strtoul' function in | |

nearly all aspects but handles wide character strings. | |

The 'wcstoul' function was introduced in Amendment 1 of ISO C90. | |

-- Function: long long int strtoll (const char *restrict STRING, char | |

**restrict TAILPTR, int BASE) | |

Preliminary: | MT-Safe locale | AS-Safe | AC-Safe | *Note POSIX | |

Safety Concepts::. | |

The 'strtoll' function is like 'strtol' except that it returns a | |

'long long int' value, and accepts numbers with a correspondingly | |

larger range. | |

If the string has valid syntax for an integer but the value is not | |

representable because of overflow, 'strtoll' returns either | |

'LLONG_MAX' or 'LLONG_MIN' (*note Range of Type::), as appropriate | |

for the sign of the value. It also sets 'errno' to 'ERANGE' to | |

indicate there was overflow. | |

The 'strtoll' function was introduced in ISO C99. | |

-- Function: long long int wcstoll (const wchar_t *restrict STRING, | |

wchar_t **restrict TAILPTR, int BASE) | |

Preliminary: | MT-Safe locale | AS-Safe | AC-Safe | *Note POSIX | |

Safety Concepts::. | |

The 'wcstoll' function is equivalent to the 'strtoll' function in | |

nearly all aspects but handles wide character strings. | |

The 'wcstoll' function was introduced in Amendment 1 of ISO C90. | |

-- Function: long long int strtoq (const char *restrict STRING, char | |

**restrict TAILPTR, int BASE) | |

Preliminary: | MT-Safe locale | AS-Safe | AC-Safe | *Note POSIX | |

Safety Concepts::. | |

'strtoq' ("string-to-quad-word") is the BSD name for 'strtoll'. | |

-- Function: long long int wcstoq (const wchar_t *restrict STRING, | |

wchar_t **restrict TAILPTR, int BASE) | |

Preliminary: | MT-Safe locale | AS-Safe | AC-Safe | *Note POSIX | |

Safety Concepts::. | |

The 'wcstoq' function is equivalent to the 'strtoq' function in | |

nearly all aspects but handles wide character strings. | |

The 'wcstoq' function is a GNU extension. | |

-- Function: unsigned long long int strtoull (const char *restrict | |

STRING, char **restrict TAILPTR, int BASE) | |

Preliminary: | MT-Safe locale | AS-Safe | AC-Safe | *Note POSIX | |

Safety Concepts::. | |

The 'strtoull' function is related to 'strtoll' the same way | |

'strtoul' is related to 'strtol'. | |

The 'strtoull' function was introduced in ISO C99. | |

-- Function: unsigned long long int wcstoull (const wchar_t *restrict | |

STRING, wchar_t **restrict TAILPTR, int BASE) | |

Preliminary: | MT-Safe locale | AS-Safe | AC-Safe | *Note POSIX | |

Safety Concepts::. | |

The 'wcstoull' function is equivalent to the 'strtoull' function in | |

nearly all aspects but handles wide character strings. | |

The 'wcstoull' function was introduced in Amendment 1 of ISO C90. | |

-- Function: unsigned long long int strtouq (const char *restrict | |

STRING, char **restrict TAILPTR, int BASE) | |

Preliminary: | MT-Safe locale | AS-Safe | AC-Safe | *Note POSIX | |

Safety Concepts::. | |

'strtouq' is the BSD name for 'strtoull'. | |

-- Function: unsigned long long int wcstouq (const wchar_t *restrict | |

STRING, wchar_t **restrict TAILPTR, int BASE) | |

Preliminary: | MT-Safe locale | AS-Safe | AC-Safe | *Note POSIX | |

Safety Concepts::. | |

The 'wcstouq' function is equivalent to the 'strtouq' function in | |

nearly all aspects but handles wide character strings. | |

The 'wcstouq' function is a GNU extension. | |

-- Function: intmax_t strtoimax (const char *restrict STRING, char | |

**restrict TAILPTR, int BASE) | |

Preliminary: | MT-Safe locale | AS-Safe | AC-Safe | *Note POSIX | |

Safety Concepts::. | |

The 'strtoimax' function is like 'strtol' except that it returns a | |

'intmax_t' value, and accepts numbers of a corresponding range. | |

If the string has valid syntax for an integer but the value is not | |

representable because of overflow, 'strtoimax' returns either | |

'INTMAX_MAX' or 'INTMAX_MIN' (*note Integers::), as appropriate for | |

the sign of the value. It also sets 'errno' to 'ERANGE' to | |

indicate there was overflow. | |

See *note Integers:: for a description of the 'intmax_t' type. The | |

'strtoimax' function was introduced in ISO C99. | |

-- Function: intmax_t wcstoimax (const wchar_t *restrict STRING, | |

wchar_t **restrict TAILPTR, int BASE) | |

Preliminary: | MT-Safe locale | AS-Safe | AC-Safe | *Note POSIX | |

Safety Concepts::. | |

The 'wcstoimax' function is equivalent to the 'strtoimax' function | |

in nearly all aspects but handles wide character strings. | |

The 'wcstoimax' function was introduced in ISO C99. | |

-- Function: uintmax_t strtoumax (const char *restrict STRING, char | |

**restrict TAILPTR, int BASE) | |

Preliminary: | MT-Safe locale | AS-Safe | AC-Safe | *Note POSIX | |

Safety Concepts::. | |

The 'strtoumax' function is related to 'strtoimax' the same way | |

that 'strtoul' is related to 'strtol'. | |

See *note Integers:: for a description of the 'intmax_t' type. The | |

'strtoumax' function was introduced in ISO C99. | |

-- Function: uintmax_t wcstoumax (const wchar_t *restrict STRING, | |

wchar_t **restrict TAILPTR, int BASE) | |

Preliminary: | MT-Safe locale | AS-Safe | AC-Safe | *Note POSIX | |

Safety Concepts::. | |

The 'wcstoumax' funct |