C`iscntrl(c)` from `<ctype.h>` returns a nonzero value when `c` is a control character in the current locale. A control character is not printable; in the initial `C` locale, newline and horizontal tab are among the members of this class.
Basic · C23C`isdigit(c)` from `<ctype.h>` tests whether `c` is a decimal digit from the basic execution character set: one of `0` through `9`. It returns a nonzero value for a digit and zero for every other valid argument.
Basic · C23C`isfinite(x)` from `<math.h>` is a classification macro: it returns nonzero exactly when its real floating argument has a finite value. Normal numbers, subnormal numbers, and both signed zeros are finite; infinities and NaNs are not.
Basic · C23C`isgraph(c)` from `<ctype.h>` returns a nonzero value for a printing character other than space in the current locale. It therefore covers characters that leave a visible mark—letters, digits, and punctuation—but excludes the spacing character and control characters.
Basic · C23C`isinf(x)` from `<math.h>` is a classification macro that returns nonzero exactly when its real floating argument is positive or negative infinity. Finite values and every NaN produce zero.
Basic · C23C`islower(c)` from `<ctype.h>` returns a nonzero value when `c` is a lowercase letter in the current locale. In the `C` locale it includes at least the characters `a` through `z`; another locale may classify additional single-byte letters.
Basic · C23C`isnan(x)` from `<math.h>` is a classification macro that returns nonzero exactly when its real floating argument is NaN. Finite values and both infinities produce zero.
Basic · C23C`isprint(c)` from `<ctype.h>` returns a nonzero value for a printing character in the current locale. Unlike `isgraph`, it also includes the space character; control characters such as newline and horizontal tab are not printing.
Basic · C23C`ispunct(c)` from `<ctype.h>` returns a nonzero value for a punctuation character: a printing character that is neither space nor alphanumeric in the current locale. Underscore is punctuation even though C permits it in identifiers.
Basic · C23C`isspace(c)` from `<ctype.h>` returns a nonzero value for a white-space character in the current locale. In the `C` locale the class contains space, `\f`, `\n`, `\r`, `\t`, and `\v`, so it is broader than horizontal-only `isblank`.
Basic · C23C`isupper(c)` from `<ctype.h>` returns a nonzero value when `c` is an uppercase letter in the current locale; in the `C` locale this covers `A` through `Z`. The result is merely logically nonzero, not necessarily exactly `1`.
Basic · C23C`isxdigit(c)` from `<ctype.h>` returns nonzero for a hexadecimal digit: `0`–`9`, `A`–`F`, or `a`–`f`. It classifies one character; it does not parse a complete literal or its `0x` prefix.
Basic · C23C`labs(j)` from `<stdlib.h>` returns the absolute value of a `long int` argument. Its result has type `long int`; the function neither parses text nor reports an error through `errno`.
Basic · C23C`ldexp(x, exp)` from `<math.h>` returns `x * 2^exp`; `ldexpf` and `ldexpl` serve `float` and `long double`. It therefore scales by an integral power of two regardless of the value of `FLT_RADIX`.
Intermediate · C23C`ldiv(numer, denom)` from `<stdlib.h>` computes a `long int` quotient and remainder in one operation and returns an `ldiv_t` with `quot` and `rem` members. Division truncates toward zero, and `numer == quot * denom + rem`.
Basic · C23C`llabs(j)` from `<stdlib.h>` returns the absolute value of a `long long int` argument with the same result type. It neither parses text nor sets `errno`.
Basic · C23C`lldiv(numer, denom)` from `<stdlib.h>` computes a `long long int` quotient and remainder and returns an `lldiv_t` with `quot` and `rem`. Division truncates toward zero, and `numer == quot * denom + rem`.
Basic · C23C`llround(x)` from `<math.h>` rounds to the nearest `long long int`; an exact halfway case always moves away from zero, independently of the current floating-point rounding mode.
Intermediate · C23C`localeconv()` from `<locale.h>` returns a pointer to a `struct lconv` describing current numeric and monetary formatting, including `decimal_point`, grouping separators, and currency signs. It does not change the locale.
Intermediate · C23C`localtime(timer)` from `<time.h>` converts the designated `time_t` to local broken-down calendar time and returns a pointer to `struct tm`; it applies the environment’s time-zone and daylight-saving rules. It may return null on failure.
Intermediate · C23C`log(x)` from `<math.h>` computes the natural logarithm of positive `x` and returns `ln(x)` as `double`; `logf` and `logl` serve `float` and `long double`. The result is negative for `0 < x < 1`, zero for `x == 1`, and positive for `x > 1`.
Basic · C23C`log10(x)` from `<math.h>` returns the base-ten logarithm of positive `x` as `double`; `log10f` and `log10l` serve the other floating types. The result states which power of `10` produces the argument.
Basic · C23C`log1p(x)` from `<math.h>` computes `ln(1 + x)` without the digit loss caused by separately forming `1 + x` for very small `x`; `log1pf` and `log1pl` serve the other types. Its real domain is `x >= -1`.
Intermediate · C23C`log2(x)` from `<math.h>` returns the base-two logarithm of positive `x`; `log2f` and `log2l` serve the other types. Powers of two produce integral results, useful for tree levels, block sizes, and bit-oriented analysis.
Basic · C23