C`iscntrl(c)` di `<ctype.h>` restituisce un valore nonzero se `c` è un carattere di controllo nella locale corrente. Un controllo non è stampabile; nella locale iniziale `C`, newline e tab orizzontale appartengono tra gli altri a questa classe.
Base · C23C`isdigit(c)` di `<ctype.h>` verifica se `c` è una cifra decimale del set di caratteri di esecuzione base, cioè uno dei caratteri da `0` a `9`. Restituisce nonzero per una cifra e zero per ogni altro argomento valido.
Base · C23C`isfinite(x)` di `<math.h>` è una macro di classificazione: restituisce nonzero esattamente quando l’argomento floating reale ha valore finito. Numeri normali, subnormali ed entrambi gli zeri con segno sono finiti; infiniti e NaN non lo sono.
Base · C23C`isgraph(c)` di `<ctype.h>` restituisce nonzero per un carattere stampabile diverso dallo spazio nella locale corrente. Comprende quindi segni visibili come lettere, cifre e punteggiatura, ma esclude lo spazio e i caratteri di controllo.
Base · C23C`isinf(x)` di `<math.h>` è una macro di classificazione che restituisce nonzero esattamente se l’argomento floating reale è infinito positivo o negativo. Valori finiti e qualsiasi NaN producono zero.
Base · C23C`islower(c)` di `<ctype.h>` restituisce nonzero quando `c` è una lettera minuscola nella locale corrente. Nella locale `C` comprende almeno i caratteri da `a` a `z`; un’altra locale può classificare ulteriori lettere a un byte.
Base · C23C`isnan(x)` di `<math.h>` è una macro di classificazione che restituisce nonzero esattamente quando il suo argomento floating reale è NaN. Valori finiti ed entrambi gli infiniti producono zero.
Base · C23C`isprint(c)` di `<ctype.h>` restituisce nonzero per un carattere stampabile nella locale corrente. A differenza di `isgraph`, include anche lo spazio; controlli come newline e tab orizzontale non sono stampabili.
Base · C23C`ispunct(c)` di `<ctype.h>` restituisce nonzero per un carattere di punteggiatura: uno stampabile che non è spazio né alfanumerico nella locale corrente. L’underscore è punteggiatura anche se C lo ammette negli identificatori.
Base · C23C`isspace(c)` di `<ctype.h>` restituisce nonzero per un carattere whitespace nella locale corrente. Nella locale `C` la classe contiene spazio, `\f`, `\n`, `\r`, `\t` e `\v`, quindi è più ampia di `isblank`, limitata alla spaziatura orizzontale.
Base · C23C`isupper(c)` di `<ctype.h>` restituisce un valore nonzero se `c` è una maiuscola nella locale corrente; nella locale `C` copre da `A` a `Z`. Il risultato è soltanto logicamente nonzero, non necessariamente proprio `1`.
Base · C23C`isxdigit(c)` di `<ctype.h>` restituisce nonzero per una cifra esadecimale: `0`–`9`, `A`–`F` oppure `a`–`f`. Classifica un solo carattere; non analizza un intero letterale né il prefisso `0x`.
Base · C23C`labs(j)` di `<stdlib.h>` restituisce il valore assoluto di un argomento `long int`. Anche il risultato è `long int`; la funzione non analizza testo e non segnala errori tramite `errno`.
Base · C23C`ldexp(x, exp)` di `<math.h>` restituisce `x * 2^exp`; `ldexpf` e `ldexpl` servono `float` e `long double`. Scala quindi per una potenza intera di due indipendentemente da `FLT_RADIX`.
Intermedio · C23C`ldiv(numer, denom)` di `<stdlib.h>` calcola in un’operazione quoziente e resto di tipo `long int` e restituisce `ldiv_t` con `quot` e `rem`. La divisione tronca verso zero e `numer == quot * denom + rem`.
Base · C23C`llabs(j)` di `<stdlib.h>` restituisce il valore assoluto di un `long long int` con lo stesso tipo di risultato. Non analizza testo e non imposta `errno`.
Base · C23C`lldiv(numer, denom)` di `<stdlib.h>` calcola quoziente e resto `long long int` e restituisce `lldiv_t` con `quot` e `rem`. La divisione tronca verso zero e `numer == quot * denom + rem`.
Base · C23C`llround(x)` di `<math.h>` arrotonda al `long long int` più vicino; un caso esattamente a metà si allontana sempre da zero, indipendentemente dal modo di arrotondamento floating-point corrente.
Intermedio · C23C`localeconv()` di `<locale.h>` restituisce un puntatore a `struct lconv` con formattazione numerica e monetaria corrente, inclusi `decimal_point`, separatori di gruppi e simboli di valuta. Non cambia la locale.
Intermedio · C23C`localtime(timer)` di `<time.h>` converte il `time_t` indicato in tempo civile locale scomposto e restituisce un puntatore a `struct tm`; applica regole di fuso e ora legale dell’ambiente. Può restituire null al fallimento.
Intermedio · C23C`log(x)` di `<math.h>` calcola il logaritmo naturale di `x` positivo e restituisce `ln(x)` come `double`; `logf` e `logl` servono `float` e `long double`. Il risultato è negativo per `0 < x < 1`, zero per `x == 1` e positivo per `x > 1`.
Base · C23C`log10(x)` di `<math.h>` restituisce il logaritmo in base dieci di `x` positivo come `double`; `log10f` e `log10l` servono gli altri tipi. Il risultato indica quale potenza di `10` produce l’argomento.
Base · C23C`log1p(x)` di `<math.h>` calcola `ln(1 + x)` senza la perdita di cifre dovuta a formare separatamente `1 + x` per `x` molto piccolo; `log1pf` e `log1pl` servono gli altri tipi. Il dominio reale è `x >= -1`.
Intermedio · C23C`log2(x)` di `<math.h>` restituisce il logaritmo in base due di `x` positivo; `log2f` e `log2l` servono altri tipi. Le potenze di due danno risultati interi, utili per livelli di alberi, dimensioni di blocchi e analisi dei bit.
Base · C23