fma — função matemática C23
`fma(x, y, z)` de `<math.h>` calcula `x*y + z` como se produto e soma tivessem precisão ilimitada, arredondando uma só vez para `double`. `fmaf` e `fmal` oferecem a operação para os outros tipos flutuantes.
CKTIS / Base de conhecimento
Sintaxe, operadores e conceitos de programação. Encontra uma explicação, consulta um exemplo e continua a aprender.
`fma(x, y, z)` de `<math.h>` calcula `x*y + z` como se produto e soma tivessem precisão ilimitada, arredondando uma só vez para `double`. `fmaf` e `fmal` oferecem a operação para os outros tipos flutuantes.
`fmax(x, y)` de `<math.h>` devolve o maior valor numérico de dois `double`; `fmaxf` e `fmaxl` servem os outros tipos. Se apenas um argumento for NaN, devolve o valor numérico do outro.
`fmin(x, y)` de `<math.h>` devolve o menor valor numérico de dois `double`; `fminf` e `fminl` servem outros tipos. Se apenas um argumento for NaN, devolve o valor numérico.
`fmod(x, y)` de `<math.h>` devolve `x - n*y`, onde `n` é `x/y` truncado para zero; a magnitude é menor que `|y|` e o sinal segue `x`.
`fopen(filename, mode)` de `<stdio.h>` abre o ficheiro, associa-o a novo fluxo `FILE` e devolve o ponteiro ou null. `r`, `w`, `a`, os opcionais `+` e `b`, e `x` apenas nos modos enumerados baseados em `w` escolhem acesso, criação, truncamento, anexação e exclusividade.
`fprintf(stream, format, ...)` escreve dados formatados no fluxo e devolve o número de carateres ou valor negativo por falha de codificação/saída. Cada conversão de `format` tem de corresponder ao tipo real.
`fputc(c, stream)` de `<stdio.h>` escreve o caráter obtido ao converter `c` para `unsigned char`. No sucesso devolve esse valor convertido para `int`; na falha devolve `EOF` e define o indicador de erro.
`fputs(s, stream)` de `<stdio.h>` escreve todos os carateres de `s` antes do byte null final; não escreve terminador nem acrescenta nova linha. Devolve valor não negativo no sucesso ou `EOF` na falha.
`fread(ptr, size, nmemb, stream)` de `<stdio.h>` tenta ler `nmemb` elementos de `size` bytes para `ptr` e devolve quantos ficaram completos. Os dados são sequência de `unsigned char`; contagem curta significa fim ou erro.
`free(ptr)` de `<stdlib.h>` liberta o armazenamento indicado por `ptr` para futuras alocações; ponteiro null não faz nada e a função não devolve valor. Ponteiro não null tem de vir de função de memória compatível e ainda indicar uma alocação viva.
`freopen(filename, mode, stream)` de `<stdio.h>` fecha o ficheiro associado e reassocia o mesmo objeto `FILE` ao ficheiro e modo indicados. Devolve `stream` no sucesso ou null na falha.
`frexp(value, exp)` de `<math.h>` decompõe valor finito com `value == fraction * 2^*exp`; se não zero, a magnitude da fração fica em `[0.5, 1)`. Devolve a fração e guarda expoente por ponteiro válido.
`fscanf(stream, format, ...)` de `<stdio.h>` lê caracteres de um fluxo segundo diretivas de formato e guarda conversões através dos argumentos ponteiro sucessivos. Devolve o número de atribuições efetuadas, ou `EOF` quando uma falha de entrada antecede a primeira conversão.
`fseek(stream, offset, whence)` de `<stdio.h>` define a posição do ficheiro relativamente a `SEEK_SET`, `SEEK_CUR` ou `SEEK_END`. Devolve `0` no sucesso e valor não zero na falha; o sucesso limpa o indicador de fim e desfaz os efeitos de `ungetc`.
`fsetpos(stream, pos)` de `<stdio.h>` restaura o indicador de posição e, se existir, o objeto `mbstate_t` a partir de valor guardado por `fgetpos` bem-sucedido num fluxo associado ao mesmo ficheiro. Devolve `0` no sucesso e valor não zero na falha.
`ftell(stream)` de `<stdio.h>` obtém o indicador de posição atual. Num fluxo binário o resultado conta caracteres desde o início; num fluxo de texto é informação opaca que pode ser passada a `fseek` com `SEEK_SET` para regressar à mesma posição.
`fwrite(ptr, size, nmemb, stream)` de `<stdio.h>` escreve num fluxo até `nmemb` objetos de `size` bytes do array indicado por `ptr`. Cada objeto é processado como chamadas sucessivas a `fputc` sobre a representação `unsigned char`; devolve o número de objetos completos escritos.
`getchar()` de `<stdio.h>` obtém o caráter seguinte da entrada padrão e equivale a `getc(stdin)`. Devolve o caráter lido como `unsigned char` convertido em `int`, ou o valor da macro `EOF` no fim dos dados ou perante erro de leitura.
`getenv(name)` de `<stdlib.h>` procura na lista do ambiente anfitrião uma entrada correspondente à string terminada em null `name`. Devolve ponteiro para a string do valor se existir ou ponteiro null quando o nome não é encontrado.
`gmtime(timer)` de `<time.h>` converte o valor de tempo de calendário `time_t` indicado em UTC decomposto num objeto `struct tm`. Devolve ponteiro para o resultado, ou null se UTC não estiver disponível ou o valor não puder ser representado.
`hypot(x, y)` de `<math.h>` devolve o `sqrt(x*x + y*y)` não negativo, calculando-o sem overflow ou underflow intermédio indevido. `hypotf` e `hypotl` servem respetivamente `float` e `long double`.
`isalnum(c)` de `<ctype.h>` devolve valor não zero se `c` for letra ou dígito decimal na locale atual, como quando `isalpha(c) || isdigit(c)` é verdadeiro. Caso contrário devolve zero; o valor verdadeiro concreto não tem de ser 1.
`isalpha(c)` de `<ctype.h>` devolve valor não zero para caráter alfabético na locale atual. Na locale `C` são os carateres aceites por `isupper` ou `islower`; outra locale pode acrescentar letras que não sejam controlo, dígito, pontuação nem espaço.
`isblank(c)` de `<ctype.h>` devolve valor não zero para caráter de espaçamento horizontal padrão ou blank adicional definido pela locale atual. Na locale `C`, espaço e tabulação horizontal são verdadeiros; nova linha é espaço branco, mas não blank.