Type-generic math (since C99)

L'en-tête <tgmath.h> inclut les en-têtes <math.h> et <complex.h> et définit plusieurs macros génériques de type qui déterminent quelle fonction réelle ou, le cas échéant, complexe appeler en fonction des types des arguments.

Pour chaque macro, les paramètres dont le type réel correspondant dans la fonction sans suffixe <math.h> est double sont appelés paramètres génériques (par exemple, les deux paramètres de pow sont des paramètres génériques, mais seul le premier paramètre de scalbn est un paramètre générique).

Lorsqu'une macro de <tgmath.h> est utilisée, les types des arguments passés aux paramètres génériques déterminent quelle fonction est sélectionnée par la macro comme décrit ci-dessous. Si les types des arguments ne sont pas compatibles avec les types de paramètres de la fonction sélectionnée, le comportement est indéfini (par exemple, si un argument complexe est passé à une macro de <tgmath.h> qui ne prend que des réels : float complex fc ; ceil ( fc ) ; ou double complex dc ; double d ; fmax ( dc, d ) ; sont des exemples de comportement indéfini).

Note : les macros génériques de type ont été implémentées de manière définie par l'implémentation en C99, mais le mot-clé C11 _Generic permet d'implémenter ces macros de manière portable.

Macros génériques pour types complexes/réels

Pour toutes les fonctions qui possèdent à la fois des versions réelles et complexes, une macro générique de type XXX existe, qui appelle l'une des deux versions :

• fonction réelle :

• float variante XXXf
• double variante XXX
• long double variante XXXl

• fonction complexe :

• float variante cXXXf
• double variante cXXX
• long double variante cXXXl

Une exception à la règle ci-dessus est la macro fabs (voir le tableau ci-dessous).

La fonction à appeler est déterminée comme suit :

• Si l'un des arguments pour les paramètres génériques est imaginaire, le comportement est spécifié individuellement sur chaque page de référence de fonction (en particulier, sin , cos , tan , cosh , sinh , tanh , asin , atan , asinh , et atanh appellent des fonctions réelles , les types de retour de sin , tan , sinh , tanh , asin , atan , asinh , et atanh sont imaginaires, et les types de retour de cos et cosh sont réels).
• Si l'un des arguments pour les paramètres génériques est complexe, alors la fonction complexe est appelée, sinon la fonction réelle est appelée.
• Si l'un des arguments pour les paramètres génériques est long double , alors la variante long double est appelée. Sinon, si l'un des paramètres est double ou entier, alors la variante double est appelée. Sinon, la variante float est appelée.

Les macros génériques de type sont les suivantes :

Fonctions réelles uniquement

Pour toutes les fonctions qui n'ont pas d'équivalents complexes, à l'exception de modf , il existe une macro générique de type XXX , qui appelle l'une ou l'autre des variantes d'une fonction réelle :

• float variante XXXf
• double variante XXX
• long double variante XXXl

La fonction à appeler est déterminée comme suit :

• Si l'un des arguments pour les paramètres génériques est long double , alors la variante long double est appelée. Sinon, si l'un des arguments pour les paramètres génériques est double , alors la variante double est appelée. Sinon, la variante float est appelée.

Fonctions complexes uniquement

Pour toutes les fonctions de nombres complexes qui n'ont pas d'équivalents réels, une macro générique de type cXXX existe, qui appelle l'une ou l'autre des variantes d'une fonction complexe :

• float complex variante cXXXf
• double complex variante cXXX
• long double complex variante cXXXl

La fonction à appeler est déterminée comme suit :

• Si l'un des arguments pour les paramètres génériques est réel, complexe ou imaginaire, alors la fonction complexe appropriée est appelée.

Exemple

#include <stdio.h>
#include <tgmath.h>
int main(void)
{
    int i = 2;
    printf("sqrt(2) = %f\n", sqrt(i)); // le type d'argument est int, appelle sqrt
    float f = 0.5;
    printf("sin(0.5f) = %f\n", sin(f)); // le type d'argument est float, appelle sinf
    float complex dc = 1 + 0.5*I;
    float complex z = sqrt(dc); // le type d'argument est float complex, appelle csqrtf
    printf("sqrt(1 + 0.5i) = %f+%fi\n",
           creal(z),  // le type d'argument est float complex, appelle crealf
           cimag(z)); // le type d'argument est float complex, appelle cimagf
}

sqrt(2) = 1.414214
sin(0.5f) = 0.479426
sqrt(1 + 0.5i) = 1.029086+0.242934i

Références