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.25.
|
|
Copyright © 1993–2017 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.
|
* FE_SNANS_ALWAYS_SIGNAL: (libc)Infinity and NaN.
|
* 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.
|
* FP_LLOGB0: (libc)Exponents and Logarithms.
|
* FP_LLOGBNAN: (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_OFD_GETLK: (libc)Open File Description Locks.
|
* F_OFD_SETLK: (libc)Open File Description Locks.
|
* F_OFD_SETLKW: (libc)Open File Description Locks.
|
* 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.
|
* SNAN: (libc)Infinity and NaN.
|
* SNANF: (libc)Infinity and NaN.
|
* SNANL: (libc)Infinity and NaN.
|
* 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.
|
* 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_high: (libc)PowerPC.
|
* __ppc_set_ppr_med_low: (libc)PowerPC.
|
* __ppc_set_ppr_very_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 Strings and Arrays.
|
* 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 Strings and Arrays.
|
* 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: (libc)FP Bit Twiddling.
|
* canonicalize_file_name: (libc)Symbolic Links.
|
* canonicalizef: (libc)FP Bit Twiddling.
|
* canonicalizel: (libc)FP Bit Twiddling.
|
* 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_remove: (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.
|
* explicit_bzero: (libc)Erasing Sensitive Data.
|
* 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.
|
* fegetmode: (libc)Control Functions.
|
* 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.
|
* fesetexcept: (libc)Status bit operations.
|
* fesetexceptflag: (libc)Status bit operations.
|
* fesetmode: (libc)Control Functions.
|
* fesetround: (libc)Rounding.
|
* fetestexcept: (libc)Status bit operations.
|
* fetestexceptflag: (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.
|
* fmaxmag: (libc)Misc FP Arithmetic.
|
* fmaxmagf: (libc)Misc FP Arithmetic.
|
* fmaxmagl: (libc)Misc FP Arithmetic.
|
* fmemopen: (libc)String Streams.
|
* fmin: (libc)Misc FP Arithmetic.
|
* fminf: (libc)Misc FP Arithmetic.
|
* fminl: (libc)Misc FP Arithmetic.
|
* fminmag: (libc)Misc FP Arithmetic.
|
* fminmagf: (libc)Misc FP Arithmetic.
|
* fminmagl: (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.
|
* fromfp: (libc)Rounding Functions.
|
* fromfpf: (libc)Rounding Functions.
|
* fromfpl: (libc)Rounding Functions.
|
* fromfpx: (libc)Rounding Functions.
|
* fromfpxf: (libc)Rounding Functions.
|
* fromfpxl: (libc)Rounding 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.
|
* getentropy: (libc)Unpredictable Bytes.
|
* 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.
|
* getpayload: (libc)FP Bit Twiddling.
|
* getpayloadf: (libc)FP Bit Twiddling.
|
* getpayloadl: (libc)FP Bit Twiddling.
|
* 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.
|
* getrandom: (libc)Unpredictable Bytes.
|
* 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.
|
* iscanonical: (libc)Floating Point Classes.
|
* iscntrl: (libc)Classification of Characters.
|
* isdigit: (libc)Classification of Characters.
|
* iseqsig: (libc)FP Comparison Functions.
|
* 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.
|
* issubnormal: (libc)Floating Point Classes.
|
* 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.
|
* iszero: (libc)Floating Point Classes.
|
* 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.
|
* llogb: (libc)Exponents and Logarithms.
|
* llogbf: (libc)Exponents and Logarithms.
|
* llogbl: (libc)Exponents and Logarithms.
|
* 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 Strings and Arrays.
|
* memchr: (libc)Search Functions.
|
* memcmp: (libc)String/Array Comparison.
|
* memcpy: (libc)Copying Strings and Arrays.
|
* memfrob: (libc)Trivial Encryption.
|
* memmem: (libc)Search Functions.
|
* memmove: (libc)Copying Strings and Arrays.
|
* mempcpy: (libc)Copying Strings and Arrays.
|
* memrchr: (libc)Search Functions.
|
* memset: (libc)Copying Strings and Arrays.
|
* 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.
|
* nextdown: (libc)FP Bit Twiddling.
|
* nextdownf: (libc)FP Bit Twiddling.
|
* nextdownl: (libc)FP Bit Twiddling.
|
* nexttoward: (libc)FP Bit Twiddling.
|
* nexttowardf: (libc)FP Bit Twiddling.
|
* nexttowardl: (libc)FP Bit Twiddling.
|
* nextup: (libc)FP Bit Twiddling.
|
* nextupf: (libc)FP Bit Twiddling.
|
* nextupl: (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_fallocate64: (libc)Storage Allocation.
|
* posix_fallocate: (libc)Storage Allocation.
|
* 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.
|
* roundeven: (libc)Rounding Functions.
|
* roundevenf: (libc)Rounding Functions.
|
* roundevenl: (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.
|
* sem_close: (libc)Semaphores.
|
* sem_destroy: (libc)Semaphores.
|
* sem_getvalue: (libc)Semaphores.
|
* sem_init: (libc)Semaphores.
|
* sem_open: (libc)Semaphores.
|
* sem_post: (libc)Semaphores.
|
* sem_timedwait: (libc)Semaphores.
|
* sem_trywait: (libc)Semaphores.
|
* sem_unlink: (libc)Semaphores.
|
* sem_wait: (libc)Semaphores.
|
* semctl: (libc)Semaphores.
|
* semget: (libc)Semaphores.
|
* semop: (libc)Semaphores.
|
* semtimedop: (libc)Semaphores.
|
* 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.
|
* setpayload: (libc)FP Bit Twiddling.
|
* setpayloadf: (libc)FP Bit Twiddling.
|
* setpayloadl: (libc)FP Bit Twiddling.
|
* setpayloadsig: (libc)FP Bit Twiddling.
|
* setpayloadsigf: (libc)FP Bit Twiddling.
|
* setpayloadsigl: (libc)FP Bit Twiddling.
|
* 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)BSD Signal Handling.
|
* sigdelset: (libc)Signal Sets.
|
* sigemptyset: (libc)Signal Sets.
|
* sigfillset: (libc)Signal Sets.
|
* siginterrupt: (libc)BSD Signal Handling.
|
* sigismember: (libc)Signal Sets.
|
* siglongjmp: (libc)Non-Local Exits and Signals.
|
* sigmask: (libc)BSD Signal Handling.
|
* signal: (libc)Basic Signal Handling.
|
* signbit: (libc)FP Bit Twiddling.
|
* significand: (libc)Normalization Functions.
|
* significandf: (libc)Normalization Functions.
|
* significandl: (libc)Normalization Functions.
|
* sigpause: (libc)BSD Signal Handling.
|
* sigpending: (libc)Checking for Pending Signals.
|
* sigprocmask: (libc)Process Signal Mask.
|
* sigsetjmp: (libc)Non-Local Exits and Signals.
|
* sigsetmask: (libc)BSD Signal Handling.
|
* sigstack: (libc)Signal Stack.
|
* sigsuspend: (libc)Sigsuspend.
|
* 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 Strings and Arrays.
|
* stpncpy: (libc)Truncating Strings.
|
* strcasecmp: (libc)String/Array Comparison.
|
* strcasestr: (libc)Search Functions.
|
* strcat: (libc)Concatenating Strings.
|
* strchr: (libc)Search Functions.
|
* strchrnul: (libc)Search Functions.
|
* strcmp: (libc)String/Array Comparison.
|
* strcoll: (libc)Collation Functions.
|
* strcpy: (libc)Copying Strings and Arrays.
|
* strcspn: (libc)Search Functions.
|
* strdup: (libc)Copying Strings and Arrays.
|
* strdupa: (libc)Copying Strings and Arrays.
|
* strerror: (libc)Error Messages.
|
* strerror_r: (libc)Error Messages.
|
* strfmon: (libc)Formatting Numbers.
|
* strfromd: (libc)Printing of Floats.
|
* strfromf: (libc)Printing of Floats.
|
* strfroml: (libc)Printing of Floats.
|
* strfry: (libc)strfry.
|
* strftime: (libc)Formatting Calendar Time.
|
* strlen: (libc)String Length.
|
* strncasecmp: (libc)String/Array Comparison.
|
* strncat: (libc)Truncating Strings.
|
* strncmp: (libc)String/Array Comparison.
|
* strncpy: (libc)Truncating Strings.
|
* strndup: (libc)Truncating Strings.
|
* strndupa: (libc)Truncating Strings.
|
* 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.
|
* totalorder: (libc)FP Comparison Functions.
|
* totalorderf: (libc)FP Comparison Functions.
|
* totalorderl: (libc)FP Comparison Functions.
|
* totalordermag: (libc)FP Comparison Functions.
|
* totalordermagf: (libc)FP Comparison Functions.
|
* totalordermagl: (libc)FP Comparison Functions.
|
* 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.
|
* ufromfp: (libc)Rounding Functions.
|
* ufromfpf: (libc)Rounding Functions.
|
* ufromfpl: (libc)Rounding Functions.
|
* ufromfpx: (libc)Rounding Functions.
|
* ufromfpxf: (libc)Rounding Functions.
|
* ufromfpxl: (libc)Rounding 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 Strings and Arrays.
|
* wcpncpy: (libc)Truncating Strings.
|
* wcrtomb: (libc)Converting a Character.
|
* wcscasecmp: (libc)String/Array Comparison.
|
* wcscat: (libc)Concatenating Strings.
|
* wcschr: (libc)Search Functions.
|
* wcschrnul: (libc)Search Functions.
|
* wcscmp: (libc)String/Array Comparison.
|
* wcscoll: (libc)Collation Functions.
|
* wcscpy: (libc)Copying Strings and Arrays.
|
* wcscspn: (libc)Search Functions.
|
* wcsdup: (libc)Copying Strings and Arrays.
|
* wcsftime: (libc)Formatting Calendar Time.
|
* wcslen: (libc)String Length.
|
* wcsncasecmp: (libc)String/Array Comparison.
|
* wcsncat: (libc)Truncating Strings.
|
* wcsncmp: (libc)String/Array Comparison.
|
* wcsncpy: (libc)Truncating Strings.
|
* 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 Strings and Arrays.
|
* wmemmove: (libc)Copying Strings and Arrays.
|
* wmempcpy: (libc)Copying Strings and Arrays.
|
* wmemset: (libc)Copying Strings and Arrays.
|
* 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: Pseudo-Random Numbers, Next: FP Function Optimizations, Prev: Errors in Math Functions, Up: Mathematics
|
|
19.8 Pseudo-Random Numbers
|
==========================
|
|
This section describes the GNU facilities for generating a series of
|
pseudo-random numbers. The numbers generated are not truly random;
|
typically, they form a sequence that repeats periodically, with a period
|
so large that you can ignore it for ordinary purposes. The random
|
number generator works by remembering a "seed" value which it uses to
|
compute the next random number and also to compute a new seed.
|
|
Although the generated numbers look unpredictable within one run of a
|
program, the sequence of numbers is _exactly the same_ from one run to
|
the next. This is because the initial seed is always the same. This is
|
convenient when you are debugging a program, but it is unhelpful if you
|
want the program to behave unpredictably. If you want a different
|
pseudo-random series each time your program runs, you must specify a
|
different seed each time. For ordinary purposes, basing the seed on the
|
current time works well. For random numbers in cryptography, *note
|
Unpredictable Bytes::.
|
|
You can obtain repeatable sequences of numbers on a particular
|
machine type by specifying the same initial seed value for the random
|
number generator. There is no standard meaning for a particular seed
|
value; the same seed, used in different C libraries or on different CPU
|
types, will give you different random numbers.
|
|
The GNU C Library supports the standard ISO C random number functions
|
plus two other sets derived from BSD and SVID. The BSD and ISO C
|
functions provide identical, somewhat limited functionality. If only a
|
small number of random bits are required, we recommend you use the ISO C
|
interface, ‘rand’ and ‘srand’. The SVID functions provide a more
|
flexible interface, which allows better random number generator
|
algorithms, provides more random bits (up to 48) per call, and can
|
provide random floating-point numbers. These functions are required by
|
the XPG standard and therefore will be present in all modern Unix
|
systems.
|
|
* Menu:
|
|
* ISO Random:: ‘rand’ and friends.
|
* BSD Random:: ‘random’ and friends.
|
* SVID Random:: ‘drand48’ and friends.
|
|
|
File: libc.info, Node: ISO Random, Next: BSD Random, Up: Pseudo-Random Numbers
|
|
19.8.1 ISO C Random Number Functions
|
------------------------------------
|
|
This section describes the random number functions that are part of the ISO C
|
standard.
|
|
To use these facilities, you should include the header file
|
‘stdlib.h’ in your program.
|
|
-- Macro: int RAND_MAX
|
The value of this macro is an integer constant representing the
|
largest value the ‘rand’ function can return. In the GNU C
|
Library, it is ‘2147483647’, which is the largest signed integer
|
representable in 32 bits. In other libraries, it may be as low as
|
‘32767’.
|
|
-- Function: int rand (void)
|
Preliminary: | MT-Safe | AS-Unsafe lock | AC-Unsafe lock | *Note
|
POSIX Safety Concepts::.
|
|
The ‘rand’ function returns the next pseudo-random number in the
|
series. The value ranges from ‘0’ to ‘RAND_MAX’.
|
|
-- Function: void srand (unsigned int SEED)
|
Preliminary: | MT-Safe | AS-Unsafe lock | AC-Unsafe lock | *Note
|
POSIX Safety Concepts::.
|
|
This function establishes SEED as the seed for a new series of
|
pseudo-random numbers. If you call ‘rand’ before a seed has been
|
established with ‘srand’, it uses the value ‘1’ as a default seed.
|
|
To produce a different pseudo-random series each time your program
|
is run, do ‘srand (time (0))’.
|
|
POSIX.1 extended the C standard functions to support reproducible
|
random numbers in multi-threaded programs. However, the extension is
|
badly designed and unsuitable for serious work.
|
|
-- Function: int rand_r (unsigned int *SEED)
|
Preliminary: | MT-Safe | AS-Safe | AC-Safe | *Note POSIX Safety
|
Concepts::.
|
|
This function returns a random number in the range 0 to ‘RAND_MAX’
|
just as ‘rand’ does. However, all its state is stored in the SEED
|
argument. This means the RNG’s state can only have as many bits as
|
the type ‘unsigned int’ has. This is far too few to provide a good
|
RNG.
|
|
If your program requires a reentrant RNG, we recommend you use the
|
reentrant GNU extensions to the SVID random number generator. The
|
POSIX.1 interface should only be used when the GNU extensions are
|
not available.
|
|
|
File: libc.info, Node: BSD Random, Next: SVID Random, Prev: ISO Random, Up: Pseudo-Random Numbers
|
|
19.8.2 BSD Random Number Functions
|
----------------------------------
|
|
This section describes a set of random number generation functions that
|
are derived from BSD. There is no advantage to using these functions
|
with the GNU C Library; we support them for BSD compatibility only.
|
|
The prototypes for these functions are in ‘stdlib.h’.
|
|
-- Function: long int random (void)
|
Preliminary: | MT-Safe | AS-Unsafe lock | AC-Unsafe lock | *Note
|
POSIX Safety Concepts::.
|
|
This function returns the next pseudo-random number in the
|
sequence. The value returned ranges from ‘0’ to ‘2147483647’.
|
|
*NB:* Temporarily this function was defined to return a ‘int32_t’
|
value to indicate that the return value always contains 32 bits
|
even if ‘long int’ is wider. The standard demands it differently.
|
Users must always be aware of the 32-bit limitation, though.
|
|
-- Function: void srandom (unsigned int SEED)
|
Preliminary: | MT-Safe | AS-Unsafe lock | AC-Unsafe lock | *Note
|
POSIX Safety Concepts::.
|
|
The ‘srandom’ function sets the state of the random number
|
generator based on the integer SEED. If you supply a SEED value of
|
‘1’, this will cause ‘random’ to reproduce the default set of
|
random numbers.
|
|
To produce a different set of pseudo-random numbers each time your
|
program runs, do ‘srandom (time (0))’.
|
|
-- Function: char * initstate (unsigned int SEED, char *STATE, size_t
|
SIZE)
|
Preliminary: | MT-Safe | AS-Unsafe lock | AC-Unsafe lock | *Note
|
POSIX Safety Concepts::.
|
|
The ‘initstate’ function is used to initialize the random number
|
generator state. The argument STATE is an array of SIZE bytes,
|
used to hold the state information. It is initialized based on
|
SEED. The size must be between 8 and 256 bytes, and should be a
|
power of two. The bigger the STATE array, the better.
|
|
The return value is the previous value of the state information
|
array. You can use this value later as an argument to ‘setstate’
|
to restore that state.
|
|
-- Function: char * setstate (char *STATE)
|
Preliminary: | MT-Safe | AS-Unsafe lock | AC-Unsafe lock | *Note
|
POSIX Safety Concepts::.
|
|
The ‘setstate’ function restores the random number state
|
information STATE. The argument must have been the result of a
|
previous call to INITSTATE or SETSTATE.
|
|
The return value is the previous value of the state information
|
array. You can use this value later as an argument to ‘setstate’
|
to restore that state.
|
|
If the function fails the return value is ‘NULL’.
|
|
The four functions described so far in this section all work on a
|
state which is shared by all threads. The state is not directly
|
accessible to the user and can only be modified by these functions.
|
This makes it hard to deal with situations where each thread should have
|
its own pseudo-random number generator.
|
|
The GNU C Library contains four additional functions which contain
|
the state as an explicit parameter and therefore make it possible to
|
handle thread-local PRNGs. Besides this there is no difference. In
|
fact, the four functions already discussed are implemented internally
|
using the following interfaces.
|
|
The ‘stdlib.h’ header contains a definition of the following type:
|
|
-- Data Type: struct random_data
|
|
Objects of type ‘struct random_data’ contain the information
|
necessary to represent the state of the PRNG. Although a complete
|
definition of the type is present the type should be treated as
|
opaque.
|
|
The functions modifying the state follow exactly the already
|
described functions.
|
|
-- Function: int random_r (struct random_data *restrict BUF, int32_t
|
*restrict RESULT)
|
Preliminary: | MT-Safe race:buf | AS-Safe | AC-Unsafe corrupt |
|
*Note POSIX Safety Concepts::.
|
|
The ‘random_r’ function behaves exactly like the ‘random’ function
|
except that it uses and modifies the state in the object pointed to
|
by the first parameter instead of the global state.
|
|
-- Function: int srandom_r (unsigned int SEED, struct random_data *BUF)
|
Preliminary: | MT-Safe race:buf | AS-Safe | AC-Unsafe corrupt |
|
*Note POSIX Safety Concepts::.
|
|
The ‘srandom_r’ function behaves exactly like the ‘srandom’
|
function except that it uses and modifies the state in the object
|
pointed to by the second parameter instead of the global state.
|
|
-- Function: int initstate_r (unsigned int SEED, char *restrict
|
STATEBUF, size_t STATELEN, struct random_data *restrict BUF)
|
Preliminary: | MT-Safe race:buf | AS-Safe | AC-Unsafe corrupt |
|
*Note POSIX Safety Concepts::.
|
|
The ‘initstate_r’ function behaves exactly like the ‘initstate’
|
function except that it uses and modifies the state in the object
|
pointed to by the fourth parameter instead of the global state.
|
|
-- Function: int setstate_r (char *restrict STATEBUF, struct
|
random_data *restrict BUF)
|
Preliminary: | MT-Safe race:buf | AS-Safe | AC-Unsafe corrupt |
|
*Note POSIX Safety Concepts::.
|
|
The ‘setstate_r’ function behaves exactly like the ‘setstate’
|
function except that it uses and modifies the state in the object
|
pointed to by the first parameter instead of the global state.
|
|
|
File: libc.info, Node: SVID Random, Prev: BSD Random, Up: Pseudo-Random Numbers
|
|
19.8.3 SVID Random Number Function
|
----------------------------------
|
|
The C library on SVID systems contains yet another kind of random number
|
generator functions. They use a state of 48 bits of data. The user can
|
choose among a collection of functions which return the random bits in
|
different forms.
|
|
Generally there are two kinds of function. The first uses a state of
|
the random number generator which is shared among several functions and
|
by all threads of the process. The second requires the user to handle
|
the state.
|
|
All functions have in common that they use the same congruential
|
formula with the same constants. The formula is
|
|
Y = (a * X + c) mod m
|
|
where X is the state of the generator at the beginning and Y the state
|
at the end. ‘a’ and ‘c’ are constants determining the way the generator
|
works. By default they are
|
|
a = 0x5DEECE66D = 25214903917
|
c = 0xb = 11
|
|
but they can also be changed by the user. ‘m’ is of course 2^48 since
|
the state consists of a 48-bit array.
|
|
The prototypes for these functions are in ‘stdlib.h’.
|
|
-- Function: double drand48 (void)
|
Preliminary: | MT-Unsafe race:drand48 | AS-Unsafe | AC-Unsafe
|
corrupt | *Note POSIX Safety Concepts::.
|
|
This function returns a ‘double’ value in the range of ‘0.0’ to
|
‘1.0’ (exclusive). The random bits are determined by the global
|
state of the random number generator in the C library.
|
|
Since the ‘double’ type according to IEEE 754 has a 52-bit mantissa
|
this means 4 bits are not initialized by the random number
|
generator. These are (of course) chosen to be the least
|
significant bits and they are initialized to ‘0’.
|
|
-- Function: double erand48 (unsigned short int XSUBI[3])
|
Preliminary: | MT-Unsafe race:drand48 | AS-Unsafe | AC-Unsafe
|
corrupt | *Note POSIX Safety Concepts::.
|
|
This function returns a ‘double’ value in the range of ‘0.0’ to
|
‘1.0’ (exclusive), similarly to ‘drand48’. The argument is an
|
array describing the state of the random number generator.
|
|
This function can be called subsequently since it updates the array
|
to guarantee random numbers. The array should have been
|
initialized before initial use to obtain reproducible results.
|
|
-- Function: long int lrand48 (void)
|
Preliminary: | MT-Unsafe race:drand48 | AS-Unsafe | AC-Unsafe
|
corrupt | *Note POSIX Safety Concepts::.
|
|
The ‘lrand48’ function returns an integer value in the range of ‘0’
|
to ‘2^31’ (exclusive). Even if the size of the ‘long int’ type can
|
take more than 32 bits, no higher numbers are returned. The random
|
bits are determined by the global state of the random number
|
generator in the C library.
|
|
-- Function: long int nrand48 (unsigned short int XSUBI[3])
|
Preliminary: | MT-Unsafe race:drand48 | AS-Unsafe | AC-Unsafe
|
corrupt | *Note POSIX Safety Concepts::.
|
|
This function is similar to the ‘lrand48’ function in that it
|
returns a number in the range of ‘0’ to ‘2^31’ (exclusive) but the
|
state of the random number generator used to produce the random
|
bits is determined by the array provided as the parameter to the
|
function.
|
|
The numbers in the array are updated afterwards so that subsequent
|
calls to this function yield different results (as is expected of a
|
random number generator). The array should have been initialized
|
before the first call to obtain reproducible results.
|
|
-- Function: long int mrand48 (void)
|
Preliminary: | MT-Unsafe race:drand48 | AS-Unsafe | AC-Unsafe
|
corrupt | *Note POSIX Safety Concepts::.
|
|
The ‘mrand48’ function is similar to ‘lrand48’. The only
|
difference is that the numbers returned are in the range ‘-2^31’ to
|
‘2^31’ (exclusive).
|
|
-- Function: long int jrand48 (unsigned short int XSUBI[3])
|
Preliminary: | MT-Unsafe race:drand48 | AS-Unsafe | AC-Unsafe
|
corrupt | *Note POSIX Safety Concepts::.
|
|
The ‘jrand48’ function is similar to ‘nrand48’. The only
|
difference is that the numbers returned are in the range ‘-2^31’ to
|
‘2^31’ (exclusive). For the ‘xsubi’ parameter the same
|
requirements are necessary.
|
|
The internal state of the random number generator can be initialized
|
in several ways. The methods differ in the completeness of the
|
information provided.
|
|
-- Function: void srand48 (long int SEEDVAL)
|
Preliminary: | MT-Unsafe race:drand48 | AS-Unsafe | AC-Unsafe
|
corrupt | *Note POSIX Safety Concepts::.
|
|
The ‘srand48’ function sets the most significant 32 bits of the
|
internal state of the random number generator to the least
|
significant 32 bits of the SEEDVAL parameter. The lower 16 bits
|
are initialized to the value ‘0x330E’. Even if the ‘long int’ type
|
contains more than 32 bits only the lower 32 bits are used.
|
|
Owing to this limitation, initialization of the state of this
|
function is not very useful. But it makes it easy to use a
|
construct like ‘srand48 (time (0))’.
|
|
A side-effect of this function is that the values ‘a’ and ‘c’ from
|
the internal state, which are used in the congruential formula, are
|
reset to the default values given above. This is of importance
|
once the user has called the ‘lcong48’ function (see below).
|
|
-- Function: unsigned short int * seed48 (unsigned short int
|
SEED16V[3])
|
Preliminary: | MT-Unsafe race:drand48 | AS-Unsafe | AC-Unsafe
|
corrupt | *Note POSIX Safety Concepts::.
|
|
The ‘seed48’ function initializes all 48 bits of the state of the
|
internal random number generator from the contents of the parameter
|
SEED16V. Here the lower 16 bits of the first element of SEED16V
|
initialize the least significant 16 bits of the internal state, the
|
lower 16 bits of ‘SEED16V[1]’ initialize the mid-order 16 bits of
|
the state and the 16 lower bits of ‘SEED16V[2]’ initialize the most
|
significant 16 bits of the state.
|
|
Unlike ‘srand48’ this function lets the user initialize all 48 bits
|
of the state.
|
|
The value returned by ‘seed48’ is a pointer to an array containing
|
the values of the internal state before the change. This might be
|
useful to restart the random number generator at a certain state.
|
Otherwise the value can simply be ignored.
|
|
As for ‘srand48’, the values ‘a’ and ‘c’ from the congruential
|
formula are reset to the default values.
|
|
There is one more function to initialize the random number generator
|
which enables you to specify even more information by allowing you to
|
change the parameters in the congruential formula.
|
|
-- Function: void lcong48 (unsigned short int PARAM[7])
|
Preliminary: | MT-Unsafe race:drand48 | AS-Unsafe | AC-Unsafe
|
corrupt | *Note POSIX Safety Concepts::.
|
|
The ‘lcong48’ function allows the user to change the complete state
|
of the random number generator. Unlike ‘srand48’ and ‘seed48’,
|
this function also changes the constants in the congruential
|
formula.
|
|
From the seven elements in the array PARAM the least significant 16
|
bits of the entries ‘PARAM[0]’ to ‘PARAM[2]’ determine the initial
|
state, the least significant 16 bits of ‘PARAM[3]’ to ‘PARAM[5]’
|
determine the 48 bit constant ‘a’ and ‘PARAM[6]’ determines the
|
16-bit value ‘c’.
|
|
All the above functions have in common that they use the global
|
parameters for the congruential formula. In multi-threaded programs it
|
might sometimes be useful to have different parameters in different
|
threads. For this reason all the above functions have a counterpart
|
which works on a description of the random number generator in the
|
user-supplied buffer instead of the global state.
|
|
Please note that it is no problem if several threads use the global
|
state if all threads use the functions which take a pointer to an array
|
containing the state. The random numbers are computed following the
|
same loop but if the state in the array is different all threads will
|
obtain an individual random number generator.
|
|
The user-supplied buffer must be of type ‘struct drand48_data’. This
|
type should be regarded as opaque and not manipulated directly.
|
|
-- Function: int drand48_r (struct drand48_data *BUFFER, double
|
*RESULT)
|
Preliminary: | MT-Safe race:buffer | AS-Safe | AC-Unsafe corrupt |
|
*Note POSIX Safety Concepts::.
|
|
This function is equivalent to the ‘drand48’ function with the
|
difference that it does not modify the global random number
|
generator parameters but instead the parameters in the buffer
|
supplied through the pointer BUFFER. The random number is returned
|
in the variable pointed to by RESULT.
|
|
The return value of the function indicates whether the call
|
succeeded. If the value is less than ‘0’ an error occurred and
|
ERRNO is set to indicate the problem.
|
|
This function is a GNU extension and should not be used in portable
|
programs.
|
|
-- Function: int erand48_r (unsigned short int XSUBI[3], struct
|
drand48_data *BUFFER, double *RESULT)
|
Preliminary: | MT-Safe race:buffer | AS-Safe | AC-Unsafe corrupt |
|
*Note POSIX Safety Concepts::.
|
|
The ‘erand48_r’ function works like ‘erand48’, but in addition it
|
takes an argument BUFFER which describes the random number
|
generator. The state of the random number generator is taken from
|
the ‘xsubi’ array, the parameters for the congruential formula from
|
the global random number generator data. The random number is
|
returned in the variable pointed to by RESULT.
|
|
The return value is non-negative if the call succeeded.
|
|
This function is a GNU extension and should not be used in portable
|
programs.
|
|
-- Function: int lrand48_r (struct drand48_data *BUFFER, long int
|
*RESULT)
|
Preliminary: | MT-Safe race:buffer | AS-Safe | AC-Unsafe corrupt |
|
*Note POSIX Safety Concepts::.
|
|
This function is similar to ‘lrand48’, but in addition it takes a
|
pointer to a buffer describing the state of the random number
|
generator just like ‘drand48’.
|
|
If the return value of the function is non-negative the variable
|
pointed to by RESULT contains the result. Otherwise an error
|
occurred.
|
|
This function is a GNU extension and should not be used in portable
|
programs.
|
|
-- Function: int nrand48_r (unsigned short int XSUBI[3], struct
|
drand48_data *BUFFER, long int *RESULT)
|
Preliminary: | MT-Safe race:buffer | AS-Safe | AC-Unsafe corrupt |
|
*Note POSIX Safety Concepts::.
|
|
The ‘nrand48_r’ function works like ‘nrand48’ in that it produces a
|
random number in the range ‘0’ to ‘2^31’. But instead of using the
|
global parameters for the congruential formula it uses the
|
information from the buffer pointed to by BUFFER. The state is
|
described by the values in XSUBI.
|
|
If the return value is non-negative the variable pointed to by
|
RESULT contains the result.
|
|
This function is a GNU extension and should not be used in portable
|
programs.
|
|
-- Function: int mrand48_r (struct drand48_data *BUFFER, long int
|
*RESULT)
|
Preliminary: | MT-Safe race:buffer | AS-Safe | AC-Unsafe corrupt |
|
*Note POSIX Safety Concepts::.
|
|
This function is similar to ‘mrand48’ but like the other reentrant
|
functions it uses the random number generator described by the
|
value in the buffer pointed to by BUFFER.
|
|
If the return value is non-negative the variable pointed to by
|
RESULT contains the result.
|
|
This function is a GNU extension and should not be used in portable
|
programs.
|
|
-- Function: int jrand48_r (unsigned short int XSUBI[3], struct
|
drand48_data *BUFFER, long int *RESULT)
|
Preliminary: | MT-Safe race:buffer | AS-Safe | AC-Unsafe corrupt |
|
*Note POSIX Safety Concepts::.
|
|
The ‘jrand48_r’ function is similar to ‘jrand48’. Like the other
|
reentrant functions of this function family it uses the
|
congruential formula parameters from the buffer pointed to by
|
BUFFER.
|
|
If the return value is non-negative the variable pointed to by
|
RESULT contains the result.
|
|
This function is a GNU extension and should not be used in portable
|
programs.
|
|
Before any of the above functions are used the buffer of type ‘struct
|
drand48_data’ should be initialized. The easiest way to do this is to
|
fill the whole buffer with null bytes, e.g. by
|
|
memset (buffer, '\0', sizeof (struct drand48_data));
|
|
Using any of the reentrant functions of this family now will
|
automatically initialize the random number generator to the default
|
values for the state and the parameters of the congruential formula.
|
|
The other possibility is to use any of the functions which explicitly
|
initialize the buffer. Though it might be obvious how to initialize the
|
buffer from looking at the parameter to the function, it is highly
|
recommended to use these functions since the result might not always be
|
what you expect.
|
|
-- Function: int srand48_r (long int SEEDVAL, struct drand48_data
|
*BUFFER)
|
Preliminary: | MT-Safe race:buffer | AS-Safe | AC-Unsafe corrupt |
|
*Note POSIX Safety Concepts::.
|
|
The description of the random number generator represented by the
|
information in BUFFER is initialized similarly to what the function
|
‘srand48’ does. The state is initialized from the parameter
|
SEEDVAL and the parameters for the congruential formula are
|
initialized to their default values.
|
|
If the return value is non-negative the function call succeeded.
|
|
This function is a GNU extension and should not be used in portable
|
programs.
|
|
-- Function: int seed48_r (unsigned short int SEED16V[3], struct
|
drand48_data *BUFFER)
|
Preliminary: | MT-Safe race:buffer | AS-Safe | AC-Unsafe corrupt |
|
*Note POSIX Safety Concepts::.
|
|
This function is similar to ‘srand48_r’ but like ‘seed48’ it
|
initializes all 48 bits of the state from the parameter SEED16V.
|
|
If the return value is non-negative the function call succeeded.
|
It does not return a pointer to the previous state of the random
|
number generator like the ‘seed48’ function does. If the user
|
wants to preserve the state for a later re-run s/he can copy the
|
whole buffer pointed to by BUFFER.
|
|
This function is a GNU extension and should not be used in portable
|
programs.
|
|
-- Function: int lcong48_r (unsigned short int PARAM[7], struct
|
drand48_data *BUFFER)
|
Preliminary: | MT-Safe race:buffer | AS-Safe | AC-Unsafe corrupt |
|
*Note POSIX Safety Concepts::.
|
|
This function initializes all aspects of the random number
|
generator described in BUFFER with the data in PARAM. Here it is
|
especially true that the function does more than just copying the
|
contents of PARAM and BUFFER. More work is required and therefore
|
it is important to use this function rather than initializing the
|
random number generator directly.
|
|
If the return value is non-negative the function call succeeded.
|
|
This function is a GNU extension and should not be used in portable
|
programs.
|
|
|
File: libc.info, Node: FP Function Optimizations, Prev: Pseudo-Random Numbers, Up: Mathematics
|
|
19.9 Is Fast Code or Small Code preferred?
|
==========================================
|
|
If an application uses many floating point functions it is often the
|
case that the cost of the function calls themselves is not negligible.
|
Modern processors can often execute the operations themselves very fast,
|
but the function call disrupts the instruction pipeline.
|
|
For this reason the GNU C Library provides optimizations for many of
|
the frequently-used math functions. When GNU CC is used and the user
|
activates the optimizer, several new inline functions and macros are
|
defined. These new functions and macros have the same names as the
|
library functions and so are used instead of the latter. In the case of
|
inline functions the compiler will decide whether it is reasonable to
|
use them, and this decision is usually correct.
|
|
This means that no calls to the library functions may be necessary,
|
and can increase the speed of generated code significantly. The
|
drawback is that code size will increase, and the increase is not always
|
negligible.
|
|
There are two kinds of inline functions: those that give the same
|
result as the library functions and others that might not set ‘errno’
|
and might have a reduced precision and/or argument range in comparison
|
with the library functions. The latter inline functions are only
|
available if the flag ‘-ffast-math’ is given to GNU CC.
|
|
In cases where the inline functions and macros are not wanted the
|
symbol ‘__NO_MATH_INLINES’ should be defined before any system header is
|
included. This will ensure that only library functions are used. Of
|
course, it can be determined for each file in the project whether giving
|
this option is preferable or not.
|
|
Not all hardware implements the entire IEEE 754 standard, and even if
|
it does there may be a substantial performance penalty for using some of
|
its features. For example, enabling traps on some processors forces the
|
FPU to run un-pipelined, which can more than double calculation time.
|
|
|
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.
|
* Printing of Floats:: Converting floating-point numbers to strings.
|
* 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.
|
Similiarly, there are macros such as ‘INTMAX_WIDTH’ for the width of
|
these types. Those macros for integer type widths come from TS
|
18661-1:2014.
|
|
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::.
|
|
The 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 iscanonical (_float-type_ X)
|
Preliminary: | MT-Safe | AS-Safe | AC-Safe | *Note POSIX Safety
|
Concepts::.
|
|
In some floating-point formats, some values have canonical
|
(preferred) and noncanonical encodings (for IEEE interchange binary
|
formats, all encodings are canonical). This macro returns a
|
nonzero value if X has a canonical encoding. It is from TS
|
18661-1:2014.
|
|
Note that some formats have multiple encodings of a value which are
|
all equally canonical; ‘iscanonical’ returns a nonzero value for
|
all such encodings. Also, formats may have encodings that do not
|
correspond to any valid value of the type. In ISO C terms these
|
are "trap representations"; in the GNU C Library, ‘iscanonical’
|
returns zero for such encodings.
|
|
-- 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 from TS 18661-1:2014.
|
|
-- Macro: int issubnormal (_float-type_ X)
|
Preliminary: | MT-Safe | AS-Safe | AC-Safe | *Note POSIX Safety
|
Concepts::.
|
|
This macro returns a nonzero value if X is subnormal. It is from
|
TS 18661-1:2014.
|
|
-- Macro: int iszero (_float-type_ X)
|
Preliminary: | MT-Safe | AS-Safe | AC-Safe | *Note POSIX Safety
|
Concepts::.
|
|
This macro returns a nonzero value if X is zero. It is from TS
|
18661-1:2014.
|
|
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 than 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’.)
|
|
-- Macro: float SNANF
|
-- Macro: double SNAN
|
-- Macro: long double SNANL
|
These macros, defined by TS 18661-1:2014, are constant expressions
|
for signaling NaNs.
|
|
-- Macro: int FE_SNANS_ALWAYS_SIGNAL
|
This macro, defined by TS 18661-1:2014, is defined to ‘1’ in
|
‘fenv.h’ to indicate that functions and operations with signaling
|
NaN inputs and floating-point results always raise the invalid
|
exception and return a quiet NaN, even in cases (such as ‘fmax’,
|
‘hypot’ and ‘pow’) where a quiet NaN input can produce a non-NaN
|
result. Because some compiler optimizations may not handle
|
signaling NaNs correctly, this macro is only defined if compiler
|
support for signaling NaNs is enabled. That support can be enabled
|
with the GCC option ‘-fsignaling-nans’.
|
|
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 fesetexcept (int EXCEPTS)
|
Preliminary: | MT-Safe | AS-Safe | AC-Safe | *Note POSIX Safety
|
Concepts::.
|
|
This function sets the supported exception flags indicated by
|
EXCEPTS, like ‘feraiseexcept’, but without causing enabled traps to
|
be taken. ‘fesetexcept’ is from TS 18661-1:2014.
|
|
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.
|
|
-- Function: int fetestexceptflag (const fexcept_t *FLAGP, int EXCEPTS)
|
Preliminary: | MT-Safe | AS-Safe | AC-Safe | *Note POSIX Safety
|
Concepts::.
|
|
Test whether the exception flags indicated by the parameter EXCEPTS
|
are set in the variable pointed to by FLAGP. If any of them are, a
|
nonzero value is returned which specifies which exceptions are set.
|
Otherwise the result is zero. ‘fetestexceptflag’ is from TS
|
18661-1:2014.
|
|
|
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.
|
|
When a math function has an argument that is a signaling NaN, the GNU
|
C Library does not consider this a domain error, so ‘errno’ is
|
unchanged, but the invalid exception is still raised (except for a few
|
functions that are specified to handle signaling NaNs differently).
|
|
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, or 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.
|
|
TS 18661-1:2014 defines additional functions to save and restore
|
floating-point control modes (such as the rounding mode and whether
|
traps are enabled) while leaving other status (such as raised flags)
|
unchanged.
|
|
The special macro ‘FE_DFL_MODE’ may be passed to ‘fesetmode’. It
|
represents the floating-point control modes at program start.
|
|
-- Function: int fegetmode (femode_t *MODEP)
|
Preliminary: | MT-Safe | AS-Safe | AC-Safe | *Note POSIX Safety
|
Concepts::.
|
|
Store the floating-point control modes in the variable pointed to
|
by MODEP.
|
|
The function returns zero in case the operation was successful, a
|
non-zero value otherwise.
|
|
-- Function: int fesetmode (const femode_t *MODEP)
|
Preliminary: | MT-Safe | AS-Safe | AC-Safe | *Note POSIX Safety
|
Concepts::.
|
|
Set the floating-point control modes to those described by MODEP.
|
|
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 function enables traps for each of the exceptions as indicated
|
by the parameter EXCEPTS. 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 function disables traps for each of the exceptions as
|
indicated by the parameter EXCEPTS. 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.
|
|
The ‘fromfp’ functions use the following macros, from TS
|
18661-1:2014, to specify the direction of rounding. These correspond to
|
the rounding directions defined in IEEE 754-2008.
|
|
‘FP_INT_UPWARD’
|
Round toward +oo.
|
|
‘FP_INT_DOWNWARD’
|
Round toward -oo.
|
|
‘FP_INT_TOWARDZERO’
|
Round toward zero.
|
|
‘FP_INT_TONEARESTFROMZERO’
|
Round to nearest, ties round away from zero.
|
|
‘FP_INT_TONEAREST’
|
Round to nearest, ties round to even.
|
|
-- 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: double roundeven (double X)
|
-- Function: float roundevenf (float X)
|
-- Function: long double roundevenl (long double X)
|
Preliminary: | MT-Safe | AS-Safe | AC-Safe | *Note POSIX Safety
|
Concepts::.
|
|
These functions, from TS 18661-1:2014, are similar to ‘round’, but
|
they round halfway cases to even instead of away from zero.
|
|
-- 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: intmax_t fromfp (double X, int ROUND, unsigned int WIDTH)
|
-- Function: intmax_t fromfpf (float X, int ROUND, unsigned int WIDTH)
|
-- Function: intmax_t fromfpl (long double X, int ROUND, unsigned int
|
WIDTH)
|
-- Function: uintmax_t ufromfp (double X, int ROUND, unsigned int
|
WIDTH)
|
-- Function: uintmax_t ufromfpf (float X, int ROUND, unsigned int
|
WIDTH)
|
-- Function: uintmax_t ufromfpl (long double X, int ROUND, unsigned int
|
WIDTH)
|
-- Function: intmax_t fromfpx (double X, int ROUND, unsigned int WIDTH)
|
-- Function: intmax_t fromfpxf (float X, int ROUND, unsigned int WIDTH)
|
-- Function: intmax_t fromfpxl (long double X, int ROUND, unsigned int
|
WIDTH)
|
-- Function: uintmax_t ufromfpx (double X, int ROUND, unsigned int
|
WIDTH)
|
-- Function: uintmax_t ufromfpxf (float X, int ROUND, unsigned int
|
WIDTH)
|
-- Function: uintmax_t ufromfpxl (long double X, int ROUND, unsigned
|
int WIDTH)
|
Preliminary: | MT-Safe | AS-Safe | AC-Safe | *Note POSIX Safety
|
Concepts::.
|
|
These functions, from TS 18661-1:2014, convert a floating-point
|
number to an integer according to the rounding direction ROUND (one
|
of the ‘FP_INT_*’ macros). If the integer is outside the range of
|
a signed or unsigned (depending on the return type of the function)
|
type of width WIDTH bits (or outside the range of the return type,
|
if WIDTH is larger), or if X is infinite or NaN, or if WIDTH is
|
zero, a domain error occurs and an unspecified value is returned.
|
The functions with an ‘x’ in their names raise the inexact
|
exception when a domain error does not occur and the argument is
|
not an integer; the other functions do not raise the inexact
|
exception.
|
|
-- 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 nextup (double X)
|
-- Function: float nextupf (float X)
|
-- Function: long double nextupl (long double X)
|
Preliminary: | MT-Safe | AS-Safe | AC-Safe | *Note POSIX Safety
|
Concepts::.
|
|
The ‘nextup’ function returns the next representable neighbor of X
|
in the direction of positive infinity. If X is the smallest
|
negative subnormal number in the type of X the function returns
|
‘-0’. If X = ‘0’ the function returns the smallest positive
|
subnormal number in the type of X. If X is NaN, NaN is returned.
|
If X is +oo, +oo is returned. ‘nextup’ is from TS 18661-1:2014.
|
‘nextup’ never raises an exception except for signaling NaNs.
|
|
-- Function: double nextdown (double X)
|
-- Function: float nextdownf (float X)
|
-- Function: long double nextdownl (long double X)
|
Preliminary: | MT-Safe | AS-Safe | AC-Safe | *Note POSIX Safety
|
Concepts::.
|
|
The ‘nextdown’ function returns the next representable neighbor of
|
X in the direction of negative infinity. If X is the smallest
|
positive subnormal number in the type of X the function returns
|
‘+0’. If X = ‘0’ the function returns the smallest negative
|
subnormal number in the type of X. If X is NaN, NaN is returned.
|
If X is -oo, -oo is returned. ‘nextdown’ is from TS 18661-1:2014.
|
‘nextdown’ never raises an exception except for signaling NaNs.
|
|
-- 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.
|
|
-- Function: int canonicalize (double *CX, const double *X)
|
-- Function: int canonicalizef (float *CX, const float *X)
|
-- Function: int canonicalizel (long double *CX, const long double *X)
|
Preliminary: | MT-Safe | AS-Safe | AC-Safe | *Note POSIX Safety
|
Concepts::.
|
|
In some floating-point formats, some values have canonical
|
(preferred) and noncanonical encodings (for IEEE interchange binary
|
formats, all encodings are canonical). These functions, defined by
|
TS 18661-1:2014, attempt to produce a canonical version of the
|
floating-point value pointed to by X; if that value is a signaling
|
NaN, they raise the invalid exception and produce a quiet NaN. If a
|
canonical value is produced, it is stored in the object pointed to
|
by CX, and these functions return zero. Otherwise (if a canonical
|
value could not be produced because the object pointed to by X is
|
not a valid representation of any floating-point value), the object
|
pointed to by CX is unchanged and a nonzero value is returned.
|
|
Note that some formats have multiple encodings of a value which are
|
all equally canonical; when such an encoding is used as an input to
|
this function, any such encoding of the same value (or of the
|
corresponding quiet NaN, if that value is a signaling NaN) may be
|
produced as output.
|
|
-- Function: double getpayload (const double *X)
|
-- Function: float getpayloadf (const float *X)
|
-- Function: long double getpayloadl (const long double *X)
|
Preliminary: | MT-Safe | AS-Safe | AC-Safe | *Note POSIX Safety
|
Concepts::.
|
|
IEEE 754 defines the "payload" of a NaN to be an integer value
|
encoded in the representation of the NaN. Payloads are typically
|
propagated from NaN inputs to the result of a floating-point
|
operation. These functions, defined by TS 18661-1:2014, return the
|
payload of the NaN pointed to by X (returned as a positive integer,
|
or positive zero, represented as a floating-point number); if X is
|
not a NaN, they return an unspecified value. They raise no
|
floating-point exceptions even for signaling NaNs.
|
|
-- Function: int setpayload (double *X, double PAYLOAD)
|
-- Function: int setpayloadf (float *X, float PAYLOAD)
|
-- Function: int setpayloadl (long double *X, long double PAYLOAD)
|
Preliminary: | MT-Safe | AS-Safe | AC-Safe | *Note POSIX Safety
|
Concepts::.
|
|
These functions, defined by TS 18661-1:2014, set the object pointed
|
to by X to a quiet NaN with payload PAYLOAD and a zero sign bit and
|
return zero. If PAYLOAD is not a positive-signed integer that is a
|
valid payload for a quiet NaN of the given type, the object pointed
|
to by X is set to positive zero and a nonzero value is returned.
|
They raise no floating-point exceptions.
|
|
-- Function: int setpayloadsig (double *X, double PAYLOAD)
|
-- Function: int setpayloadsigf (float *X, float PAYLOAD)
|
-- Function: int setpayloadsigl (long double *X, long double PAYLOAD)
|
Preliminary: | MT-Safe | AS-Safe | AC-Safe | *Note POSIX Safety
|
Concepts::.
|
|
These functions, defined by TS 18661-1:2014, set the object pointed
|
to by X to a signaling NaN with payload PAYLOAD and a zero sign bit
|
and return zero. If PAYLOAD is not a positive-signed integer that
|
is a valid payload for a signaling NaN of the given type, the
|
object pointed to by X is set to positive zero and a nonzero value
|
is returned. They raise no floating-point exceptions.
|
|
|
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. TS 18661-1:2014 adds
|
such a macro for an equality comparison that _does_ raise an exception
|
for a NaN argument; it also adds functions that provide a total ordering
|
on all floating-point values, including NaNs, without raising any
|
exceptions even for signaling NaNs.
|
|
-- 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.
|
|
-- Macro: int iseqsig (_real-floating_ X, _real-floating_ Y)
|
Preliminary: | MT-Safe | AS-Safe | AC-Safe | *Note POSIX Safety
|
Concepts::.
|
|
This macro determines whether its arguments are equal. It is
|
equivalent to ‘(X) == (Y)’, but it raises the invalid exception and
|
sets ‘errno’ to ‘EDOM’ if either argument is a NaN.
|
|
-- Function: int totalorder (double X, double Y)
|
-- Function: int totalorderf (float X, float Y)
|
-- Function: int totalorderl (long double X, long double Y)
|
Preliminary: | MT-Safe | AS-Safe | AC-Safe | *Note POSIX Safety
|
Concepts::.
|
|
These functions determine whether the total order relationship,
|
defined in IEEE 754-2008, is true for X and Y, returning nonzero if
|
it is true and zero if it is false. No exceptions are raised even
|
for signaling NaNs. The relationship is true if they are the same
|
floating-point value (including sign for zero and NaNs, and payload
|
for NaNs), or if X comes before Y in the following order: negative
|
quiet NaNs, in order of decreasing payload; negative signaling
|
NaNs, in order of decreasing payload; negative infinity; finite
|
numbers, in ascending order, with negative zero before positive
|
zero; positive infinity; positive signaling NaNs, in order of
|
increasing payload; positive quiet NaNs, in order of increasing
|
payload.
|
|
-- Function: int totalordermag (double X, double Y)
|
-- Function: int totalordermagf (float X, float Y)
|
-- Function: int totalordermagl (long double X, long double Y)
|
Preliminary: | MT-Safe | AS-Safe | AC-Safe | *Note POSIX Safety
|
Concepts::.
|
|
These functions determine whether the total order relationship,
|
defined in IEEE 754-2008, is true for the absolute values of X and
|
Y, returning nonzero if it is true and zero if it is false. No
|
exceptions are raised even for signaling NaNs.
|
|
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 fminmag (double X, double Y)
|
-- Function: float fminmagf (float X, float Y)
|
-- Function: long double fminmagl (long double X, long double Y)
|
Preliminary: | MT-Safe | AS-Safe | AC-Safe | *Note POSIX Safety
|
Concepts::.
|
|
These functions, from TS 18661-1:2014, return whichever of the two
|
values X and Y has the smaller absolute value. If both have the
|
same absolute value, or either is NaN, they behave the same as the
|
‘fmin’ functions.
|
|
-- Function: double fmaxmag (double X, double Y)
|
-- Function: float fmaxmagf (float X, float Y)
|
-- Function: long double fmaxmagl (long double X, long double Y)
|
Preliminary: | MT-Safe | AS-Safe | AC-Safe | *Note POSIX Safety
|
Concepts::.
|
|
These functions, from TS 18661-1:2014, return whichever of the two
|
values X and Y has the greater absolute value. If both have the
|
same absolute value, or either is NaN, they behave the same as the
|
‘fmax’ functions.
|
|
-- 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: Printing of Floats, 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: Printing of Floats, Next: System V Number Conversion, Prev: Parsing of Numbers, Up: Arithmetic
|
|
20.12 Printing of Floats
|
========================
|
|
The ‘strfrom’ functions are declared in ‘stdlib.h’.
|
|
-- Function: int strfromd (char *restrict STRING, size_t SIZE, const
|
char *restrict FORMAT, double VALUE)
|
-- Function: int strfromf (char *restrict STRING, size_t SIZE, const
|
char *restrict FORMAT, float VALUE)
|
-- Function: int strfroml (char *restrict STRING, size_t SIZE, const
|
char *restrict FORMAT, long double VALUE)
|
Preliminary: | MT-Safe locale | AS-Unsafe heap | AC-Unsafe mem |
|
*Note POSIX Safety Concepts::.
|
|
The functions ‘strfromd’ (“string-from-double”), ‘strfromf’
|
(“string-from-float”), and ‘strfroml’ (“string-from-long-double”)
|
convert the floating-point number VALUE to a string of characters
|
and stores them into the area pointed to by STRING. The conversion
|
writes at most SIZE characters and respects the format specified by
|
FORMAT.
|
|
The format string must start with the character ‘%’. An optional
|
precision follows, which starts with a period, ‘.’, and may be
|
followed by a decimal integer, representing the precision. If a
|
decimal integer is not specified after the period, the precision is
|
taken to be zero. The character ‘*’ is not allowed. Finally, the
|
format string ends with one of the following conversion specifiers:
|
‘a’, ‘A’, ‘e’, ‘E’, ‘f’, ‘F’, ‘g’ or ‘G’ (*note Table of Output
|
Conversions::). Invalid format strings result in undefined
|
behavior.
|
|
These functions return the number of characters that would have
|
been written to STRING had SIZE been sufficiently large, not
|
counting the terminating null character. Thus, the null-terminated
|
output has been completely written if and only if the returned
|
value is less than SIZE.
|
|
These functions were introduced by ISO/IEC TS 18661-1.
|
|
|
File: libc.info, Node: System V Number Conversion, Prev: Printing of Floats, Up: Arithmetic
|
|
20.13 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:
|
|
‘time_t 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:
|
|
‘time_t 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 (struct timeval *result, struct timeval *x, struct timeval *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.
|
