| 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' function is equivalent to the 'strtoumax' function |
| in nearly all aspects but handles wide character strings. |
| |
| The 'wcstoumax' function was introduced in ISO C99. |
| |
| -- Function: long int atol (const char *STRING) |
| Preliminary: | MT-Safe locale | AS-Safe | AC-Safe | *Note POSIX |
| Safety Concepts::. |
| |
| This function is similar to the 'strtol' function with a BASE |
| argument of '10', except that it need not detect overflow errors. |
| The 'atol' function is provided mostly for compatibility with |
| existing code; using 'strtol' is more robust. |
| |
| -- Function: int atoi (const char *STRING) |
| Preliminary: | MT-Safe locale | AS-Safe | AC-Safe | *Note POSIX |
| Safety Concepts::. |
| |
| This function is like 'atol', except that it returns an 'int'. The |
| 'atoi' function is also considered obsolete; use 'strtol' instead. |
| |
| -- Function: long long int atoll (const char *STRING) |
| Preliminary: | MT-Safe locale | AS-Safe | AC-Safe | *Note POSIX |
| Safety Concepts::. |
| |
| This function is similar to 'atol', except it returns a 'long long |
| int'. |
| |
| The 'atoll' function was introduced in ISO C99. It too is obsolete |
| (despite having just been added); use 'strtoll' instead. |
| |
| All the functions mentioned in this section so far do not handle |
| alternative representations of characters as described in the locale |
| data. Some locales specify thousands separator and the way they have to |
| be used which can help to make large numbers more readable. To read |
| such numbers one has to use the 'scanf' functions with the ''' flag. |
| |
| Here is a function which parses a string as a sequence of integers |
| and returns the sum of them: |
| |
| int |
| sum_ints_from_string (char *string) |
| { |
| int sum = 0; |
| |
| while (1) { |
| char *tail; |
| int next; |
| |
| /* Skip whitespace by hand, to detect the end. */ |
| while (isspace (*string)) string++; |
| if (*string == 0) |
| break; |
| |
| /* There is more nonwhitespace, */ |
| /* so it ought to be another number. */ |
| errno = 0; |
| /* Parse it. */ |
| next = strtol (string, &tail, 0); |
| /* Add it in, if not overflow. */ |
| if (errno) |
| printf ("Overflow\n"); |
| else |
| sum += next; |
| /* Advance past it. */ |
| string = tail; |
| } |
| |
| return sum; |
| } |
| |
| |
| File: libc.info, Node: Parsing of Floats, Prev: Parsing of Integers, Up: Parsing of Numbers |
| |
| 20.11.2 Parsing of Floats |
| ------------------------- |
| |
| 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: double strtod (const char *restrict STRING, char |
| **restrict TAILPTR) |
| Preliminary: | MT-Safe locale | AS-Safe | AC-Safe | *Note POSIX |
| Safety Concepts::. |
| |
| The 'strtod' ("string-to-double") function converts the initial |
| part of STRING to a floating-point number, which is returned as a |
| value of type 'double'. |
| |
| 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 floating point number in decimal or hexadecimal format. The |
| decimal format is: |
| |
| - A nonempty sequence of digits optionally containing a |
| decimal-point character--normally '.', but it depends on |
| the locale (*note General Numeric::). |
| |
| - An optional exponent part, consisting of a character 'e' |
| or 'E', an optional sign, and a sequence of digits. |
| |
| The hexadecimal format is as follows: |
| |
| - A 0x or 0X followed by a nonempty sequence of hexadecimal |
| digits optionally containing a decimal-point |
| character--normally '.', but it depends on the locale |
| (*note General Numeric::). |
| |
| - An optional binary-exponent part, consisting of a |
| character 'p' or 'P', an optional sign, and a sequence of |
| digits. |
| |
| * Any remaining characters in the string. If TAILPTR is not a |
| null pointer, a pointer to this tail of the string is stored |
| in '*TAILPTR'. |
| |
| If the string is empty, contains only whitespace, or does not |
| contain an initial substring that has the expected syntax for a |
| floating-point number, no conversion is performed. In this case, |
| 'strtod' returns a value of zero and the value returned in |
| '*TAILPTR' is the value of STRING. |
| |
| In a locale other than the standard '"C"' or '"POSIX"' locales, |
| this function may recognize additional locale-dependent syntax. |
| |
| If the string has valid syntax for a floating-point number but the |
| value is outside the range of a 'double', 'strtod' will signal |
| overflow or underflow as described in *note Math Error Reporting::. |
| |
| 'strtod' recognizes four special input strings. The strings |
| '"inf"' and '"infinity"' are converted to oo, or to the largest |
| representable value if the floating-point format doesn't support |
| infinities. You can prepend a '"+"' or '"-"' to specify the sign. |
| Case is ignored when scanning these strings. |
| |
| The strings '"nan"' and '"nan(CHARS...)"' are converted to NaN. |
| Again, case is ignored. If CHARS... are provided, they are used in |
| some unspecified fashion to select a particular representation of |
| NaN (there can be several). |
| |
| Since zero is a valid result as well as the value returned on |
| error, you should check for errors in the same way as for 'strtol', |
| by examining ERRNO and TAILPTR. |
| |
| -- Function: float strtof (const char *STRING, char **TAILPTR) |
| -- Function: long double strtold (const char *STRING, char **TAILPTR) |
| Preliminary: | MT-Safe locale | AS-Safe | AC-Safe | *Note POSIX |
| Safety Concepts::. |
| |
| These functions are analogous to 'strtod', but return 'float' and |
| 'long double' values respectively. They report errors in the same |
| way as 'strtod'. 'strtof' can be substantially faster than |
| 'strtod', but has less precision; conversely, 'strtold' can be much |
| slower but has more precision (on systems where 'long double' is a |
| separate type). |
| |
| These functions have been GNU extensions and are new to ISO C99. |
| |
| -- Function: double wcstod (const wchar_t *restrict STRING, wchar_t |
| **restrict TAILPTR) |
| -- Function: float wcstof (const wchar_t *STRING, wchar_t **TAILPTR) |
| -- Function: long double wcstold (const wchar_t *STRING, wchar_t |
| **TAILPTR) |
| Preliminary: | MT-Safe locale | AS-Safe | AC-Safe | *Note POSIX |
| Safety Concepts::. |
| |
| The 'wcstod', 'wcstof', and 'wcstol' functions are equivalent in |
| nearly all aspect to the 'strtod', 'strtof', and 'strtold' |
| functions but it handles wide character string. |
| |
| The 'wcstod' function was introduced in Amendment 1 of ISO C90. |
| The 'wcstof' and 'wcstold' functions were introduced in ISO C99. |
| |
| -- Function: double atof (const char *STRING) |
| Preliminary: | MT-Safe locale | AS-Safe | AC-Safe | *Note POSIX |
| Safety Concepts::. |
| |
| This function is similar to the 'strtod' function, except that it |
| need not detect overflow and underflow errors. The 'atof' function |
| is provided mostly for compatibility with existing code; using |
| 'strtod' is more robust. |
| |
| The GNU C Library also provides '_l' versions of these functions, |
| which take an additional argument, the locale to use in conversion. |
| |
| See also *note Parsing of Integers::. |
| |
| |
| File: libc.info, Node: System V Number Conversion, Prev: Parsing of Numbers, Up: Arithmetic |
| |
| 20.12 Old-fashioned System V number-to-string functions |
| ======================================================= |
| |
| The old System V C library provided three functions to convert numbers |
| to strings, with unusual and hard-to-use semantics. The GNU C Library |
| also provides these functions and some natural extensions. |
| |
| These functions are only available in the GNU C Library and on |
| systems descended from AT&T Unix. Therefore, unless these functions do |
| precisely what you need, it is better to use 'sprintf', which is |
| standard. |
| |
| All these functions are defined in 'stdlib.h'. |
| |
| -- Function: char * ecvt (double VALUE, int NDIGIT, int *DECPT, int |
| *NEG) |
| Preliminary: | MT-Unsafe race:ecvt | AS-Unsafe | AC-Safe | *Note |
| POSIX Safety Concepts::. |
| |
| The function 'ecvt' converts the floating-point number VALUE to a |
| string with at most NDIGIT decimal digits. The returned string |
| contains no decimal point or sign. The first digit of the string |
| is non-zero (unless VALUE is actually zero) and the last digit is |
| rounded to nearest. '*DECPT' is set to the index in the string of |
| the first digit after the decimal point. '*NEG' is set to a |
| nonzero value if VALUE is negative, zero otherwise. |
| |
| If NDIGIT decimal digits would exceed the precision of a 'double' |
| it is reduced to a system-specific value. |
| |
| The returned string is statically allocated and overwritten by each |
| call to 'ecvt'. |
| |
| If VALUE is zero, it is implementation defined whether '*DECPT' is |
| '0' or '1'. |
| |
| For example: 'ecvt (12.3, 5, &d, &n)' returns '"12300"' and sets D |
| to '2' and N to '0'. |
| |
| -- Function: char * fcvt (double VALUE, int NDIGIT, int *DECPT, int |
| *NEG) |
| Preliminary: | MT-Unsafe race:fcvt | AS-Unsafe heap | AC-Unsafe mem |
| | *Note POSIX Safety Concepts::. |
| |
| The function 'fcvt' is like 'ecvt', but NDIGIT specifies the number |
| of digits after the decimal point. If NDIGIT is less than zero, |
| VALUE is rounded to the NDIGIT+1'th place to the left of the |
| decimal point. For example, if NDIGIT is '-1', VALUE will be |
| rounded to the nearest 10. If NDIGIT is negative and larger than |
| the number of digits to the left of the decimal point in VALUE, |
| VALUE will be rounded to one significant digit. |
| |
| If NDIGIT decimal digits would exceed the precision of a 'double' |
| it is reduced to a system-specific value. |
| |
| The returned string is statically allocated and overwritten by each |
| call to 'fcvt'. |
| |
| -- Function: char * gcvt (double VALUE, int NDIGIT, char *BUF) |
| Preliminary: | MT-Safe | AS-Safe | AC-Safe | *Note POSIX Safety |
| Concepts::. |
| |
| 'gcvt' is functionally equivalent to 'sprintf(buf, "%*g", ndigit, |
| value'. It is provided only for compatibility's sake. It returns |
| BUF. |
| |
| If NDIGIT decimal digits would exceed the precision of a 'double' |
| it is reduced to a system-specific value. |
| |
| As extensions, the GNU C Library provides versions of these three |
| functions that take 'long double' arguments. |
| |
| -- Function: char * qecvt (long double VALUE, int NDIGIT, int *DECPT, |
| int *NEG) |
| Preliminary: | MT-Unsafe race:qecvt | AS-Unsafe | AC-Safe | *Note |
| POSIX Safety Concepts::. |
| |
| This function is equivalent to 'ecvt' except that it takes a 'long |
| double' for the first parameter and that NDIGIT is restricted by |
| the precision of a 'long double'. |
| |
| -- Function: char * qfcvt (long double VALUE, int NDIGIT, int *DECPT, |
| int *NEG) |
| Preliminary: | MT-Unsafe race:qfcvt | AS-Unsafe heap | AC-Unsafe |
| mem | *Note POSIX Safety Concepts::. |
| |
| This function is equivalent to 'fcvt' except that it takes a 'long |
| double' for the first parameter and that NDIGIT is restricted by |
| the precision of a 'long double'. |
| |
| -- Function: char * qgcvt (long double VALUE, int NDIGIT, char *BUF) |
| Preliminary: | MT-Safe | AS-Safe | AC-Safe | *Note POSIX Safety |
| Concepts::. |
| |
| This function is equivalent to 'gcvt' except that it takes a 'long |
| double' for the first parameter and that NDIGIT is restricted by |
| the precision of a 'long double'. |
| |
| The 'ecvt' and 'fcvt' functions, and their 'long double' equivalents, |
| all return a string located in a static buffer which is overwritten by |
| the next call to the function. The GNU C Library provides another set |
| of extended functions which write the converted string into a |
| user-supplied buffer. These have the conventional '_r' suffix. |
| |
| 'gcvt_r' is not necessary, because 'gcvt' already uses a |
| user-supplied buffer. |
| |
| -- Function: int ecvt_r (double VALUE, int NDIGIT, int *DECPT, int |
| *NEG, char *BUF, size_t LEN) |
| Preliminary: | MT-Safe | AS-Safe | AC-Safe | *Note POSIX Safety |
| Concepts::. |
| |
| The 'ecvt_r' function is the same as 'ecvt', except that it places |
| its result into the user-specified buffer pointed to by BUF, with |
| length LEN. The return value is '-1' in case of an error and zero |
| otherwise. |
| |
| This function is a GNU extension. |
| |
| -- Function: int fcvt_r (double VALUE, int NDIGIT, int *DECPT, int |
| *NEG, char *BUF, size_t LEN) |
| Preliminary: | MT-Safe | AS-Safe | AC-Safe | *Note POSIX Safety |
| Concepts::. |
| |
| The 'fcvt_r' function is the same as 'fcvt', except that it places |
| its result into the user-specified buffer pointed to by BUF, with |
| length LEN. The return value is '-1' in case of an error and zero |
| otherwise. |
| |
| This function is a GNU extension. |
| |
| -- Function: int qecvt_r (long double VALUE, int NDIGIT, int *DECPT, |
| int *NEG, char *BUF, size_t LEN) |
| Preliminary: | MT-Safe | AS-Safe | AC-Safe | *Note POSIX Safety |
| Concepts::. |
| |
| The 'qecvt_r' function is the same as 'qecvt', except that it |
| places its result into the user-specified buffer pointed to by BUF, |
| with length LEN. The return value is '-1' in case of an error and |
| zero otherwise. |
| |
| This function is a GNU extension. |
| |
| -- Function: int qfcvt_r (long double VALUE, int NDIGIT, int *DECPT, |
| int *NEG, char *BUF, size_t LEN) |
| Preliminary: | MT-Safe | AS-Safe | AC-Safe | *Note POSIX Safety |
| Concepts::. |
| |
| The 'qfcvt_r' function is the same as 'qfcvt', except that it |
| places its result into the user-specified buffer pointed to by BUF, |
| with length LEN. The return value is '-1' in case of an error and |
| zero otherwise. |
| |
| This function is a GNU extension. |
| |
| |
| File: libc.info, Node: Date and Time, Next: Resource Usage And Limitation, Prev: Arithmetic, Up: Top |
| |
| 21 Date and Time |
| **************** |
| |
| This chapter describes functions for manipulating dates and times, |
| including functions for determining what time it is and conversion |
| between different time representations. |
| |
| * Menu: |
| |
| * Time Basics:: Concepts and definitions. |
| * Elapsed Time:: Data types to represent elapsed times |
| * Processor And CPU Time:: Time a program has spent executing. |
| * Calendar Time:: Manipulation of "real" dates and times. |
| * Setting an Alarm:: Sending a signal after a specified time. |
| * Sleeping:: Waiting for a period of time. |
| |
| |
| File: libc.info, Node: Time Basics, Next: Elapsed Time, Up: Date and Time |
| |
| 21.1 Time Basics |
| ================ |
| |
| Discussing time in a technical manual can be difficult because the word |
| "time" in English refers to lots of different things. In this manual, |
| we use a rigorous terminology to avoid confusion, and the only thing we |
| use the simple word "time" for is to talk about the abstract concept. |
| |
| A "calendar time" is a point in the time continuum, for example |
| November 4, 1990 at 18:02.5 UTC. Sometimes this is called "absolute |
| time". |
| |
| We don't speak of a "date", because that is inherent in a calendar |
| time. |
| |
| An "interval" is a contiguous part of the time continuum between two |
| calendar times, for example the hour between 9:00 and 10:00 on July 4, |
| 1980. |
| |
| An "elapsed time" is the length of an interval, for example, 35 |
| minutes. People sometimes sloppily use the word "interval" to refer to |
| the elapsed time of some interval. |
| |
| An "amount of time" is a sum of elapsed times, which need not be of |
| any specific intervals. For example, the amount of time it takes to |
| read a book might be 9 hours, independently of when and in how many |
| sittings it is read. |
| |
| A "period" is the elapsed time of an interval between two events, |
| especially when they are part of a sequence of regularly repeating |
| events. |
| |
| "CPU time" is like calendar time, except that it is based on the |
| subset of the time continuum when a particular process is actively using |
| a CPU. CPU time is, therefore, relative to a process. |
| |
| "Processor time" is an amount of time that a CPU is in use. In fact, |
| it's a basic system resource, since there's a limit to how much can |
| exist in any given interval (that limit is the elapsed time of the |
| interval times the number of CPUs in the processor). People often call |
| this CPU time, but we reserve the latter term in this manual for the |
| definition above. |
| |
| |
| File: libc.info, Node: Elapsed Time, Next: Processor And CPU Time, Prev: Time Basics, Up: Date and Time |
| |
| 21.2 Elapsed Time |
| ================= |
| |
| One way to represent an elapsed time is with a simple arithmetic data |
| type, as with the following function to compute the elapsed time between |
| two calendar times. This function is declared in 'time.h'. |
| |
| -- Function: double difftime (time_t TIME1, time_t TIME0) |
| Preliminary: | MT-Safe | AS-Safe | AC-Safe | *Note POSIX Safety |
| Concepts::. |
| |
| The 'difftime' function returns the number of seconds of elapsed |
| time between calendar time TIME1 and calendar time TIME0, as a |
| value of type 'double'. The difference ignores leap seconds unless |
| leap second support is enabled. |
| |
| In the GNU C Library, you can simply subtract 'time_t' values. But |
| on other systems, the 'time_t' data type might use some other |
| encoding where subtraction doesn't work directly. |
| |
| The GNU C Library provides two data types specifically for |
| representing an elapsed time. They are used by various GNU C Library |
| functions, and you can use them for your own purposes too. They're |
| exactly the same except that one has a resolution in microseconds, and |
| the other, newer one, is in nanoseconds. |
| |
| -- Data Type: struct timeval |
| The 'struct timeval' structure represents an elapsed time. It is |
| declared in 'sys/time.h' and has the following members: |
| |
| 'long int tv_sec' |
| This represents the number of whole seconds of elapsed time. |
| |
| 'long int tv_usec' |
| This is the rest of the elapsed time (a fraction of a second), |
| represented as the number of microseconds. It is always less |
| than one million. |
| |
| -- Data Type: struct timespec |
| The 'struct timespec' structure represents an elapsed time. It is |
| declared in 'time.h' and has the following members: |
| |
| 'long int tv_sec' |
| This represents the number of whole seconds of elapsed time. |
| |
| 'long int tv_nsec' |
| This is the rest of the elapsed time (a fraction of a second), |
| represented as the number of nanoseconds. It is always less |
| than one billion. |
| |
| It is often necessary to subtract two values of type 'struct timeval' |
| or 'struct timespec'. Here is the best way to do this. It works even |
| on some peculiar operating systems where the 'tv_sec' member has an |
| unsigned type. |
| |
| |
| /* Subtract the 'struct timeval' values X and Y, |
| storing the result in RESULT. |
| Return 1 if the difference is negative, otherwise 0. */ |
| |
| int |
| timeval_subtract (result, x, y) |
| struct timeval *result, *x, *y; |
| { |
| /* Perform the carry for the later subtraction by updating Y. */ |
| if (x->tv_usec < y->tv_usec) { |
| int nsec = (y->tv_usec - x->tv_usec) / 1000000 + 1; |
| y->tv_usec -= 1000000 * nsec; |
| y->tv_sec += nsec; |
| } |
| if (x->tv_usec - y->tv_usec > 1000000) { |
| int nsec = (x->tv_usec - y->tv_usec) / 1000000; |
| y->tv_usec += 1000000 * nsec; |
| y->tv_sec -= nsec; |
| } |
| |
| /* Compute the time remaining to wait. |
| 'tv_usec' is certainly positive. */ |
| result->tv_sec = x->tv_sec - y->tv_sec; |
| result->tv_usec = x->tv_usec - y->tv_usec; |
| |
| /* Return 1 if result is negative. */ |
| return x->tv_sec < y->tv_sec; |
| } |
| |
| Common functions that use 'struct timeval' are 'gettimeofday' and |
| 'settimeofday'. |
| |
| There are no GNU C Library functions specifically oriented toward |
| dealing with elapsed times, but the calendar time, processor time, and |
| alarm and sleeping functions have a lot to do with them. |
| |
| |
| File: libc.info, Node: Processor And CPU Time, Next: Calendar Time, Prev: Elapsed Time, Up: Date and Time |
| |
| 21.3 Processor And CPU Time |
| =========================== |
| |
| If you're trying to optimize your program or measure its efficiency, |
| it's very useful to know how much processor time it uses. For that, |
| calendar time and elapsed times are useless because a process may spend |
| time waiting for I/O or for other processes to use the CPU. However, you |
| can get the information with the functions in this section. |
| |
| CPU time (*note Time Basics::) is represented by the data type |
| 'clock_t', which is a number of "clock ticks". It gives the total |
| amount of time a process has actively used a CPU since some arbitrary |
| event. On GNU systems, that event is the creation of the process. |
| While arbitrary in general, the event is always the same event for any |
| particular process, so you can always measure how much time on the CPU a |
| particular computation takes by examining the process' CPU time before |
| and after the computation. |
| |
| On GNU/Linux and GNU/Hurd systems, 'clock_t' is equivalent to 'long |
| int' and 'CLOCKS_PER_SEC' is an integer value. But in other systems, |
| both 'clock_t' and the macro 'CLOCKS_PER_SEC' can be either integer or |
| floating-point types. Casting CPU time values to 'double', as in the |
| example above, makes sure that operations such as arithmetic and |
| printing work properly and consistently no matter what the underlying |
| representation is. |
| |
| Note that the clock can wrap around. On a 32bit system with |
| 'CLOCKS_PER_SEC' set to one million this function will return the same |
| value approximately every 72 minutes. |
| |
| For additional functions to examine a process' use of processor time, |
| and to control it, see *note Resource Usage And Limitation::. |
| |
| * Menu: |
| |
| * CPU Time:: The 'clock' function. |
| * Processor Time:: The 'times' function. |
| |
| |
| File: libc.info, Node: CPU Time, Next: Processor Time, Up: Processor And CPU Time |
| |
| 21.3.1 CPU Time Inquiry |
|
