Arithmetic types

Type booléen

• _Bool (également accessible via la macro bool ) (jusqu'à C23) bool (depuis C23) — type capable de contenir l'une des deux valeurs : 1 et ​ 0 ​ (également accessibles via les macros true et false ) (jusqu'à C23) true et false (depuis C23) .

Notez que la conversion vers _Bool (jusqu'à C23) bool (depuis C23) ne fonctionne pas de la même manière que la conversion vers d'autres types entiers : ( bool ) 0.5 s'évalue à true , tandis que ( int ) 0.5 s'évalue à ​ 0 ​ .

• long long int (également accessible sous le nom long long )
• unsigned long long int (également accessible sous le nom unsigned long long )

• _BitInt ( n ) (également accessible sous le nom signed _BitInt ( n ) ), les types entiers signés à précision de bits (où n est remplacé par une expression constante entière désignant la largeur précise (incluant le bit de signe), qui ne peut pas être supérieure à BITINT_MAXWIDTH de <limits.h> )
• unsigned _BitInt ( n ) , les types entiers non signés à précision de bits (où n est remplacé par une expression constante entière désignant la largeur précise, qui ne peut pas être supérieure à BITINT_MAXWIDTH de <limits.h> )

Si l'implémentation prédéfinit la macro constante __STDC_IEC_60559_DFP__ , les types de virgule flottante décimaux suivants sont également pris en charge.

• _Decimal32 — Représente le format decimal32 IEEE-754 .
• _Decimal64 — Représente le format decimal64 IEEE-754 .
• _Decimal128 — Représente le format decimal128 IEEE-754 .

Sinon, ces types de virgule flottante décimaux ne sont pas pris en charge.

Types à virgule flottante complexes

Les types à virgule flottante complexes modélisent les nombres complexes mathématiques, c'est-à-dire les nombres qui peuvent s'écrire comme la somme d'un nombre réel et d'un nombre réel multiplié par l'unité imaginaire : a + bi

Les trois types complexes sont

• float _Complex (également disponible sous le nom float complex si <complex.h> est inclus)
• double _Complex (également disponible sous le nom double complex si <complex.h> est inclus)
• long double _Complex (également disponible sous le nom long double complex si <complex.h> est inclus)

Remarque : comme pour tous les spécificateurs de type, tout ordre est autorisé : long double complex , complex long double , et même double complex long désignent le même type.

#include <complex.h>
#include <stdio.h>
int main(void)
{
    double complex z = 1 + 2*I;
    z = 1 / z;
    printf("1/(1.0+2.0i) = %.1f%+.1fi\n", creal(z), cimag(z));
}

1/(1.0+2.0i) = 0.2-0.4i

Chaque type complexe possède la même représentation d'objet et les mêmes exigences d'alignement qu'un tableau de deux éléments du type réel correspondant ( float pour float complex , double pour double complex , long double pour long double complex ). Le premier élément du tableau contient la partie réelle, et le deuxième élément du tableau contient la composante imaginaire.

float a[4] = {1, 2, 3, 4};
float complex z1, z2;
memcpy(&z1, a, sizeof z1); // z1 devient 1.0 + 2.0i
memcpy(&z2, a+2, sizeof z2); // z2 devient 3.0 + 4.0i

Les nombres complexes peuvent être utilisés avec les opérateurs arithmétiques + - * et / , éventuellement mélangés avec des nombres imaginaires et réels. De nombreuses fonctions mathématiques sont définies pour les nombres complexes dans <complex.h> . Les opérateurs intégrés et les fonctions de bibliothèque peuvent lever des exceptions en virgule flottante et définir errno comme décrit dans math_errhandling .

L'incrémentation et la décrémentation ne sont pas définies pour les types complexes.

Les opérateurs relationnels ne sont pas définis pour les types complexes (il n'existe pas de notion de "inférieur à").

Afin de soutenir le modèle un-infini de l'arithmétique des nombres complexes, C considère toute valeur complexe avec au moins une partie infinie comme une infini même si son autre partie est un NaN, garantit que tous les opérateurs et fonctions respectent les propriétés fondamentales des infinis et fournit cproj pour mapper tous les infinis vers l'infini canonique (voir opérateurs arithmétiques pour les règles exactes).

#include <complex.h>
#include <math.h>
#include <stdio.h>
int main(void)
{
    double complex z = (1 + 0*I) * (INFINITY + I*INFINITY);
//  la formule théorique donnerait
//  (1+i0)(∞+i∞) ⇒ (1×∞ – 0×∞) + i(0×∞+1×∞) ⇒ NaN + I*NaN
//  mais C donne un infini complexe
    printf("%f%+f*i\n", creal(z), cimag(z));
//  la formule théorique donnerait
//  cexp(∞+iNaN) ⇒ exp(∞)×(cis(NaN)) ⇒ NaN + I*NaN
//  mais C donne  ±∞+i*nan
    double complex y = cexp(INFINITY + I*NAN);
    printf("%f%+f*i\n", creal(y), cimag(y));
}

inf+inf*i 
inf+nan*i

C traite également les multiples infinis de manière à préserver l'information directionnelle lorsque cela est possible, malgré les limitations inhérentes à la représentation cartésienne :

multiplier l'unité imaginaire par l'infini réel donne l'infini imaginaire correctement signé : i × ∞ = i∞. De plus, i × (∞ – i∞) = ∞ + i∞ indique le quadrant raisonnable.

Types flottants imaginaires

Les types flottants imaginaires modélisent les nombres imaginaires mathématiques, c'est-à-dire des nombres qui peuvent s'écrire comme un nombre réel multiplié par l'unité imaginaire : bi Les trois types imaginaires sont

• float _Imaginary (également disponible sous le nom float imaginary si <complex.h> est inclus)
• double _Imaginary (également disponible sous le nom double imaginary si <complex.h> est inclus)
• long double _Imaginary (également disponible sous le nom long double imaginary si <complex.h> est inclus)

Note : comme pour tous les spécificateurs de type, tout ordre est autorisé : long double imaginary , imaginary long double , et même double imaginary long désignent le même type.

#include <complex.h>
#include <stdio.h>
int main(void)
{
    double imaginary z = 3*I;
    z = 1 / z;
    printf("1/(3.0i) = %+.1fi\n", cimag(z));
}

1/(3.0i) = -0.3i

Chacun des trois types imaginaires possède la même représentation d'objet et les mêmes exigences d'alignement que son type réel correspondant ( float pour float imaginary , double pour double imaginary , long double pour long double imaginary ).

Note : bien que les types imaginaires soient distincts et non compatibles avec leurs types réels correspondants, ce qui interdit l'aliasing.

Les nombres imaginaires peuvent être utilisés avec les opérateurs arithmétiques + - * et / , éventuellement mélangés avec des nombres complexes et réels. De nombreuses fonctions mathématiques sont définies pour les nombres imaginaires dans <complex.h> . Les opérateurs intégrés et les fonctions de bibliothèque peuvent lever des exceptions en virgule flottante et définir errno comme décrit dans math_errhandling .

L'incrémentation et la décrémentation ne sont pas définies pour les types imaginaires.

Les nombres imaginaires permettent d'exprimer tous les nombres complexes en utilisant la notation naturelle x + I * y (où I est défini comme _Imaginary_I ). Sans les types imaginaires, certaines valeurs complexes spéciales ne peuvent pas être créées naturellement. Par exemple, si I est défini comme _Complex_I , alors écrire 0.0 + I * INFINITY donne NaN comme partie réelle, et CMPLX ( 0.0 , INFINITY ) doit être utilisé à la place. Il en va de même pour les nombres avec une composante imaginaire de zéro négatif, qui sont significatifs lors de l'utilisation des fonctions de bibliothèque avec des coupures de branche, telles que csqrt : 1.0 - 0.0 * I donne une composante imaginaire de zéro positif si I est défini comme _Complex_I et la partie imaginaire de zéro négatif nécessite l'utilisation de CMPLX ou conj .

Les types imaginaires simplifient également les implémentations ; la multiplication d'un imaginaire par un complexe peut être implémentée directement avec deux multiplications si les types imaginaires sont pris en charge, au lieu de quatre multiplications et deux additions.