This is libc.info, produced by makeinfo version 5.1 from libc.texinfo.
|
|
This is ‘The GNU C Library Reference Manual’, for version 2.33 (GNU).
|
|
Copyright © 1993–2021 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.
|
* CHAR_BIT: (libc)Width of Type.
|
* CHILD_MAX: (libc)General Limits.
|
* CIGNORE: (libc)Control Modes.
|
* CLK_TCK: (libc)Processor Time.
|
* CLOCAL: (libc)Control Modes.
|
* CLOCKS_PER_SEC: (libc)CPU Time.
|
* CLOCK_MONOTONIC: (libc)Getting the Time.
|
* CLOCK_REALTIME: (libc)Getting the Time.
|
* COLL_WEIGHTS_MAX: (libc)Utility Limits.
|
* CPU_CLR: (libc)CPU Affinity.
|
* CPU_FEATURE_USABLE: (libc)X86.
|
* 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.
|
* 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.
|
* HAS_CPU_FEATURE: (libc)X86.
|
* HUGE_VAL: (libc)Math Error Reporting.
|
* HUGE_VALF: (libc)Math Error Reporting.
|
* HUGE_VALL: (libc)Math Error Reporting.
|
* HUGE_VAL_FN: (libc)Math Error Reporting.
|
* HUGE_VAL_FNx: (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_DIRECTORY: (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_NOFOLLOW: (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_PATH: (libc)Access Modes.
|
* 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_TMPFILE: (libc)Open-time Flags.
|
* 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.
|
* PTHREAD_ATTR_NO_SIGMASK_NP: (libc)Initial Thread Signal Mask.
|
* 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.
|
* SNANFN: (libc)Infinity and NaN.
|
* SNANFNx: (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.
|
* __riscv_flush_icache: (libc)RISC-V.
|
* __va_copy: (libc)Argument Macros.
|
* __x86_get_cpuid_feature_leaf: (libc)X86.
|
* _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.
|
* acosfN: (libc)Inverse Trig Functions.
|
* acosfNx: (libc)Inverse Trig Functions.
|
* acosh: (libc)Hyperbolic Functions.
|
* acoshf: (libc)Hyperbolic Functions.
|
* acoshfN: (libc)Hyperbolic Functions.
|
* acoshfNx: (libc)Hyperbolic Functions.
|
* acoshl: (libc)Hyperbolic Functions.
|
* acosl: (libc)Inverse Trig Functions.
|
* addmntent: (libc)mtab.
|
* addseverity: (libc)Adding Severity Classes.
|
* adjtime: (libc)Setting and Adjusting the Time.
|
* adjtimex: (libc)Setting and Adjusting the Time.
|
* 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.
|
* asinfN: (libc)Inverse Trig Functions.
|
* asinfNx: (libc)Inverse Trig Functions.
|
* asinh: (libc)Hyperbolic Functions.
|
* asinhf: (libc)Hyperbolic Functions.
|
* asinhfN: (libc)Hyperbolic Functions.
|
* asinhfNx: (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.
|
* atan2fN: (libc)Inverse Trig Functions.
|
* atan2fNx: (libc)Inverse Trig Functions.
|
* atan2l: (libc)Inverse Trig Functions.
|
* atan: (libc)Inverse Trig Functions.
|
* atanf: (libc)Inverse Trig Functions.
|
* atanfN: (libc)Inverse Trig Functions.
|
* atanfNx: (libc)Inverse Trig Functions.
|
* atanh: (libc)Hyperbolic Functions.
|
* atanhf: (libc)Hyperbolic Functions.
|
* atanhfN: (libc)Hyperbolic Functions.
|
* atanhfNx: (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.
|
* cabsfN: (libc)Absolute Value.
|
* cabsfNx: (libc)Absolute Value.
|
* cabsl: (libc)Absolute Value.
|
* cacos: (libc)Inverse Trig Functions.
|
* cacosf: (libc)Inverse Trig Functions.
|
* cacosfN: (libc)Inverse Trig Functions.
|
* cacosfNx: (libc)Inverse Trig Functions.
|
* cacosh: (libc)Hyperbolic Functions.
|
* cacoshf: (libc)Hyperbolic Functions.
|
* cacoshfN: (libc)Hyperbolic Functions.
|
* cacoshfNx: (libc)Hyperbolic Functions.
|
* cacoshl: (libc)Hyperbolic Functions.
|
* cacosl: (libc)Inverse Trig Functions.
|
* call_once: (libc)Call Once.
|
* calloc: (libc)Allocating Cleared Space.
|
* canonicalize: (libc)FP Bit Twiddling.
|
* canonicalize_file_name: (libc)Symbolic Links.
|
* canonicalizef: (libc)FP Bit Twiddling.
|
* canonicalizefN: (libc)FP Bit Twiddling.
|
* canonicalizefNx: (libc)FP Bit Twiddling.
|
* canonicalizel: (libc)FP Bit Twiddling.
|
* carg: (libc)Operations on Complex.
|
* cargf: (libc)Operations on Complex.
|
* cargfN: (libc)Operations on Complex.
|
* cargfNx: (libc)Operations on Complex.
|
* cargl: (libc)Operations on Complex.
|
* casin: (libc)Inverse Trig Functions.
|
* casinf: (libc)Inverse Trig Functions.
|
* casinfN: (libc)Inverse Trig Functions.
|
* casinfNx: (libc)Inverse Trig Functions.
|
* casinh: (libc)Hyperbolic Functions.
|
* casinhf: (libc)Hyperbolic Functions.
|
* casinhfN: (libc)Hyperbolic Functions.
|
* casinhfNx: (libc)Hyperbolic Functions.
|
* casinhl: (libc)Hyperbolic Functions.
|
* casinl: (libc)Inverse Trig Functions.
|
* catan: (libc)Inverse Trig Functions.
|
* catanf: (libc)Inverse Trig Functions.
|
* catanfN: (libc)Inverse Trig Functions.
|
* catanfNx: (libc)Inverse Trig Functions.
|
* catanh: (libc)Hyperbolic Functions.
|
* catanhf: (libc)Hyperbolic Functions.
|
* catanhfN: (libc)Hyperbolic Functions.
|
* catanhfNx: (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.
|
* cbrt: (libc)Exponents and Logarithms.
|
* cbrtf: (libc)Exponents and Logarithms.
|
* cbrtfN: (libc)Exponents and Logarithms.
|
* cbrtfNx: (libc)Exponents and Logarithms.
|
* cbrtl: (libc)Exponents and Logarithms.
|
* ccos: (libc)Trig Functions.
|
* ccosf: (libc)Trig Functions.
|
* ccosfN: (libc)Trig Functions.
|
* ccosfNx: (libc)Trig Functions.
|
* ccosh: (libc)Hyperbolic Functions.
|
* ccoshf: (libc)Hyperbolic Functions.
|
* ccoshfN: (libc)Hyperbolic Functions.
|
* ccoshfNx: (libc)Hyperbolic Functions.
|
* ccoshl: (libc)Hyperbolic Functions.
|
* ccosl: (libc)Trig Functions.
|
* ceil: (libc)Rounding Functions.
|
* ceilf: (libc)Rounding Functions.
|
* ceilfN: (libc)Rounding Functions.
|
* ceilfNx: (libc)Rounding Functions.
|
* ceill: (libc)Rounding Functions.
|
* cexp: (libc)Exponents and Logarithms.
|
* cexpf: (libc)Exponents and Logarithms.
|
* cexpfN: (libc)Exponents and Logarithms.
|
* cexpfNx: (libc)Exponents and Logarithms.
|
* cexpl: (libc)Exponents and Logarithms.
|
* cfgetispeed: (libc)Line Speed.
|
* cfgetospeed: (libc)Line Speed.
|
* cfmakeraw: (libc)Noncanonical Input.
|
* 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.
|
* cimagfN: (libc)Operations on Complex.
|
* cimagfNx: (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.
|
* clock_getres: (libc)Getting the Time.
|
* clock_gettime: (libc)Getting the Time.
|
* clock_settime: (libc)Setting and Adjusting the Time.
|
* clog10: (libc)Exponents and Logarithms.
|
* clog10f: (libc)Exponents and Logarithms.
|
* clog10fN: (libc)Exponents and Logarithms.
|
* clog10fNx: (libc)Exponents and Logarithms.
|
* clog10l: (libc)Exponents and Logarithms.
|
* clog: (libc)Exponents and Logarithms.
|
* clogf: (libc)Exponents and Logarithms.
|
* clogfN: (libc)Exponents and Logarithms.
|
* clogfNx: (libc)Exponents and Logarithms.
|
* clogl: (libc)Exponents and Logarithms.
|
* close: (libc)Opening and Closing Files.
|
* closedir: (libc)Reading/Closing Directory.
|
* closelog: (libc)closelog.
|
* cnd_broadcast: (libc)ISO C Condition Variables.
|
* cnd_destroy: (libc)ISO C Condition Variables.
|
* cnd_init: (libc)ISO C Condition Variables.
|
* cnd_signal: (libc)ISO C Condition Variables.
|
* cnd_timedwait: (libc)ISO C Condition Variables.
|
* cnd_wait: (libc)ISO C Condition Variables.
|
* confstr: (libc)String Parameters.
|
* conj: (libc)Operations on Complex.
|
* conjf: (libc)Operations on Complex.
|
* conjfN: (libc)Operations on Complex.
|
* conjfNx: (libc)Operations on Complex.
|
* conjl: (libc)Operations on Complex.
|
* connect: (libc)Connecting.
|
* copy_file_range: (libc)Copying File Data.
|
* copysign: (libc)FP Bit Twiddling.
|
* copysignf: (libc)FP Bit Twiddling.
|
* copysignfN: (libc)FP Bit Twiddling.
|
* copysignfNx: (libc)FP Bit Twiddling.
|
* copysignl: (libc)FP Bit Twiddling.
|
* cos: (libc)Trig Functions.
|
* cosf: (libc)Trig Functions.
|
* cosfN: (libc)Trig Functions.
|
* cosfNx: (libc)Trig Functions.
|
* cosh: (libc)Hyperbolic Functions.
|
* coshf: (libc)Hyperbolic Functions.
|
* coshfN: (libc)Hyperbolic Functions.
|
* coshfNx: (libc)Hyperbolic Functions.
|
* coshl: (libc)Hyperbolic Functions.
|
* cosl: (libc)Trig Functions.
|
* cpow: (libc)Exponents and Logarithms.
|
* cpowf: (libc)Exponents and Logarithms.
|
* cpowfN: (libc)Exponents and Logarithms.
|
* cpowfNx: (libc)Exponents and Logarithms.
|
* cpowl: (libc)Exponents and Logarithms.
|
* cproj: (libc)Operations on Complex.
|
* cprojf: (libc)Operations on Complex.
|
* cprojfN: (libc)Operations on Complex.
|
* cprojfNx: (libc)Operations on Complex.
|
* cprojl: (libc)Operations on Complex.
|
* creal: (libc)Operations on Complex.
|
* crealf: (libc)Operations on Complex.
|
* crealfN: (libc)Operations on Complex.
|
* crealfNx: (libc)Operations on Complex.
|
* creall: (libc)Operations on Complex.
|
* creat64: (libc)Opening and Closing Files.
|
* creat: (libc)Opening and Closing Files.
|
* crypt: (libc)Passphrase Storage.
|
* crypt_r: (libc)Passphrase Storage.
|
* csin: (libc)Trig Functions.
|
* csinf: (libc)Trig Functions.
|
* csinfN: (libc)Trig Functions.
|
* csinfNx: (libc)Trig Functions.
|
* csinh: (libc)Hyperbolic Functions.
|
* csinhf: (libc)Hyperbolic Functions.
|
* csinhfN: (libc)Hyperbolic Functions.
|
* csinhfNx: (libc)Hyperbolic Functions.
|
* csinhl: (libc)Hyperbolic Functions.
|
* csinl: (libc)Trig Functions.
|
* csqrt: (libc)Exponents and Logarithms.
|
* csqrtf: (libc)Exponents and Logarithms.
|
* csqrtfN: (libc)Exponents and Logarithms.
|
* csqrtfNx: (libc)Exponents and Logarithms.
|
* csqrtl: (libc)Exponents and Logarithms.
|
* ctan: (libc)Trig Functions.
|
* ctanf: (libc)Trig Functions.
|
* ctanfN: (libc)Trig Functions.
|
* ctanfNx: (libc)Trig Functions.
|
* ctanh: (libc)Hyperbolic Functions.
|
* ctanhf: (libc)Hyperbolic Functions.
|
* ctanhfN: (libc)Hyperbolic Functions.
|
* ctanhfNx: (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.
|
* daddl: (libc)Misc FP Arithmetic.
|
* dcgettext: (libc)Translation with gettext.
|
* dcngettext: (libc)Advanced gettext functions.
|
* ddivl: (libc)Misc FP Arithmetic.
|
* dgettext: (libc)Translation with gettext.
|
* difftime: (libc)Calculating Elapsed Time.
|
* dirfd: (libc)Opening a Directory.
|
* dirname: (libc)Finding Tokens in a String.
|
* div: (libc)Integer Division.
|
* dmull: (libc)Misc FP Arithmetic.
|
* 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.
|
* dsubl: (libc)Misc FP Arithmetic.
|
* dup2: (libc)Duplicating Descriptors.
|
* dup: (libc)Duplicating Descriptors.
|
* ecvt: (libc)System V Number Conversion.
|
* ecvt_r: (libc)System V Number Conversion.
|
* 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.
|
* erfcfN: (libc)Special Functions.
|
* erfcfNx: (libc)Special Functions.
|
* erfcl: (libc)Special Functions.
|
* erff: (libc)Special Functions.
|
* erffN: (libc)Special Functions.
|
* erffNx: (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.
|
* exp10fN: (libc)Exponents and Logarithms.
|
* exp10fNx: (libc)Exponents and Logarithms.
|
* exp10l: (libc)Exponents and Logarithms.
|
* exp2: (libc)Exponents and Logarithms.
|
* exp2f: (libc)Exponents and Logarithms.
|
* exp2fN: (libc)Exponents and Logarithms.
|
* exp2fNx: (libc)Exponents and Logarithms.
|
* exp2l: (libc)Exponents and Logarithms.
|
* exp: (libc)Exponents and Logarithms.
|
* expf: (libc)Exponents and Logarithms.
|
* expfN: (libc)Exponents and Logarithms.
|
* expfNx: (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.
|
* expm1fN: (libc)Exponents and Logarithms.
|
* expm1fNx: (libc)Exponents and Logarithms.
|
* expm1l: (libc)Exponents and Logarithms.
|
* fMaddfN: (libc)Misc FP Arithmetic.
|
* fMaddfNx: (libc)Misc FP Arithmetic.
|
* fMdivfN: (libc)Misc FP Arithmetic.
|
* fMdivfNx: (libc)Misc FP Arithmetic.
|
* fMmulfN: (libc)Misc FP Arithmetic.
|
* fMmulfNx: (libc)Misc FP Arithmetic.
|
* fMsubfN: (libc)Misc FP Arithmetic.
|
* fMsubfNx: (libc)Misc FP Arithmetic.
|
* fMxaddfN: (libc)Misc FP Arithmetic.
|
* fMxaddfNx: (libc)Misc FP Arithmetic.
|
* fMxdivfN: (libc)Misc FP Arithmetic.
|
* fMxdivfNx: (libc)Misc FP Arithmetic.
|
* fMxmulfN: (libc)Misc FP Arithmetic.
|
* fMxmulfNx: (libc)Misc FP Arithmetic.
|
* fMxsubfN: (libc)Misc FP Arithmetic.
|
* fMxsubfNx: (libc)Misc FP Arithmetic.
|
* fabs: (libc)Absolute Value.
|
* fabsf: (libc)Absolute Value.
|
* fabsfN: (libc)Absolute Value.
|
* fabsfNx: (libc)Absolute Value.
|
* fabsl: (libc)Absolute Value.
|
* fadd: (libc)Misc FP Arithmetic.
|
* faddl: (libc)Misc FP Arithmetic.
|
* 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.
|
* fdimfN: (libc)Misc FP Arithmetic.
|
* fdimfNx: (libc)Misc FP Arithmetic.
|
* fdiml: (libc)Misc FP Arithmetic.
|
* fdiv: (libc)Misc FP Arithmetic.
|
* fdivl: (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.
|
* fexecve: (libc)Executing a File.
|
* 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.
|
* floorfN: (libc)Rounding Functions.
|
* floorfNx: (libc)Rounding Functions.
|
* floorl: (libc)Rounding Functions.
|
* fma: (libc)Misc FP Arithmetic.
|
* fmaf: (libc)Misc FP Arithmetic.
|
* fmafN: (libc)Misc FP Arithmetic.
|
* fmafNx: (libc)Misc FP Arithmetic.
|
* fmal: (libc)Misc FP Arithmetic.
|
* fmax: (libc)Misc FP Arithmetic.
|
* fmaxf: (libc)Misc FP Arithmetic.
|
* fmaxfN: (libc)Misc FP Arithmetic.
|
* fmaxfNx: (libc)Misc FP Arithmetic.
|
* fmaxl: (libc)Misc FP Arithmetic.
|
* fmaxmag: (libc)Misc FP Arithmetic.
|
* fmaxmagf: (libc)Misc FP Arithmetic.
|
* fmaxmagfN: (libc)Misc FP Arithmetic.
|
* fmaxmagfNx: (libc)Misc FP Arithmetic.
|
* fmaxmagl: (libc)Misc FP Arithmetic.
|
* fmemopen: (libc)String Streams.
|
* fmin: (libc)Misc FP Arithmetic.
|
* fminf: (libc)Misc FP Arithmetic.
|
* fminfN: (libc)Misc FP Arithmetic.
|
* fminfNx: (libc)Misc FP Arithmetic.
|
* fminl: (libc)Misc FP Arithmetic.
|
* fminmag: (libc)Misc FP Arithmetic.
|
* fminmagf: (libc)Misc FP Arithmetic.
|
* fminmagfN: (libc)Misc FP Arithmetic.
|
* fminmagfNx: (libc)Misc FP Arithmetic.
|
* fminmagl: (libc)Misc FP Arithmetic.
|
* fmod: (libc)Remainder Functions.
|
* fmodf: (libc)Remainder Functions.
|
* fmodfN: (libc)Remainder Functions.
|
* fmodfNx: (libc)Remainder Functions.
|
* fmodl: (libc)Remainder Functions.
|
* fmtmsg: (libc)Printing Formatted Messages.
|
* fmul: (libc)Misc FP Arithmetic.
|
* fmull: (libc)Misc FP Arithmetic.
|
* 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.
|
* frexpfN: (libc)Normalization Functions.
|
* frexpfNx: (libc)Normalization Functions.
|
* frexpl: (libc)Normalization Functions.
|
* fromfp: (libc)Rounding Functions.
|
* fromfpf: (libc)Rounding Functions.
|
* fromfpfN: (libc)Rounding Functions.
|
* fromfpfNx: (libc)Rounding Functions.
|
* fromfpl: (libc)Rounding Functions.
|
* fromfpx: (libc)Rounding Functions.
|
* fromfpxf: (libc)Rounding Functions.
|
* fromfpxfN: (libc)Rounding Functions.
|
* fromfpxfNx: (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.
|
* fsub: (libc)Misc FP Arithmetic.
|
* fsubl: (libc)Misc FP Arithmetic.
|
* 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.
|
* getcpu: (libc)CPU Affinity.
|
* getcwd: (libc)Working Directory.
|
* getdate: (libc)General Time String Parsing.
|
* getdate_r: (libc)General Time String Parsing.
|
* getdelim: (libc)Line Input.
|
* getdents64: (libc)Low-level Directory Access.
|
* 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.
|
* getpayloadfN: (libc)FP Bit Twiddling.
|
* getpayloadfNx: (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.
|
* gettid: (libc)Process Identification.
|
* gettimeofday: (libc)Getting the Time.
|
* 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.
|
* hypotfN: (libc)Exponents and Logarithms.
|
* hypotfNx: (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.
|
* ilogbfN: (libc)Exponents and Logarithms.
|
* ilogbfNx: (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.
|
* j0fN: (libc)Special Functions.
|
* j0fNx: (libc)Special Functions.
|
* j0l: (libc)Special Functions.
|
* j1: (libc)Special Functions.
|
* j1f: (libc)Special Functions.
|
* j1fN: (libc)Special Functions.
|
* j1fNx: (libc)Special Functions.
|
* j1l: (libc)Special Functions.
|
* jn: (libc)Special Functions.
|
* jnf: (libc)Special Functions.
|
* jnfN: (libc)Special Functions.
|
* jnfNx: (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.
|
* ldexpfN: (libc)Normalization Functions.
|
* ldexpfNx: (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.
|
* lgammafN: (libc)Special Functions.
|
* lgammafN_r: (libc)Special Functions.
|
* lgammafNx: (libc)Special Functions.
|
* lgammafNx_r: (libc)Special Functions.
|
* lgammaf_r: (libc)Special Functions.
|
* lgammal: (libc)Special Functions.
|
* lgammal_r: (libc)Special Functions.
|
* link: (libc)Hard Links.
|
* linkat: (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.
|
* llogbfN: (libc)Exponents and Logarithms.
|
* llogbfNx: (libc)Exponents and Logarithms.
|
* llogbl: (libc)Exponents and Logarithms.
|
* llrint: (libc)Rounding Functions.
|
* llrintf: (libc)Rounding Functions.
|
* llrintfN: (libc)Rounding Functions.
|
* llrintfNx: (libc)Rounding Functions.
|
* llrintl: (libc)Rounding Functions.
|
* llround: (libc)Rounding Functions.
|
* llroundf: (libc)Rounding Functions.
|
* llroundfN: (libc)Rounding Functions.
|
* llroundfNx: (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.
|
* log10fN: (libc)Exponents and Logarithms.
|
* log10fNx: (libc)Exponents and Logarithms.
|
* log10l: (libc)Exponents and Logarithms.
|
* log1p: (libc)Exponents and Logarithms.
|
* log1pf: (libc)Exponents and Logarithms.
|
* log1pfN: (libc)Exponents and Logarithms.
|
* log1pfNx: (libc)Exponents and Logarithms.
|
* log1pl: (libc)Exponents and Logarithms.
|
* log2: (libc)Exponents and Logarithms.
|
* log2f: (libc)Exponents and Logarithms.
|
* log2fN: (libc)Exponents and Logarithms.
|
* log2fNx: (libc)Exponents and Logarithms.
|
* log2l: (libc)Exponents and Logarithms.
|
* log: (libc)Exponents and Logarithms.
|
* logb: (libc)Exponents and Logarithms.
|
* logbf: (libc)Exponents and Logarithms.
|
* logbfN: (libc)Exponents and Logarithms.
|
* logbfNx: (libc)Exponents and Logarithms.
|
* logbl: (libc)Exponents and Logarithms.
|
* logf: (libc)Exponents and Logarithms.
|
* logfN: (libc)Exponents and Logarithms.
|
* logfNx: (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.
|
* lrintfN: (libc)Rounding Functions.
|
* lrintfNx: (libc)Rounding Functions.
|
* lrintl: (libc)Rounding Functions.
|
* lround: (libc)Rounding Functions.
|
* lroundf: (libc)Rounding Functions.
|
* lroundfN: (libc)Rounding Functions.
|
* lroundfNx: (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.
|
* mallinfo2: (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.
|
* memfd_create: (libc)Memory-mapped I/O.
|
* memfrob: (libc)Obfuscating Data.
|
* 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.
|
* mlock2: (libc)Page Lock Functions.
|
* 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.
|
* modffN: (libc)Rounding Functions.
|
* modffNx: (libc)Rounding Functions.
|
* modfl: (libc)Rounding Functions.
|
* mount: (libc)Mount-Unmount-Remount.
|
* mprobe: (libc)Heap Consistency Checking.
|
* mprotect: (libc)Memory Protection.
|
* 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.
|
* mtx_destroy: (libc)ISO C Mutexes.
|
* mtx_init: (libc)ISO C Mutexes.
|
* mtx_lock: (libc)ISO C Mutexes.
|
* mtx_timedlock: (libc)ISO C Mutexes.
|
* mtx_trylock: (libc)ISO C Mutexes.
|
* mtx_unlock: (libc)ISO C Mutexes.
|
* 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.
|
* nanfN: (libc)FP Bit Twiddling.
|
* nanfNx: (libc)FP Bit Twiddling.
|
* nanl: (libc)FP Bit Twiddling.
|
* nanosleep: (libc)Sleeping.
|
* nearbyint: (libc)Rounding Functions.
|
* nearbyintf: (libc)Rounding Functions.
|
* nearbyintfN: (libc)Rounding Functions.
|
* nearbyintfNx: (libc)Rounding Functions.
|
* nearbyintl: (libc)Rounding Functions.
|
* nextafter: (libc)FP Bit Twiddling.
|
* nextafterf: (libc)FP Bit Twiddling.
|
* nextafterfN: (libc)FP Bit Twiddling.
|
* nextafterfNx: (libc)FP Bit Twiddling.
|
* nextafterl: (libc)FP Bit Twiddling.
|
* nextdown: (libc)FP Bit Twiddling.
|
* nextdownf: (libc)FP Bit Twiddling.
|
* nextdownfN: (libc)FP Bit Twiddling.
|
* nextdownfNx: (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.
|
* nextupfN: (libc)FP Bit Twiddling.
|
* nextupfNx: (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)Setting and Adjusting the Time.
|
* ntp_gettime: (libc)Setting and Adjusting the Time.
|
* 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.
|
* pkey_alloc: (libc)Memory Protection.
|
* pkey_free: (libc)Memory Protection.
|
* pkey_get: (libc)Memory Protection.
|
* pkey_mprotect: (libc)Memory Protection.
|
* pkey_set: (libc)Memory Protection.
|
* popen: (libc)Pipe to a Subprocess.
|
* posix_fallocate64: (libc)Storage Allocation.
|
* posix_fallocate: (libc)Storage Allocation.
|
* posix_memalign: (libc)Aligned Memory Blocks.
|
* pow: (libc)Exponents and Logarithms.
|
* powf: (libc)Exponents and Logarithms.
|
* powfN: (libc)Exponents and Logarithms.
|
* powfNx: (libc)Exponents and Logarithms.
|
* powl: (libc)Exponents and Logarithms.
|
* pread64: (libc)I/O Primitives.
|
* pread: (libc)I/O Primitives.
|
* preadv2: (libc)Scatter-Gather.
|
* preadv64: (libc)Scatter-Gather.
|
* preadv64v2: (libc)Scatter-Gather.
|
* preadv: (libc)Scatter-Gather.
|
* printf: (libc)Formatted Output Functions.
|
* printf_size: (libc)Predefined Printf Handlers.
|
* printf_size_info: (libc)Predefined Printf Handlers.
|
* psignal: (libc)Signal Messages.
|
* pthread_attr_getsigmask_np: (libc)Initial Thread Signal Mask.
|
* pthread_attr_setsigmask_np: (libc)Initial Thread Signal Mask.
|
* pthread_clockjoin_np: (libc)Waiting with Explicit Clocks.
|
* pthread_cond_clockwait: (libc)Waiting with Explicit Clocks.
|
* 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_rwlock_clockrdlock: (libc)Waiting with Explicit Clocks.
|
* pthread_rwlock_clockwrlock: (libc)Waiting with Explicit Clocks.
|
* pthread_setattr_default_np: (libc)Default Thread Attributes.
|
* pthread_setspecific: (libc)Thread-specific Data.
|
* pthread_timedjoin_np: (libc)Waiting with Explicit Clocks.
|
* pthread_tryjoin_np: (libc)Waiting with Explicit Clocks.
|
* 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.
|
* pwritev2: (libc)Scatter-Gather.
|
* pwritev64: (libc)Scatter-Gather.
|
* pwritev64v2: (libc)Scatter-Gather.
|
* pwritev: (libc)Scatter-Gather.
|
* 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.
|
* reallocarray: (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.
|
* remainderfN: (libc)Remainder Functions.
|
* remainderfNx: (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.
|
* rintfN: (libc)Rounding Functions.
|
* rintfNx: (libc)Rounding Functions.
|
* rintl: (libc)Rounding Functions.
|
* rmdir: (libc)Deleting Files.
|
* round: (libc)Rounding Functions.
|
* roundeven: (libc)Rounding Functions.
|
* roundevenf: (libc)Rounding Functions.
|
* roundevenfN: (libc)Rounding Functions.
|
* roundevenfNx: (libc)Rounding Functions.
|
* roundevenl: (libc)Rounding Functions.
|
* roundf: (libc)Rounding Functions.
|
* roundfN: (libc)Rounding Functions.
|
* roundfNx: (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.
|
* scalblnfN: (libc)Normalization Functions.
|
* scalblnfNx: (libc)Normalization Functions.
|
* scalblnl: (libc)Normalization Functions.
|
* scalbn: (libc)Normalization Functions.
|
* scalbnf: (libc)Normalization Functions.
|
* scalbnfN: (libc)Normalization Functions.
|
* scalbnfNx: (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_clockwait: (libc)Waiting with Explicit Clocks.
|
* 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.
|
* 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.
|
* setpayloadfN: (libc)FP Bit Twiddling.
|
* setpayloadfNx: (libc)FP Bit Twiddling.
|
* setpayloadl: (libc)FP Bit Twiddling.
|
* setpayloadsig: (libc)FP Bit Twiddling.
|
* setpayloadsigf: (libc)FP Bit Twiddling.
|
* setpayloadsigfN: (libc)FP Bit Twiddling.
|
* setpayloadsigfNx: (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)Setting and Adjusting the Time.
|
* 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.
|
* sigabbrev_np: (libc)Signal Messages.
|
* sigaction: (libc)Advanced Signal Handling.
|
* sigaddset: (libc)Signal Sets.
|
* sigaltstack: (libc)Signal Stack.
|
* sigblock: (libc)BSD Signal Handling.
|
* sigdelset: (libc)Signal Sets.
|
* sigdescr_np: (libc)Signal Messages.
|
* 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.
|
* sincosfN: (libc)Trig Functions.
|
* sincosfNx: (libc)Trig Functions.
|
* sincosl: (libc)Trig Functions.
|
* sinf: (libc)Trig Functions.
|
* sinfN: (libc)Trig Functions.
|
* sinfNx: (libc)Trig Functions.
|
* sinh: (libc)Hyperbolic Functions.
|
* sinhf: (libc)Hyperbolic Functions.
|
* sinhfN: (libc)Hyperbolic Functions.
|
* sinhfNx: (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.
|
* sqrtfN: (libc)Exponents and Logarithms.
|
* sqrtfNx: (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)Setting and Adjusting the 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.
|
* strerrordesc_np: (libc)Error Messages.
|
* strerrorname_np: (libc)Error Messages.
|
* strfmon: (libc)Formatting Numbers.
|
* strfromd: (libc)Printing of Floats.
|
* strfromf: (libc)Printing of Floats.
|
* strfromfN: (libc)Printing of Floats.
|
* strfromfNx: (libc)Printing of Floats.
|
* strfroml: (libc)Printing of Floats.
|
* strfry: (libc)Shuffling Bytes.
|
* 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.
|
* strtofN: (libc)Parsing of Floats.
|
* strtofNx: (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.
|
* syslog: (libc)syslog; vsyslog.
|
* system: (libc)Running a Command.
|
* sysv_signal: (libc)Basic Signal Handling.
|
* tan: (libc)Trig Functions.
|
* tanf: (libc)Trig Functions.
|
* tanfN: (libc)Trig Functions.
|
* tanfNx: (libc)Trig Functions.
|
* tanh: (libc)Hyperbolic Functions.
|
* tanhf: (libc)Hyperbolic Functions.
|
* tanhfN: (libc)Hyperbolic Functions.
|
* tanhfNx: (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.
|
* tgammafN: (libc)Special Functions.
|
* tgammafNx: (libc)Special Functions.
|
* tgammal: (libc)Special Functions.
|
* tgkill: (libc)Signaling Another Process.
|
* thrd_create: (libc)ISO C Thread Management.
|
* thrd_current: (libc)ISO C Thread Management.
|
* thrd_detach: (libc)ISO C Thread Management.
|
* thrd_equal: (libc)ISO C Thread Management.
|
* thrd_exit: (libc)ISO C Thread Management.
|
* thrd_join: (libc)ISO C Thread Management.
|
* thrd_sleep: (libc)ISO C Thread Management.
|
* thrd_yield: (libc)ISO C Thread Management.
|
* time: (libc)Getting the 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.
|
* totalorderfN: (libc)FP Comparison Functions.
|
* totalorderfNx: (libc)FP Comparison Functions.
|
* totalorderl: (libc)FP Comparison Functions.
|
* totalordermag: (libc)FP Comparison Functions.
|
* totalordermagf: (libc)FP Comparison Functions.
|
* totalordermagfN: (libc)FP Comparison Functions.
|
* totalordermagfNx: (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.
|
* truncfN: (libc)Rounding Functions.
|
* truncfNx: (libc)Rounding Functions.
|
* truncl: (libc)Rounding Functions.
|
* tsearch: (libc)Tree Search Function.
|
* tss_create: (libc)ISO C Thread-local Storage.
|
* tss_delete: (libc)ISO C Thread-local Storage.
|
* tss_get: (libc)ISO C Thread-local Storage.
|
* tss_set: (libc)ISO C Thread-local Storage.
|
* ttyname: (libc)Is It a Terminal.
|
* ttyname_r: (libc)Is It a Terminal.
|
* twalk: (libc)Tree Search Function.
|
* twalk_r: (libc)Tree Search Function.
|
* tzset: (libc)Time Zone Functions.
|
* ufromfp: (libc)Rounding Functions.
|
* ufromfpf: (libc)Rounding Functions.
|
* ufromfpfN: (libc)Rounding Functions.
|
* ufromfpfNx: (libc)Rounding Functions.
|
* ufromfpl: (libc)Rounding Functions.
|
* ufromfpx: (libc)Rounding Functions.
|
* ufromfpxf: (libc)Rounding Functions.
|
* ufromfpxfN: (libc)Rounding Functions.
|
* ufromfpxfNx: (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.
|
* 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.
|
* wcstofN: (libc)Parsing of Floats.
|
* wcstofNx: (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.
|
* y0fN: (libc)Special Functions.
|
* y0fNx: (libc)Special Functions.
|
* y0l: (libc)Special Functions.
|
* y1: (libc)Special Functions.
|
* y1f: (libc)Special Functions.
|
* y1fN: (libc)Special Functions.
|
* y1fNx: (libc)Special Functions.
|
* y1l: (libc)Special Functions.
|
* yn: (libc)Special Functions.
|
* ynf: (libc)Special Functions.
|
* ynfN: (libc)Special Functions.
|
* ynfNx: (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.
|
|
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 neither infinite nor
|
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.
|
|
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
|
-- Macro: _FloatN SNANFN
|
-- Macro: _FloatNx SNANFNx
|
|
These macros, defined by TS 18661-1:2014 and TS 18661-3:2015, 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
|
-- Macro: _FloatN HUGE_VAL_FN
|
-- Macro: _FloatNx HUGE_VAL_FNx
|
|
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’; the ‘fabs’ functions are declared in
|
‘math.h’; the ‘cabs’ functions 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)
|
-- Function: _FloatN fabsfN (_FloatN NUMBER)
|
-- Function: _FloatNx fabsfNx (_FloatNx 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)
|
-- Function: _FloatN cabsfN (complex _FloatN Z)
|
-- Function: _FloatNx cabsfNx (complex _FloatNx 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)
|
-- Function: _FloatN frexpfN (_FloatN VALUE, int *EXPONENT)
|
-- Function: _FloatNx frexpfNx (_FloatNx 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)
|
-- Function: _FloatN ldexpfN (_FloatN VALUE, int EXPONENT)
|
-- Function: _FloatNx ldexpfNx (_FloatNx 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. The ‘_FloatN’ and
|
‘_FloatN’ variants of the following functions come from TS 18661-3:2015.
|
|
-- 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)
|
-- Function: _FloatN scalbnfN (_FloatN X, int N)
|
-- Function: _FloatNx scalbnfNx (_FloatNx 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)
|
-- Function: _FloatN scalblnfN (_FloatN X, long int N)
|
-- Function: _FloatNx scalblnfNx (_FloatNx 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)
|
-- Function: _FloatN ceilfN (_FloatN X)
|
-- Function: _FloatNx ceilfNx (_FloatNx 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)
|
-- Function: _FloatN floorfN (_FloatN X)
|
-- Function: _FloatNx floorfNx (_FloatNx 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)
|
-- Function: _FloatN truncfN (_FloatN X)
|
-- Function: _FloatNx truncfNx (_FloatNx 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)
|
-- Function: _FloatN rintfN (_FloatN X)
|
-- Function: _FloatNx rintfNx (_FloatNx 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)
|
-- Function: _FloatN nearbyintfN (_FloatN X)
|
-- Function: _FloatNx nearbyintfNx (_FloatNx 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)
|
-- Function: _FloatN roundfN (_FloatN X)
|
-- Function: _FloatNx roundfNx (_FloatNx 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)
|
-- Function: _FloatN roundevenfN (_FloatN X)
|
-- Function: _FloatNx roundevenfNx (_FloatNx X)
|
|
Preliminary: | MT-Safe | AS-Safe | AC-Safe | *Note POSIX Safety
|
Concepts::.
|
|
These functions, from TS 18661-1:2014 and TS 18661-3:2015, 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)
|
-- Function: long int lrintfN (_FloatN X)
|
-- Function: long int lrintfNx (_FloatNx 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)
|
-- Function: long long int llrintfN (_FloatN X)
|
-- Function: long long int llrintfNx (_FloatNx 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)
|
-- Function: long int lroundfN (_FloatN X)
|
-- Function: long int lroundfNx (_FloatNx 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)
|
-- Function: long long int llroundfN (_FloatN X)
|
-- Function: long long int llroundfNx (_FloatNx 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: intmax_t fromfpfN (_FloatN X, int ROUND, unsigned int
|
WIDTH)
|
-- Function: intmax_t fromfpfNx (_FloatNx 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: uintmax_t ufromfpfN (_FloatN X, int ROUND, unsigned int
|
WIDTH)
|
-- Function: uintmax_t ufromfpfNx (_FloatNx 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: intmax_t fromfpxfN (_FloatN X, int ROUND, unsigned int
|
WIDTH)
|
-- Function: intmax_t fromfpxfNx (_FloatNx 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)
|
-- Function: uintmax_t ufromfpxfN (_FloatN X, int ROUND, unsigned int
|
WIDTH)
|
-- Function: uintmax_t ufromfpxfNx (_FloatNx X, int ROUND, unsigned int
|
WIDTH)
|
|
Preliminary: | MT-Safe | AS-Safe | AC-Safe | *Note POSIX Safety
|
Concepts::.
|
|
These functions, from TS 18661-1:2014 and TS 18661-3:2015, 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)
|
-- Function: _FloatN modffN (_FloatN VALUE, _FloatN *INTEGER-PART)
|
-- Function: _FloatNx modffNx (_FloatNx VALUE, _FloatNx *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)
|
-- Function: _FloatN fmodfN (_FloatN NUMERATOR, _FloatN DENOMINATOR)
|
-- Function: _FloatNx fmodfNx (_FloatNx NUMERATOR, _FloatNx
|
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 remainder (double NUMERATOR, double DENOMINATOR)
|
-- Function: float remainderf (float NUMERATOR, float DENOMINATOR)
|
-- Function: long double remainderl (long double NUMERATOR, long double
|
DENOMINATOR)
|
-- Function: _FloatN remainderfN (_FloatN NUMERATOR, _FloatN
|
DENOMINATOR)
|
-- Function: _FloatNx remainderfNx (_FloatNx NUMERATOR, _FloatNx
|
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, ‘remainder (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 ‘remainder (NUMERATOR, DENOMINATOR)’
|
is always either DENOMINATOR, minus DENOMINATOR, or zero.
|
|
If DENOMINATOR is zero, ‘remainder’ 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::.
|
|
This function is another name for ‘remainder’.
|
|
|
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)
|
-- Function: _FloatN copysignfN (_FloatN X, _FloatN Y)
|
-- Function: _FloatNx copysignfNx (_FloatNx X, _FloatNx 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)
|
-- Function: _FloatN nextafterfN (_FloatN X, _FloatN Y)
|
-- Function: _FloatNx nextafterfNx (_FloatNx X, _FloatNx 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)
|
-- Function: _FloatN nextupfN (_FloatN X)
|
-- Function: _FloatNx nextupfNx (_FloatNx 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 and
|
TS 18661-3:2015. ‘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)
|
-- Function: _FloatN nextdownfN (_FloatN X)
|
-- Function: _FloatNx nextdownfNx (_FloatNx 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
|
and TS 18661-3:2015. ‘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)
|
-- Function: _FloatN nanfN (const char *TAGP)
|
-- Function: _FloatNx nanfNx (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)
|
-- Function: int canonicalizefN (_FloatN *CX, const _FloatN *X)
|
-- Function: int canonicalizefNx (_FloatNx *CX, const _FloatNx *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 and TS 18661-3:2015, 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)
|
-- Function: _FloatN getpayloadfN (const _FloatN *X)
|
-- Function: _FloatNx getpayloadfNx (const _FloatNx *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 and TS
|
18661-3:2015, 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 −1. They
|
raise no floating-point exceptions even for signaling NaNs. (The
|
return value of −1 for an argument that is not a NaN is specified
|
in C2x; the value was unspecified in TS 18661.)
|
|
-- Function: int setpayload (double *X, double PAYLOAD)
|
-- Function: int setpayloadf (float *X, float PAYLOAD)
|
-- Function: int setpayloadl (long double *X, long double PAYLOAD)
|
-- Function: int setpayloadfN (_FloatN *X, _FloatN PAYLOAD)
|
-- Function: int setpayloadfNx (_FloatNx *X, _FloatNx PAYLOAD)
|
|
Preliminary: | MT-Safe | AS-Safe | AC-Safe | *Note POSIX Safety
|
Concepts::.
|
|
These functions, defined by TS 18661-1:2014 and TS 18661-3:2015,
|
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)
|
-- Function: int setpayloadsigfN (_FloatN *X, _FloatN PAYLOAD)
|
-- Function: int setpayloadsigfNx (_FloatNx *X, _FloatNx PAYLOAD)
|
|
Preliminary: | MT-Safe | AS-Safe | AC-Safe | *Note POSIX Safety
|
Concepts::.
|
|
These functions, defined by TS 18661-1:2014 and TS 18661-3:2015,
|
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 (const double *X, const double *Y)
|
-- Function: int totalorderf (const float *X, const float *Y)
|
-- Function: int totalorderl (const long double *X, const long double
|
*Y)
|
-- Function: int totalorderfN (const _FloatN *X, const _FloatN *Y)
|
-- Function: int totalorderfNx (const _FloatNx *X, const _FloatNx *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 (const double *X, const double *Y)
|
-- Function: int totalordermagf (const float *X, const float *Y)
|
-- Function: int totalordermagl (const long double *X, const long
|
double *Y)
|
-- Function: int totalordermagfN (const _FloatN *X, const _FloatN *Y)
|
-- Function: int totalordermagfNx (const _FloatNx *X, const _FloatNx
|
*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)
|
-- Function: _FloatN fminfN (_FloatN X, _FloatN Y)
|
-- Function: _FloatNx fminfNx (_FloatNx X, _FloatNx 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)
|
-- Function: _FloatN fmaxfN (_FloatN X, _FloatN Y)
|
-- Function: _FloatNx fmaxfNx (_FloatNx X, _FloatNx 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)
|
-- Function: _FloatN fminmagfN (_FloatN X, _FloatN Y)
|
-- Function: _FloatNx fminmagfNx (_FloatNx X, _FloatNx Y)
|
|
Preliminary: | MT-Safe | AS-Safe | AC-Safe | *Note POSIX Safety
|
Concepts::.
|
|
These functions, from TS 18661-1:2014 and TS 18661-3:2015, 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)
|
-- Function: _FloatN fmaxmagfN (_FloatN X, _FloatN Y)
|
-- Function: _FloatNx fmaxmagfNx (_FloatNx X, _FloatNx 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)
|
-- Function: _FloatN fdimfN (_FloatN X, _FloatN Y)
|
-- Function: _FloatNx fdimfNx (_FloatNx X, _FloatNx 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)
|
-- Function: _FloatN fmafN (_FloatN X, _FloatN Y, _FloatN Z)
|
-- Function: _FloatNx fmafNx (_FloatNx X, _FloatNx Y, _FloatNx 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.
|
|
-- Function: float fadd (double X, double Y)
|
-- Function: float faddl (long double X, long double Y)
|
-- Function: double daddl (long double X, long double Y)
|
-- Function: _FloatM fMaddfN (_FloatN X, _FloatN Y)
|
-- Function: _FloatM fMaddfNx (_FloatNx X, _FloatNx Y)
|
-- Function: _FloatMx fMxaddfN (_FloatN X, _FloatN Y)
|
-- Function: _FloatMx fMxaddfNx (_FloatNx X, _FloatNx Y)
|
|
Preliminary: | MT-Safe | AS-Safe | AC-Safe | *Note POSIX Safety
|
Concepts::.
|
|
These functions, from TS 18661-1:2014 and TS 18661-3:2015, return X
|
+ Y, rounded once to the return type of the function without any
|
intermediate rounding to the type of the arguments.
|
|
-- Function: float fsub (double X, double Y)
|
-- Function: float fsubl (long double X, long double Y)
|
-- Function: double dsubl (long double X, long double Y)
|
-- Function: _FloatM fMsubfN (_FloatN X, _FloatN Y)
|
-- Function: _FloatM fMsubfNx (_FloatNx X, _FloatNx Y)
|
-- Function: _FloatMx fMxsubfN (_FloatN X, _FloatN Y)
|
-- Function: _FloatMx fMxsubfNx (_FloatNx X, _FloatNx Y)
|
|
Preliminary: | MT-Safe | AS-Safe | AC-Safe | *Note POSIX Safety
|
Concepts::.
|
|
These functions, from TS 18661-1:2014 and TS 18661-3:2015, return X
|
- Y, rounded once to the return type of the function without any
|
intermediate rounding to the type of the arguments.
|
|
-- Function: float fmul (double X, double Y)
|
-- Function: float fmull (long double X, long double Y)
|
-- Function: double dmull (long double X, long double Y)
|
-- Function: _FloatM fMmulfN (_FloatN X, _FloatN Y)
|
-- Function: _FloatM fMmulfNx (_FloatNx X, _FloatNx Y)
|
-- Function: _FloatMx fMxmulfN (_FloatN X, _FloatN Y)
|
-- Function: _FloatMx fMxmulfNx (_FloatNx X, _FloatNx Y)
|
|
Preliminary: | MT-Safe | AS-Safe | AC-Safe | *Note POSIX Safety
|
Concepts::.
|
|
These functions, from TS 18661-1:2014 and TS 18661-3:2015, return X
|
* Y, rounded once to the return type of the function without any
|
intermediate rounding to the type of the arguments.
|
|
-- Function: float fdiv (double X, double Y)
|
-- Function: float fdivl (long double X, long double Y)
|
-- Function: double ddivl (long double X, long double Y)
|
-- Function: _FloatM fMdivfN (_FloatN X, _FloatN Y)
|
-- Function: _FloatM fMdivfNx (_FloatNx X, _FloatNx Y)
|
-- Function: _FloatMx fMxdivfN (_FloatN X, _FloatN Y)
|
-- Function: _FloatMx fMxdivfNx (_FloatNx X, _FloatNx Y)
|
|
Preliminary: | MT-Safe | AS-Safe | AC-Safe | *Note POSIX Safety
|
Concepts::.
|
|
These functions, from TS 18661-1:2014 and TS 18661-3:2015, return X
|
/ Y, rounded once to the return type of the function without any
|
intermediate rounding to the type of the arguments.
|
|
|
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’.
|
|
Likewise, on machines that have support for ‘_FloatN’ or ‘_FloatNx’
|
enabled, the complex types ‘_FloatN complex’ and ‘_FloatNx complex’ are
|
also available if ‘complex.h’ has been included; *note Mathematics::.
|
|
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)
|
-- Function: _FloatN crealfN (complex _FloatN Z)
|
-- Function: _FloatNx crealfNx (complex _FloatNx 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)
|
-- Function: _FloatN cimagfN (complex _FloatN Z)
|
-- Function: _FloatNx cimagfNx (complex _FloatNx 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)
|
-- Function: complex _FloatN conjfN (complex _FloatN Z)
|
-- Function: complex _FloatNx conjfNx (complex _FloatNx 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)
|
-- Function: _FloatN cargfN (complex _FloatN Z)
|
-- Function: _FloatNx cargfNx (complex _FloatNx 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)
|
-- Function: complex _FloatN cprojfN (complex _FloatN Z)
|
-- Function: complex _FloatNx cprojfNx (complex _FloatNx 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 *restrict 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: _FloatN strtofN (const char *STRING, char **TAILPTR)
|
-- Function: _FloatNx strtofNx (const char *STRING, char **TAILPTR)
|
|
Preliminary: | MT-Safe locale | AS-Safe | AC-Safe | *Note POSIX
|
Safety Concepts::.
|
|
These functions are like ‘strtod’, except for the return type.
|
|
They were introduced in ISO/IEC TS 18661-3 and are available on
|
machines that support the related types; *note Mathematics::.
|
|
-- 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)
|
-- Function: _FloatN wcstofN (const wchar_t *STRING, wchar_t **TAILPTR)
|
-- Function: _FloatNx wcstofNx (const wchar_t *STRING, wchar_t
|
**TAILPTR)
|
|
Preliminary: | MT-Safe locale | AS-Safe | AC-Safe | *Note POSIX
|
Safety Concepts::.
|
|
The ‘wcstod’, ‘wcstof’, ‘wcstol’, ‘wcstofN’, and ‘wcstofNx’
|
functions are equivalent in nearly all aspects to the ‘strtod’,
|
‘strtof’, ‘strtold’, ‘strtofN’, and ‘strtofNx’ functions, but they
|
handle wide character strings.
|
|
The ‘wcstod’ function was introduced in Amendment 1 of ISO C90.
|
The ‘wcstof’ and ‘wcstold’ functions were introduced in ISO C99.
|
|
The ‘wcstofN’ and ‘wcstofNx’ functions are not in any standard, but
|
are added to provide completeness for the non-deprecated interface
|
of wide character string to floating-point conversion functions.
|
They are only available on machines that support the related types;
|
*note Mathematics::.
|
|
-- 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.
|
|
-- Function: int strfromfN (char *restrict STRING, size_t SIZE, const
|
char *restrict FORMAT, _FloatN VALUE)
|
-- Function: int strfromfNx (char *restrict STRING, size_t SIZE, const
|
char *restrict FORMAT, _FloatNx VALUE)
|
|
Preliminary: | MT-Safe locale | AS-Unsafe heap | AC-Unsafe mem |
|
*Note POSIX Safety Concepts::.
|
|
These functions are like ‘strfromd’, except for the type of
|
‘value’.
|
|
They were introduced in ISO/IEC TS 18661-3 and are available on
|
machines that support the related types; *note Mathematics::.
|
|
|
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.
|
* Time Types:: Data types to represent time.
|
* Calculating Elapsed Time:: How to calculate the length of an interval.
|
* 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: Time Types, 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.
|
|
A "simple calendar time" is a calendar time represented as an elapsed
|
time since a fixed, implementation-specific calendar time called the
|
"epoch". This representation is convenient for doing calculations on
|
calendar times, such as finding the elapsed time between two calendar
|
times. Simple calendar times are independent of time zone; they
|
represent the same instant in time regardless of where on the globe the
|
computer is.
|
|
POSIX says that simple calendar times do not include leap seconds,
|
but some (otherwise POSIX-conformant) systems can be configured to
|
include leap seconds in simple calendar times.
|
|
A "broken-down time" is a calendar time represented by its components
|
in the Gregorian calendar: year, month, day, hour, minute, and second.
|
A broken-down time value is relative to a specific time zone, and so it
|
is also sometimes called a "local time". Broken-down times are most
|
useful for input and output, as they are easier for people to
|
understand, but more difficult to calculate with.
|
|
"CPU time" measures the amount of time that a single process has
|
actively used a CPU to perform computations. It does not include the
|
time that process has spent waiting for external events. The system
|
tracks the CPU time used by each process separately.
|
|
"Processor time" measures the amount of time _any_ CPU has been in
|
use by _any_ process. It is a basic system resource, since there’s a
|
limit to how much can exist in any given interval (the elapsed time of
|
the interval times the number of CPUs in the computer)
|
|
People often call this CPU time, but we reserve the latter term in
|
this manual for the definition above.
|
|
|
File: libc.info, Node: Time Types, Next: Calculating Elapsed Time, Prev: Time Basics, Up: Date and Time
|
|
21.2 Time Types
|
===============
|
|
ISO C and POSIX define several data types for representing elapsed
|
times, simple calendar times, and broken-down times.
|
|
-- Data Type: clock_t
|
|
‘clock_t’ is used to measure processor and CPU time. It may be an
|
integer or a floating-point type. Its values are counts of "clock
|
ticks" since some arbitrary event in the past. The number of clock
|
ticks per second is system-specific. *Note Processor And CPU
|
Time::, for further detail.
|
|
-- Data Type: time_t
|
|
‘time_t’ is the simplest data type used to represent simple
|
calendar time.
|
|
In ISO C, ‘time_t’ can be either an integer or a floating-point
|
type, and the meaning of ‘time_t’ values is not specified. The
|
only things a strictly conforming program can do with ‘time_t’
|
values are: pass them to ‘difftime’ to get the elapsed time between
|
two simple calendar times (*note Calculating Elapsed Time::), and
|
pass them to the functions that convert them to broken-down time
|
(*note Broken-down Time::).
|
|
On POSIX-conformant systems, ‘time_t’ is an integer type and its
|
values represent the number of seconds elapsed since the "epoch",
|
which is 00:00:00 on January 1, 1970, Coordinated Universal Time.
|
|
The GNU C Library additionally guarantees that ‘time_t’ is a signed
|
type, and that all of its functions operate correctly on negative
|
‘time_t’ values, which are interpreted as times before the epoch.
|
|
-- Data Type: struct timespec
|
|
‘struct timespec’ represents a simple calendar time, or an elapsed
|
time, with sub-second resolution. It is declared in ‘time.h’ and
|
has the following members:
|
|
‘time_t tv_sec’
|
The number of whole seconds elapsed since the epoch (for a
|
simple calendar time) or since some other starting point (for
|
an elapsed time).
|
|
‘long int tv_nsec’
|
The number of nanoseconds elapsed since the time given by the
|
‘tv_sec’ member.
|
|
When ‘struct timespec’ values are produced by GNU C Library
|
functions, the value in this field will always be greater than
|
or equal to zero, and less than 1,000,000,000. When ‘struct
|
timespec’ values are supplied to GNU C Library functions, the
|
value in this field must be in the same range.
|
|
-- Data Type: struct timeval
|
|
‘struct timeval’ is an older type for representing a simple
|
calendar time, or an elapsed time, with sub-second resolution. It
|
is almost the same as ‘struct timespec’, but provides only
|
microsecond resolution. It is declared in ‘sys/time.h’ and has the
|
following members:
|
|
‘time_t tv_sec’
|
The number of whole seconds elapsed since the epoch (for a
|
simple calendar time) or since some other starting point (for
|
an elapsed time).
|
|
‘long int tv_usec’
|
The number of microseconds elapsed since the time given by the
|
‘tv_sec’ member.
|
|
When ‘struct timeval’ values are produced by GNU C Library
|
functions, the value in this field will always be greater than
|
or equal to zero, and less than 1,000,000. When ‘struct
|
timeval’ values are supplied to GNU C Library functions, the
|
value in this field must be in the same range.
|
|
-- Data Type: struct tm
|
|
This is the data type used to represent a broken-down time. It has
|
separate fields for year, month, day, and so on. *Note Broken-down
|
Time::, for further details.
|
|
|
File: libc.info, Node: Calculating Elapsed Time, Next: Processor And CPU Time, Prev: Time Types, Up: Date and Time
|
|
21.3 Calculating Elapsed Time
|
=============================
|
|
Often, one wishes to calculate an elapsed time as the difference between
|
two simple calendar times. The GNU C Library provides only one function
|
for this purpose.
|
|
-- Function: double difftime (time_t END, time_t BEGIN)
|
|
Preliminary: | MT-Safe | AS-Safe | AC-Safe | *Note POSIX Safety
|
Concepts::.
|
|
The ‘difftime’ function returns the number of seconds of elapsed
|
time from calendar time BEGIN to calendar time END, as a value of
|
type ‘double’.
|
|
On POSIX-conformant systems, the advantage of using ‘difftime (END,
|
BEGIN)’ over ‘END - BEGIN’ is that it will produce the
|
mathematically correct result even if END and BEGIN are so far
|
apart that a simple subtraction would overflow. However, if they
|
are so far apart that a ‘double’ cannot exactly represent the
|
difference, the result will be inexact.
|
|
On other systems, ‘time_t’ values might be encoded in a way that
|
prevents subtraction from working directly, and then ‘difftime’
|
would be the only way to compute their difference.
|
|
The GNU C Library does not provide any functions for computing the
|
difference between two values of type ‘struct timeval’ or
|
‘struct timespec’. Here is the recommended way to do this calculation
|
by hand. 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;
|
}
|
|
|
File: libc.info, Node: Processor And CPU Time, Next: Calendar Time, Prev: Calculating Elapsed Time, Up: Date and Time
|
|
21.4 Processor And CPU Time
|
===========================
|
|
If you’re trying to optimize your program or measure its efficiency,
|
it’s very useful to know how much processor time it uses. For that,
|
calendar time and elapsed times are useless because a process may spend
|
time waiting for I/O or for other processes to use the CPU. However, you
|
can get the information with the functions in this section.
|
|
CPU time (*note Time Basics::) is represented by the data type
|
‘clock_t’, which is a number of "clock ticks". It gives the total
|
amount of time a process has actively used a CPU since some arbitrary
|
event. On GNU systems, that event is the creation of the process.
|
While arbitrary in general, the event is always the same event for any
|
particular process, so you can always measure how much time on the CPU a
|
particular computation takes by examining the process’ CPU time before
|
and after the computation.
|
|
On GNU/Linux and GNU/Hurd systems, ‘clock_t’ is equivalent to ‘long
|
int’ and ‘CLOCKS_PER_SEC’ is an integer value. But in other systems,
|
both ‘clock_t’ and the macro ‘CLOCKS_PER_SEC’ can be either integer or
|
floating-point types. Casting CPU time values to ‘double’, as in the
|
example above, makes sure that operations such as arithmetic and
|
printing work properly and consistently no matter what the underlying
|
representation is.
|
|
Note that the clock can wrap around. On a 32bit system with
|
‘CLOCKS_PER_SEC’ set to one million this function will return the same
|
value approximately every 72 minutes.
|
|
For additional functions to examine a process’ use of processor time,
|
and to control it, see *note Resource Usage And Limitation::.
|
|
* Menu:
|
|
* CPU Time:: The ‘clock’ function.
|
* Processor Time:: The ‘times’ function.
|
|
|
File: libc.info, Node: CPU Time, Next: Processor Time, Up: Processor And CPU Time
|
|
21.4.1 CPU Time Inquiry
|
-----------------------
|
|
To get a process’ CPU time, you can use the ‘clock’ function. This
|
facility is declared in the header file ‘time.h’.
|
|
In typical usage, you call the ‘clock’ function at the beginning and
|
end of the interval you want to time, subtract the values, and then
|
divide by ‘CLOCKS_PER_SEC’ (the number of clock ticks per second) to get
|
processor time, like this:
|
|
#include <time.h>
|
|
clock_t start, end;
|
double cpu_time_used;
|
|
start = clock();
|
… /* Do the work. */
|
end = clock();
|
cpu_time_used = ((double) (end - start)) / CLOCKS_PER_SEC;
|
|
Do not use a single CPU time as an amount of time; it doesn’t work
|
that way. Either do a subtraction as shown above or query processor
|
time directly. *Note Processor Time::.
|
|
Different computers and operating systems vary wildly in how they
|
keep track of CPU time. It’s common for the internal processor clock to
|
have a resolution somewhere between a hundredth and millionth of a
|
second.
|
|
-- Macro: int CLOCKS_PER_SEC
|
|
The value of this macro is the number of clock ticks per second
|
measured by the ‘clock’ function. POSIX requires that this value
|
be one million independent of the actual resolution.
|
|
-- Function: clock_t clock (void)
|
|
Preliminary: | MT-Safe | AS-Safe | AC-Safe | *Note POSIX Safety
|
Concepts::.
|
|
This function returns the calling process’ current CPU time. If
|
the CPU time is not available or cannot be represented, ‘clock’
|
returns the value ‘(clock_t)(-1)’.
|
|
|
File: libc.info, Node: Processor Time, Prev: CPU Time, Up: Processor And CPU Time
|
|
21.4.2 Processor Time Inquiry
|
-----------------------------
|
|
The ‘times’ function returns information about a process’ consumption of
|
processor time in a ‘struct tms’ object, in addition to the process’ CPU
|
time. *Note Time Basics::. You should include the header file
|
‘sys/times.h’ to use this facility.
|
|
-- Data Type: struct tms
|
|
The ‘tms’ structure is used to return information about process
|
times. It contains at least the following members:
|
|
‘clock_t tms_utime’
|
This is the total processor time the calling process has used
|
in executing the instructions of its program.
|
|
‘clock_t tms_stime’
|
This is the processor time the system has used on behalf of
|
the calling process.
|
|
‘clock_t tms_cutime’
|
This is the sum of the ‘tms_utime’ values and the ‘tms_cutime’
|
values of all terminated child processes of the calling
|
process, whose status has been reported to the parent process
|
by ‘wait’ or ‘waitpid’; see *note Process Completion::. In
|
other words, it represents the total processor time used in
|
executing the instructions of all the terminated child
|
processes of the calling process, excluding child processes
|
which have not yet been reported by ‘wait’ or ‘waitpid’.
|
|
‘clock_t tms_cstime’
|
This is similar to ‘tms_cutime’, but represents the total
|
processor time the system has used on behalf of all the
|
terminated child processes of the calling process.
|
|
All of the times are given in numbers of clock ticks. Unlike CPU
|
time, these are the actual amounts of time; not relative to any
|
event. *Note Creating a Process::.
|
|
-- Macro: int CLK_TCK
|
|
This is an obsolete name for the number of clock ticks per second.
|
Use ‘sysconf (_SC_CLK_TCK)’ instead.
|
|
-- Function: clock_t times (struct tms *BUFFER)
|
|
Preliminary: | MT-Safe | AS-Safe | AC-Safe | *Note POSIX Safety
|
Concepts::.
|
|
The ‘times’ function stores the processor time information for the
|
calling process in BUFFER.
|
|
The return value is the number of clock ticks since an arbitrary
|
point in the past, e.g. since system start-up. ‘times’ returns
|
‘(clock_t)(-1)’ to indicate failure.
|
|
*Portability Note:* The ‘clock’ function described in *note CPU
|
Time:: is specified by the ISO C standard. The ‘times’ function is a
|
feature of POSIX.1. On GNU systems, the CPU time is defined to be
|
equivalent to the sum of the ‘tms_utime’ and ‘tms_stime’ fields returned
|
by ‘times’.
|
|
|
File: libc.info, Node: Calendar Time, Next: Setting an Alarm, Prev: Processor And CPU Time, Up: Date and Time
|
|
21.5 Calendar Time
|
==================
|
|
This section describes the functions for getting, setting, and
|
manipulating calendar times.
|
|
* Menu:
|
|
* Getting the Time:: Functions for finding out what time it is.
|
* Setting and Adjusting the Time::
|
Functions for setting and adjusting
|
the system clock.
|
* Broken-down Time:: Facilities for manipulating local time.
|
* Formatting Calendar Time:: Converting times to strings.
|
* Parsing Date and Time:: Convert textual time and date information back
|
into broken-down time values.
|
* TZ Variable:: How users specify the time zone.
|
* Time Zone Functions:: Functions to examine or specify the time zone.
|
* Time Functions Example:: An example program showing use of some of
|
the time functions.
|
|
|
File: libc.info, Node: Getting the Time, Next: Setting and Adjusting the Time, Up: Calendar Time
|
|
21.5.1 Getting the Time
|
-----------------------
|
|
The GNU C Library provides several functions for getting the current
|
calendar time, with different levels of resolution.
|
|
-- Function: time_t time (time_t *RESULT)
|
|
Preliminary: | MT-Safe | AS-Safe | AC-Safe | *Note POSIX Safety
|
Concepts::.
|
|
This is the simplest function for getting the current calendar
|
time. It returns the calendar time as a value of type ‘time_t’; on
|
POSIX systems, that means it has a resolution of one second. It
|
uses the same clock as ‘clock_gettime (CLOCK_REALTIME_COARSE)’,
|
when the clock is available or ‘clock_gettime (CLOCK_REALTIME)’
|
otherwise.
|
|
If the argument RESULT is not a null pointer, the calendar time
|
value is also stored in ‘*RESULT’.
|
|
This function cannot fail.
|
|
Some applications need more precise timekeeping than is possible with
|
a ‘time_t’ alone. Some applications also need more control over what is
|
meant by “the current time.” For these applications, POSIX provides a
|
function ‘clock_gettime’ that can retrieve the time with up to
|
nanosecond precision, from a variety of different clocks. Clocks can be
|
system-wide, measuring time the same for all processes; or they can be
|
per-process or per-thread, measuring CPU time consumed by a particular
|
process, or some other similar resource. Each clock has its own
|
resolution and epoch. You can find the resolution of a clock with the
|
function ‘clock_getres’. There is no function to get the epoch for a
|
clock; either it is fixed and documented, or the clock is not meant to
|
be used to measure absolute times.
|
|
-- Data Type: clockid_t
|
|
The type ‘clockid_t’ is used for constants that indicate which of
|
several system clocks one wishes to use.
|
|
All systems that support this family of functions will define at
|
least this clock constant:
|
|
-- Macro: clockid_t CLOCK_REALTIME
|
|
This clock uses the POSIX epoch, 00:00:00 on January 1, 1970,
|
Coordinated Universal Time. It is close to, but not necessarily in
|
lock-step with, the clocks of ‘time’ (above) and of ‘gettimeofday’
|
(below).
|
|
A second clock constant which is not universal, but still very
|
common, is for a clock measuring "monotonic time". Monotonic time is
|
useful for measuring elapsed times, because it guarantees that those
|
measurements are not affected by changes to the system clock.
|
|
-- Macro: clockid_t CLOCK_MONOTONIC
|
|
System-wide clock that continuously measures the advancement of
|
calendar time, ignoring discontinuous changes to the system’s
|
setting for absolute calendar time.
|
|
The epoch for this clock is an unspecified point in the past. The
|
epoch may change if the system is rebooted or suspended.
|
Therefore, ‘CLOCK_MONOTONIC’ cannot be used to measure absolute
|
time, only elapsed time.
|
|
Systems may support more than just these two clocks.
|
|
-- Function: int clock_gettime (clockid_t CLOCK, struct timespec *TS)
|
|
Get the current time accoding to the clock identified by CLOCK,
|
storing it as seconds and nanoseconds in ‘*TS’. *Note Time
|
Types::, for a description of ‘struct timespec’.
|
|
The return value is ‘0’ on success and ‘-1’ on failure. The
|
following ‘errno’ error condition is defined for this function:
|
|
‘EINVAL’
|
The clock identified by CLOCK is not supported.
|
|
‘clock_gettime’ reports the time scaled to seconds and nanoseconds,
|
but the actual resolution of each clock may not be as fine as one
|
nanosecond, and may not be the same for all clocks. POSIX also provides
|
a function for finding out the actual resolution of a clock:
|
|
-- Function: int clock_getres (clockid_t CLOCK, struct timespec *RES)
|
|
Get the actual resolution of the clock identified by CLOCK, storing
|
it in ‘*TS’.
|
|
For instance, if the clock hardware for ‘CLOCK_REALTIME’ uses a
|
quartz crystal that oscillates at 32.768 kHz, then its resolution
|
would be 30.518 microseconds, and ‘clock_getres (CLOCK_REALTIME, &r)’
|
would set ‘r.tv_sec’ to 0 and ‘r.tv_nsec’ to 30518.
|
|
The return value is ‘0’ on success and ‘-1’ on failure. The
|
following ‘errno’ error condition is defined for this function:
|
|
‘EINVAL’
|
The clock identified by CLOCK is not supported.
|
|
These functions, and the constants that identify particular clocks,
|
are declared in ‘time.h’.
|
|
*Portability Note:* On some systems, including systems that use older
|
versions of the GNU C Library, programs that use ‘clock_gettime’ or
|
‘clock_setres’ must be linked with the ‘-lrt’ library. This has not
|
been necessary with the GNU C Library since version 2.17.
|
|
The GNU C Library also provides an older, but still widely used,
|
function for getting the current time with a resolution of microseconds.
|
This function is declared in ‘sys/time.h’.
|
|
-- Function: int gettimeofday (struct timeval *TP, void *TZP)
|
|
Preliminary: | MT-Safe | AS-Safe | AC-Safe | *Note POSIX Safety
|
Concepts::.
|
|
Get the current calendar time, storing it as seconds and
|
microseconds in ‘*TP’. *Note Time Types::, for a description of
|
‘struct timeval’. The clock of ‘gettimeofday’ is close to, but not
|
necessarily in lock-step with, the clocks of ‘time’ and of ‘clock_gettime (CLOCK_REALTIME)’
|
(see above).
|
|
On some historic systems, if TZP was not a null pointer,
|
information about a system-wide time zone would be written to
|
‘*TZP’. This feature is obsolete and not supported on GNU systems.
|
You should always supply a null pointer for this argument.
|
Instead, use the facilities described in *note Time Zone
|
Functions:: and in *note Broken-down Time:: for working with time
|
zones.
|
|
This function cannot fail, and its return value is always ‘0’.
|
|
*Portability Note:* As of the 2008 revision of POSIX, this function
|
is considered obsolete. The GNU C Library will continue to provide
|
this function indefinitely, but new programs should use
|
‘clock_gettime’ instead.
|
|
|
File: libc.info, Node: Setting and Adjusting the Time, Next: Broken-down Time, Prev: Getting the Time, Up: Calendar Time
|
|
21.5.2 Setting and Adjusting the Time
|
-------------------------------------
|
|
The clock hardware inside a modern computer is quite reliable, but it
|
can still be wrong. The functions in this section allow one to set the
|
system’s idea of the current calendar time, and to adjust the rate at
|
which the system counts seconds, so that the calendar time will both be
|
accurate, and remain accurate.
|
|
The functions in this section require special privileges to use.
|
*Note Users and Groups::.
|
|
-- Function: int clock_settime (clockid_t CLOCK, const struct timespec
|
*TS)
|
|
Preliminary: | MT-Safe | AS-Safe | AC-Safe | *Note POSIX Safety
|
Concepts::.
|
|
Change the current calendar time, according to the clock identified
|
by CLOCK, to be the simple calendar time in ‘*TS’.
|
|
Not all of the system’s clocks can be changed. For instance, the
|
‘CLOCK_REALTIME’ clock can be changed (with the appropriate
|
privileges), but the ‘CLOCK_MONOTONIC’ clock cannot.
|
|
Because simple calendar times are independent of time zone, this
|
function should not be used when the time zone changes (e.g. if the
|
computer is physically moved from one zone to another). Instead,
|
use the facilities described in *note Time Zone Functions::.
|
|
‘clock_settime’ causes the clock to jump forwards or backwards,
|
which can cause a variety of problems. Changing the
|
‘CLOCK_REALTIME’ clock with ‘clock_settime’ does not affect when
|
timers expire (*note Setting an Alarm::) or when sleeping processes
|
wake up (*note Sleeping::), which avoids some of the problems.
|
Still, for small changes made while the system is running, it is
|
better to use ‘ntp_adjtime’ (below) to make a smooth transition
|
from one time to another.
|
|
The return value is ‘0’ on success and ‘-1’ on failure. The
|
following ‘errno’ error conditions are defined for this function:
|
|
‘EINVAL’
|
The clock identified by CLOCK is not supported or cannot be
|
set at all, or the simple calendar time in ‘*TS’ is invalid
|
(for instance, ‘ts->tv_nsec’ is negative or greater than
|
999,999,999).
|
|
‘EPERM’
|
This process does not have the privileges required to set the
|
clock identified by CLOCK.
|
|
*Portability Note*: On some systems, including systems that use
|
older versions of the GNU C Library, programs that use
|
‘clock_settime’ must be linked with the ‘-lrt’ library. This has
|
not been necessary with the GNU C Library since version 2.17.
|
|
For systems that remain up and running for long periods, it is not
|
enough to set the time once; one should also "discipline" the clock so
|
that it does not drift away from the true calendar time.
|
|
The ‘ntp_gettime’ and ‘ntp_adjtime’ functions provide an interface to
|
monitor and discipline the system clock. For example, you can fine-tune
|
the rate at which the clock “ticks,” and make small adjustments to the
|
current reported calendar time smoothly, by temporarily speeding up or
|
slowing down the clock.
|
|
These functions’ names begin with ‘ntp_’ because they were designed
|
for use by programs implementing the Network Time Protocol to
|
synchronize a system’s clock with other systems’ clocks and/or with
|
external high-precision clock hardware.
|
|
These functions, and the constants and structures they use, are
|
declared in ‘sys/timex.h’.
|
|
-- Data Type: struct ntptimeval
|
This structure is used to report information about the system
|
clock. It contains the following members:
|
‘struct timeval time’
|
The current calendar time, as if retrieved by ‘gettimeofday’.
|
The ‘struct timeval’ data type is described in *note Time
|
Types::.
|
|
‘long int maxerror’
|
This is the maximum error, measured in microseconds. Unless
|
updated via ‘ntp_adjtime’ periodically, this value will reach
|
some platform-specific maximum value.
|
|
‘long int esterror’
|
This is the estimated error, measured in microseconds. This
|
value can be set by ‘ntp_adjtime’ to indicate the estimated
|
offset of the system clock from the true calendar time.
|
|
-- Function: int ntp_gettime (struct ntptimeval *TPTR)
|
|
Preliminary: | MT-Safe | AS-Safe | AC-Safe | *Note POSIX Safety
|
Concepts::.
|
|
The ‘ntp_gettime’ function sets the structure pointed to by TPTR to
|
current values. The elements of the structure afterwards contain
|
the values the timer implementation in the kernel assumes. They
|
might or might not be correct. If they are not, an ‘ntp_adjtime’
|
call is necessary.
|
|
The return value is ‘0’ on success and other values on failure.
|
The following ‘errno’ error conditions are defined for this
|
function:
|
|
‘TIME_ERROR’
|
The precision clock model is not properly set up at the
|
moment, thus the clock must be considered unsynchronized, and
|
the values should be treated with care.
|
|
-- Data Type: struct timex
|
This structure is used to control and monitor the system clock. It
|
contains the following members:
|
‘unsigned int modes’
|
This variable controls whether and which values are set.
|
Several symbolic constants have to be combined with _binary
|
or_ to specify the effective mode. These constants start with
|
‘MOD_’.
|
|
‘long int offset’
|
This value indicates the current offset of the system clock
|
from the true calendar time. The value is given in
|
microseconds. If bit ‘MOD_OFFSET’ is set in ‘modes’, the
|
offset (and possibly other dependent values) can be set. The
|
offset’s absolute value must not exceed ‘MAXPHASE’.
|
|
‘long int frequency’
|
This value indicates the difference in frequency between the
|
true calendar time and the system clock. The value is
|
expressed as scaled PPM (parts per million, 0.0001%). The
|
scaling is ‘1 << SHIFT_USEC’. The value can be set with bit
|
‘MOD_FREQUENCY’, but the absolute value must not exceed
|
‘MAXFREQ’.
|
|
‘long int maxerror’
|
This is the maximum error, measured in microseconds. A new
|
value can be set using bit ‘MOD_MAXERROR’. Unless updated via
|
‘ntp_adjtime’ periodically, this value will increase steadily
|
and reach some platform-specific maximum value.
|
|
‘long int esterror’
|
This is the estimated error, measured in microseconds. This
|
value can be set using bit ‘MOD_ESTERROR’.
|
|
‘int status’
|
This variable reflects the various states of the clock
|
machinery. There are symbolic constants for the significant
|
bits, starting with ‘STA_’. Some of these flags can be
|
updated using the ‘MOD_STATUS’ bit.
|
|
‘long int constant’
|
This value represents the bandwidth or stiffness of the PLL
|
(phase locked loop) implemented in the kernel. The value can
|
be changed using bit ‘MOD_TIMECONST’.
|
|
‘long int precision’
|
This value represents the accuracy or the maximum error when
|
reading the system clock. The value is expressed in
|
microseconds.
|
|
‘long int tolerance’
|
This value represents the maximum frequency error of the
|
system clock in scaled PPM. This value is used to increase the
|
‘maxerror’ every second.
|
|
‘struct timeval time’
|
The current calendar time.
|
|
‘long int tick’
|
The elapsed time between clock ticks in microseconds. A clock
|
tick is a periodic timer interrupt on which the system clock
|
is based.
|
|
‘long int ppsfreq’
|
This is the first of a few optional variables that are present
|
only if the system clock can use a PPS (pulse per second)
|
signal to discipline the system clock. The value is expressed
|
in scaled PPM and it denotes the difference in frequency
|
between the system clock and the PPS signal.
|
|
‘long int jitter’
|
This value expresses a median filtered average of the PPS
|
signal’s dispersion in microseconds.
|
|
‘int shift’
|
This value is a binary exponent for the duration of the PPS
|
calibration interval, ranging from ‘PPS_SHIFT’ to
|
‘PPS_SHIFTMAX’.
|
|
‘long int stabil’
|
This value represents the median filtered dispersion of the
|
PPS frequency in scaled PPM.
|
|
‘long int jitcnt’
|
This counter represents the number of pulses where the jitter
|
exceeded the allowed maximum ‘MAXTIME’.
|
|
‘long int calcnt’
|
This counter reflects the number of successful calibration
|
intervals.
|
|
‘long int errcnt’
|
This counter represents the number of calibration errors
|
(caused by large offsets or jitter).
|
|
‘long int stbcnt’
|
This counter denotes the number of calibrations where the
|
stability exceeded the threshold.
|
|
-- Function: int ntp_adjtime (struct timex *TPTR)
|
|
Preliminary: | MT-Safe | AS-Safe | AC-Safe | *Note POSIX Safety
|
Concepts::.
|
|
The ‘ntp_adjtime’ function sets the structure specified by TPTR to
|
current values.
|
|
In addition, ‘ntp_adjtime’ updates some settings to match what you
|
pass to it in ‘*TPTR’. Use the ‘modes’ element of ‘*TPTR’ to
|
select what settings to update. You can set ‘offset’, ‘freq’,
|
‘maxerror’, ‘esterror’, ‘status’, ‘constant’, and ‘tick’.
|
|
‘modes’ = zero means set nothing.
|
|
Only the superuser can update settings.
|
|
The return value is ‘0’ on success and other values on failure.
|
The following ‘errno’ error conditions are defined for this
|
function:
|
|
‘TIME_ERROR’
|
The high accuracy clock model is not properly set up at the
|
moment, thus the clock must be considered unsynchronized, and
|
the values should be treated with care. Another reason could
|
be that the specified new values are not allowed.
|
|
‘EPERM’
|
The process specified a settings update, but is not superuser.
|
|
For more details see RFC1305 (Network Time Protocol, Version 3) and
|
related documents.
|
|
*Portability note:* Early versions of the GNU C Library did not
|
have this function, but did have the synonymous ‘adjtimex’.
|
|
-- Function: int adjtime (const struct timeval *DELTA, struct timeval
|
*OLDDELTA)
|
|
Preliminary: | MT-Safe | AS-Safe | AC-Safe | *Note POSIX Safety
|
Concepts::.
|
|
This simpler version of ‘ntp_adjtime’ speeds up or slows down the
|
system clock for a short time, in order to correct it by a small
|
amount. This avoids a discontinuous change in the calendar time
|
reported by the ‘CLOCK_REALTIME’ clock, at the price of having to
|
wait longer for the time to become correct.
|
|
The DELTA argument specifies a relative adjustment to be made to
|
the clock time. If negative, the system clock is slowed down for a
|
while until it has lost this much elapsed time. If positive, the
|
system clock is speeded up for a while.
|
|
If the OLDDELTA argument is not a null pointer, the ‘adjtime’
|
function returns information about any previous time adjustment
|
that has not yet completed.
|
|
The return value is ‘0’ on success and ‘-1’ on failure. The
|
following ‘errno’ error condition is defined for this function:
|
|
‘EPERM’
|
This process does not have the privileges required to adjust
|
the ‘CLOCK_REALTIME’ clock.
|
|
For compatibility, the GNU C Library also provides several older
|
functions for controlling the system time. New programs should prefer
|
to use the functions above.
|
|
-- Function: int stime (const time_t *NEWTIME)
|
|
Preliminary: | MT-Safe | AS-Safe | AC-Safe | *Note POSIX Safety
|
Concepts::.
|
|
Change the ‘CLOCK_REALTIME’ calendar time to be the simple calendar
|
time in ‘*NEWTIME’. Calling this function is exactly the same as
|
calling ‘clock_settime (CLOCK_REALTIME)’, except that the new time
|
can only be set to a precision of one second.
|
|
This function is no longer available on GNU systems, but it may be
|
the _only_ way to set the time on very old Unix systems, so we
|
continue to document it. If it is available, it is declared in
|
‘time.h’.
|
|
The return value is ‘0’ on success and ‘-1’ on failure. The
|
following ‘errno’ error condition is defined for this function:
|
|
‘EPERM’
|
This process does not have the privileges required to adjust
|
the ‘CLOCK_REALTIME’ clock.
|
|
-- Function: int adjtimex (struct timex *TIMEX)
|
|
Preliminary: | MT-Safe | AS-Safe | AC-Safe | *Note POSIX Safety
|
Concepts::.
|
|
‘adjtimex’ is an older name for ‘ntp_adjtime’. This function is
|
only available on GNU/Linux systems. It is declared in
|
‘sys/timex.h’.
|
|
-- Function: int settimeofday (const struct timeval *TP, const void
|
*TZP)
|
|
Preliminary: | MT-Safe | AS-Safe | AC-Safe | *Note POSIX Safety
|
Concepts::.
|
|
Change the ‘CLOCK_REALTIME’ calendar time to be the simple calendar
|
time in ‘*NEWTIME’. This function is declared in ‘sys/time.h’.
|
|
When TZP is a null pointer, calling this function is exactly the
|
same as calling ‘clock_settime (CLOCK_REALTIME)’, except that the
|
new time can only be set to a precision of one microsecond.
|
|
When TZP is not a null pointer, the data it points to _may_ be used
|
to set a system-wide idea of the current timezone. This feature is
|
obsolete and not supported on GNU systems. Instead, use the
|
facilities described in *note Time Zone Functions:: and in *note
|
Broken-down Time:: for working with time zones.
|
|
The return value is ‘0’ on success and ‘-1’ on failure. The
|
following ‘errno’ error conditions are defined for this function:
|
|
‘EPERM’
|
This process does not have the privileges required to set the
|
‘CLOCK_REALTIME’ clock.
|
|
‘EINVAL’
|
Neither TP nor TZP is a null pointer. (For historical
|
reasons, it is not possible to set the current time and the
|
current time zone in the same call.)
|
|
‘ENOSYS’
|
The operating system does not support setting time zone
|
information, and TZP is not a null pointer.
|
