ENIB LANG-C 10_Maths - Opérations mathématiques

{} La bibliothèque mathématique

Bien que nous ayons vu à la fin de cette section comment calculer une fonction mathématique à l'aide d'un procédé itératif, il existe cependant un moyen beaucoup plus efficace.
En effet, les processeurs des machines informatiques sont généralement équipés d'un jeu d'instructions correspondant aux fonctions mathématiques usuelles ; ils sont capables de les évaluer bien plus rapidement que nous le ferions avec un programme itératif.
Le langage C fournit en standard une bibliothèque dédiée à l'invocation de ces fonctionnalités qui sont déclarées par le fichier d'en-tête standard

<math.h>

.
(https://en.cppreference.com/w/c/numeric/math)

{} Mise en oeuvre de la bibliothèque mathématique

Nous cherchons ici à compléter la fonction test_maths() afin qu'elle affiche clairement le résultat de quelques fonctions mathématiques usuelles.
Commençons par lui ajouter un paramètre x de type réel et faisons-lui calculer et afficher le résultat de la fonction cosinus appliquée à ce paramètre.
(https://en.cppreference.com/w/c/numeric/math/cos)
Sa documentation nous apprend qu'elle existe en différentes versions selon que nous souhaitons calculer avec des données de type float, double ou long double (voir cette section).
Cette distinction est similaire pour toutes les fonctions mathématiques et repose sur la dernière lettre qui est ajoutée au nom de la fonction : f pour float, aucune pour double ou l pour long double.
Ici nous utiliserons le type double, donc la fonction cos().
Son usage est trivial : nous lui transmettons un réel et nous obtenons son résultat que nous nous contentons d'afficher.

printf("cos(%g)=%g\n", x, cos(x));

Lors de l'appel à la fonction test_maths(), nous utiliserons π/3 comme paramètre effectif.
Toutefois, tout le monde ne connaît pas par cœur la valeur de π avec suffisamment de décimales significatives.
Beaucoup d'environnements de développement font apparaître dans le fichier d'en-tête standard

<math.h>

une macro M_PI qui décrit cette valeur ; seulement la norme du langage C ne la mentionne pas et selon les options de compilations cette macro sera rendue visible ou non✍.
Une démarche prudente, consiste donc à définir cette macro par nos propres moyen dans notre code source seulement si elle ne l'est pas déjà :

#ifndef M_PI
# define M_PI 3.14159265358979323846
#endif

Désormais, la fonction test_maths() peut être invoquée avec M_PI/3.0 comme paramètre effectif.

Relancez alors la fabrication du programme exécutable ; elle doit échouer !
Le problème ne se situe pas à la compilation (si vous avez bien inclus le fichier d'en-tête standard

<math.h>

), mais à l'édition de liens.
En effet, la bibliothèque mathématique est bien livrée en standard avec tous les outils de développement mais, contrairement à la bibliothèque standard du langage C (qui définit printf(), strlen(), malloc()...), elle n'est pas automatiquement ajoutée au programme lors de son édition de liens.
C'est donc à nous de spécifier à l'éditeur de liens le fait qu'il doit prendre en compte cette bibliothèque supplémentaire.

Pour ce faire, il nous faut intervenir sur le fichier GNUmakefile : la toute première ligne qui contient

LDFLAGS=

doit être complétée pour contenir

LDFLAGS=-lm

Cette variable du fichier GNUmakefile est transmise à la commande invoquant l'éditeur de liens.
Il comprend l'option -lm que nous venons d'ajouter comme ceci : il faut lier l'exécutable produit à une bibliothèque supplémentaire (préfixe -l) ; il s'agit de la bibliothèque mathématique (suffixe m ici, voir cette section)✍.
Une nouvelle relance de la fabrication du programme exécutable doit désormais aboutir avec succès.
Exécutez-le afin de vérifier qu'il affiche bien la valeur attendue.

Maintenant que nous avons réussi à utiliser une fonction de la bibliothèque mathématique, expérimentez-en quelques autres pour afficher des valeurs remarquables : la racine carrée de deux, l'exponentielle de un, le logarithme à base dix d'un centième...
(https://en.cppreference.com/w/c/numeric/math)
Remarquez qu'il existe aussi des fonctions à plusieurs paramètres ; c'est le cas par exemple de la fonction atan2() qui renvoie l'arc-tangente du rapport de ses deux paramètres sur le cercle trigonométrique complet✍.
Invoquez également cette fonction avec des valeurs remarquables.
Fabriquez à nouveau le programme et exécutez-le afin de vérifier que les valeurs obtenues sont conformes aux attentes.

{} Détection des valeurs extrêmes

Le programme doit maintenant être complété par un nouveau module composé du fichier de définition realArray.c et du fichier d'en-tête realArray.h qui respecteront les consignes usuelles en matière de programmation modulaire (voir ce chapitre).
On y trouvera notamment la fonction RealArray_minMax() suivante :

void
RealArray_minMax(const double *values,
                 int count,
                 double *out_minValue,
                 double *out_maxValue)
{
  double minValue=DBL_MAX, maxValue=-DBL_MAX;
  for(int i=0; i<count; ++i)
  {
    double value=values[i];
    minValue=fmin(minValue, value);
    maxValue=fmax(maxValue, value);
  }
  //-- store out-parameters --
  *out_minValue=minValue;
  *out_maxValue=maxValue;
}

Son rôle est de parcourir (en lecture seule) un tableau de valeurs réelles (désigné par un pointeur sur la première et leur nombre), pour mettre à jour deux variables du contexte appelant afin qu'elles contiennent respectivement les valeurs minimale et maximale rencontrées dans le tableau.
Nous pourrions déterminer chacune de ces valeurs extrêmes à l'aide d'un opérateur de comparaison et de l'opérateur ternaire ; toutefois, les processeurs sont généralement pourvus d'instructions spécialisées à cet effet qui sont rendues accessibles par les fonctions fmin() et fmax() de la bibliothèque mathématique.
(https://en.cppreference.com/w/c/numeric/math/fmin)
(https://en.cppreference.com/w/c/numeric/math/fmax)
Nous utiliserons donc ces fonctions lors du parcours du tableau, en prenant soin d'utiliser initialement DBL_MAX comme valeur minimale et -DBL_MAX comme valeur maximale (voir cette section).
De cette façon, toute valeur rencontrée sera respectivement inférieure et supérieure à ces valeurs initiales.
Il suffit alors d'appeler ses fonctions en leur transmettant l'extrême concerné et la valeur rencontrée afin d'ajuster ce même extrême.
À la sortie de la boucle, les valeurs extrêmes ont été déterminées ; il ne reste plus qu'à les transmettre au contexte appelant.

La fonction test_realArray() doit être réalisée dans le fichier prog10.c et appelée par le programme principal.

void
test_realArray(void)
{
  printf("\n~~~~ %s() ~~~~\n", __func__);
  double values[80];
  int count=(int)(sizeof(values)/sizeof(values[0]));
  for(int i=0; i<count; ++i)
  {
    values[i]=4.0*M_PI*i/count+M_PI/4.0;
  }
  double minValue, maxValue;
  RealArray_minMax(values, count, &minValue, &maxValue);
  printf("min=%g max=%g\n", minValue, maxValue);
}

L'initialisation du tableau est réalisée de façon à être adaptée aux prochaines étapes de l'expérimentation ; les valeurs choisies ici ont peu d'importance pour l'instant.
La fonction RealArray_minMax() nous permet d'en relever les valeurs extrêmes que nous affichons. Fabriquez à nouveau ce programme et exécutez-le afin de vérifier que ces deux valeurs sont bien cohérentes avec le contenu tableau.

{} Arrondi d'un réel vers un entier

La bibliothèque mathématique propose plusieurs fonctions pour déterminer une valeur entière approchée d'une valeur réelle.
Parmi celles-ci nous trouvons principalement :

floor(), l'arrondi à l'entier par défaut : le résultat est systématiquement inférieur ou égal au paramètre,
(https://en.cppreference.com/w/c/numeric/math/floor)
ceil(), l'arrondi à l'entier par excès : le résultat est systématiquement supérieur ou égal au paramètre,
(https://en.cppreference.com/w/c/numeric/math/ceil)
trunc(), la troncature de la partie décimale : le résultat est inférieur ou égal au paramètre s'il est positif ou bien supérieur ou égal au paramètre s'il est négatif (comme dans le cas du cast vers un entier),
(https://en.cppreference.com/w/c/numeric/math/trunc)
round(), l'arrondi à l'entier le plus proche : si la partie décimale du paramètre est supérieure ou égale à 0.5, alors le résultat est l'entier ayant la valeur absolue supérieure, ou celui ayant la valeur absolue inférieure dans le cas contraire.
(https://en.cppreference.com/w/c/numeric/math/round)

Remarquez que, bien qu'elles déterminent toutes une valeur privée de décimales, le résultat de ces fonctions est toujours de type réel ; du point de vue du langage C, si nous souhaitons en faire un véritable entier, un cast est encore nécessaire.

Nous nous proposons ici d'en faire usage en ajoutant au module realArray la fonction RealArray_display() suivante :

void
RealArray_display(const double *values,
                  int count,
                  double minValue,
                  double maxValue)
{
  double valueRange=maxValue-minValue;
  int first=8, last=70, range=last-first+1;
  int zero=first+(int)round(range*(-minValue)/valueRange);
  for(int i=0; i<count; ++i)
  {
    double value=values[i];
    int step=first+(int)round(range*(value-minValue)/valueRange);
    char symbol=step>zero ? '>' : step<zero ? '<' : 'X';
    for(int s=0; s<=78; ++s)
    {
      char c=' ';
      if(step==s)
      {
        c=symbol;
      }
      else if(s==zero)
      {
        c='|';
      }
      else if(((step<=s)&&(s<=zero))||((zero<=s)&&(s<=step)))
      {
        c='~';
      }
      fputc(c, stdout);
    }
    fputc('\n', stdout);
  }
}

Elle représente sous forme de barres textuelles horizontales de longueurs variables les valeurs réelles contenues dans le tableau.
Il s'agit bien d'un problème de conversion d'une valeur réelle en un nombre entier de symboles textuels pour la représenter.
Nous choisissons ici l'arrondi à l'entier le plus proche afin de représenter le plus fidèlement possible la valeur réelle initiale.
La fonction RealArray_display() sera alors utilisée dans la fonction test_realArray() afin de représenter le contenu du tableau.
Fabriquez à nouveau ce programme et exécutez-le afin de vérifier que vous obtenez bien une rampe croissante cohérente avec le contenu du tableau.

Pour un affichage plus explicite, il faut maintenant compléter le module realArray avec la fonction RealArray_sin().

void
RealArray_sin(double *values,
              int count)
{
  for(int i=0; i<count; ++i)
  {
    values[i]=sin(values[i]);
  }
}

Elle remplace chaque valeur réelle du tableau qu'on lui transmet par le résultat de la fonction sin() (sinus) qui lui est appliquée.
Elle doit être utilisée sur le tableau de la fonction test_realArray().

{
  ...
  printf("sin():\n");
  RealArray_sin(values, count);
  RealArray_minMax(values, count, &minValue, &maxValue);
  printf("min=%g max=%g\n", minValue, maxValue);
  RealArray_display(values, count, minValue, maxValue);
  ...
}

Les nouvelles valeurs extrêmes du tableau sont alors déterminées et affichées avant d'invoquer l'affichage sous forme de barres textuelles horizontales. (https://en.cppreference.com/w/c/numeric/math/sin)
Fabriquez à nouveau ce programme et exécutez-le afin de vérifier que les valeurs extrêmes sont bien celles de la sinusoïde et que cette dernière effectue bien deux tours de cercle trigonométrique avec un déphasage d'un huitième de tour.

{} Les valeurs réelles anormales

Contrairement aux entiers pour lesquels toutes les combinaisons de bits s'interprètent comme une valeur entière, il existe des combinaisons de bits dans la représentation des réels qui ne correspondent à aucune valeur réelle finie.
(https://en.wikipedia.org/wiki/IEEE_floating_point)
La bibliothèque mathématique fournit notamment la fonction fpclassify() qui permet de classifier la représentation d'un réel selon une variété de catégories (valeur normale, infinie, not-a-number...)✍.
(https://en.cppreference.com/w/c/numeric/math/fpclassify)

Ceci donne à chaque fonction mathématique l'opportunité de renvoyer un résultat qui signifie clairement que nous l'utilisons en dehors de son domaine de définition.
Pour expérimenter ce comportement, complétons le module realArray par la fonction RealArray_sqrt().

void
RealArray_sqrt(double *values,
               int count)
{
  for(int i=0; i<count; ++i)
  {
    values[i]=sqrt(values[i]);
  }
}

Elle remplace chaque valeur réelle du tableau qu'on lui transmet par le résultat de la fonction sqrt() (racine carrée) qui lui est appliquée.
(https://en.cppreference.com/w/c/numeric/math/sqrt)
Elle devra être utilisée, après le calcul des sinus, sur le tableau de la fonction test_realArray().

{
  ...
  printf("sqrt(sin()):\n");
  RealArray_sqrt(values, count);
  RealArray_minMax(values, count, &minValue, &maxValue);
  printf("min=%g max=%g\n", minValue, maxValue);
  RealArray_display(values, count, minValue, maxValue);
  ...
}

Les nouvelles valeurs extrêmes du tableau sont déterminées et affichées avant d'invoquer l'affichage sous forme de barres textuelles horizontales.
Fabriquez à nouveau ce programme et exécutez-le afin de vérifier que les valeurs extrêmes sont bien positives ou nulles (à cause de la racine carrée) et que les lobes positifs de la sinusoïde on bien été déformés par cette opération.
En revanche, vous devez constater que l'affichage des barres textuelles horizontales est aberrant sur les lobes négatifs de la sinusoïde : les barres partent inexorablement vers les valeurs négatives alors que la valeur minimale détectée est proche de zéro !

Cela est dû au fait que sur ces derniers lobes nous tentons de déterminer la racine carrée d'un nombre négatif.
La fonction sqrt() détecte cette incohérence et fournit le résultat NAN (not-a-number) signifiant que nous sortons de son domaine de définition.
Il est intéressant de remarquer que les fonctions fmin() et fmax() utilisées pour déterminer les valeurs extrêmes du tableau ne considèrent jamais cette valeur anormale comme étant inférieure ou supérieure à toute autre valeur.
Pour vous en convaincre, affichez alors simplement sous forme de texte les valeurs du tableau dans la fonction test_realArray().

{
  ...
  for(int i=0; i<count; ++i)
  {
    printf("%g ", values[i]);
  }
  printf("\n");
  ...
}

Après une nouvelle fabrication du programme, son exécution devrait faire apparaître ces valeurs anormales avec le texte nan.

Pour corriger l'affichage sous forme de barres textuelles horizontales, il nous faut être en mesure de déterminer si une valeur réelle est finie ou anormale.
La bibliothèque mathématique nous propose à cet effet la fonction standard isfinite().
(https://en.cppreference.com/w/c/numeric/math/isfinite)
Intervenez alors sur la fonction RealArray_display() pour modifier l'initialisation des variables step et symbol.

{
  ...
    int step=zero;
    char symbol='?';
    if(isfinite(value))
    {
      step=first+(int)round(range*(value-minValue)/valueRange);
      symbol=step>zero ? '>' : step<zero ? '<' : 'X';
    }
  ...
}

Fabriquez à nouveau ce programme et exécutez-le afin de vérifier que l'affichage fait apparaître des points d'interrogation pour représenter les valeurs du tableau qui ne sont pas finies.

{} Génération pseudo-aléatoire

Il n'est pas rare d'avoir à recours à des données générées aléatoirement.
C'est le cas par exemple des simulations numériques selon la méthode de Monte-Carlo, du test de composants logiciels par la méthode de fuzzing, ou encore des jeux qui rendent l'animation des personnages et des décors imprévisibles.
La bibliothèque standard du langage C propose une fonctionnalité en ce sens.

{} Obtention de valeurs pseudo-aléatoires

Le programme principal du fichier prog10.c doit faire appel à la fonction test_rand() qui sera réalisée dans ce même fichier.

void
test_rand(void)
{
  printf("\n~~~~ %s() ~~~~\n", __func__);
  for(int i=0; i<10; ++i)
  {
    printf("%d\n", rand());
  }
}

Pour l'instant, cette dernière se contente d'afficher une dizaine de valeurs entières obtenues par la fonction standard rand() déclarée dans le fichier d'en-tête standard

<stdlib.h>

.
(https://en.cppreference.com/w/c/numeric/random/rand)
Fabriquez à nouveau ce programme et exécutez-le afin de vérifier qu'apparaît bien une séquence de valeurs entières a priori imprévisibles ; elles semblent donc aléatoires.

Toutefois, en relançant ce programme à plusieurs reprises, nous constatons que la séquence de valeurs entières obtenue est à chaque fois identique : le procédé sous-jacent est dit pseudo-aléatoire.
Un tel procédé repose sur un algorithme totalement déterministe qui doit être initialisé.
Pour une initialisation donnée, la séquence de valeurs obtenue sera toujours identique, mais des initialisations différentes donneront des séquences radicalement différentes.
Ces séquences, bien que déterministes, donnent aux êtres humains qui les observent l'illusion que les valeurs apparaissent dans un ordre complètement imprévisible.
De plus, l'algorithme de génération pseudo-aléatoire est conçu de façon à ce que chaque séquence désigne toutes les valeurs possibles de manière équiprobable.

Si nous souhaitons obtenir à chaque nouvelle exécution une séquence pseudo-aléatoire différente, il nous faut initialiser explicitement le générateur avec une graine (seed).
La fonction standard srand(), déclarée elle aussi dans le fichier d'en-tête standard

<stdlib.h>

, sert ce propos.
(https://en.cppreference.com/w/c/numeric/random/srand)
Seulement, le choix de cette graine est tout aussi problématique puisqu'une valeur constante spécifiée dans le code source produirait elle aussi toujours la même séquence à chaque exécution.

Une solution très commune consiste à rendre la graine dépendante du temps.
Pour ceci, le fichier d'en-tête standard

<time.h>

déclare la fonction standard time() qui fournit une valeur qui évolue à chaque seconde.
(https://en.cppreference.com/w/c/chrono/time)
Il nous suffit donc d'ajouter au début de la fonction main() l'appel suivant :

{
  ...
  srand((unsigned int)time(NULL));
  ...
}

pour que tous les tirages aléatoires de notre programme soient différents à chacune de ses exécutions✍.
Fabriquez à nouveau ce programme et exécutez-le plusieurs fois afin de vérifier que la séquence de valeurs entières pseudo-aléatoires est bien différente à chaque relance.

{} Choix de la plage de valeurs pseudo-aléatoires

La documentation de la fonction rand() nous indique que l'entier renvoyé est compris entre 0 et la constante RAND_MAX (incluse)✍ ; une telle valeur est difficilement exploitable directement.
Il est en effet assez courant d'avoir à choisir une valeur dans une plage déterminée par les conditions applicatives.
Un moyen très simple d'y parvenir consiste à appliquer l'opérateur % (modulo, le reste de la division entière) au résultat de rand() avec comme second opérande la largeur de la plage de valeurs choisie.
Ainsi, l'expression rand()%N fournit bien un entier pseudo-aléatoire compris entre 0 et N-1 (inclus).
Complétez alors la fonction test_rand() pour tirer et afficher une centaine de valeurs pouvant valoir de 0 jusqu'à 9.

{
  ...
  for(int i=0; i<100; ++i)
  {
    printf("%d ", rand()%10);
  }
  printf("\n");
  ...
}

Fabriquez à nouveau ce programme et exécutez-le afin de vérifier que toutes ces valeurs sont bien tirées et qu'aucune autre ne l'est.

Puisque le générateur se veut équiprobable, nous pouvons l'exploiter pour déclencher un événement avec une probabilité de la forme : k fois sur N.
Il suffit pour cela d'effectuer un tirage entre 0 et N-1 et de tester si la valeur obtenue est strictement inférieure à k.
Complétez alors la fonction test_rand() pour effectuer un million de tirages et compter ceux qui obéissent à la probabilité : trois fois sur dix.

{
  ...
  int successCount=0, drawCount=1000000;
  for(int i=0; i<drawCount; ++i)
  {
    if((rand()%10)<3)
    {
      ++successCount;
    }
  }
  printf("%d successes out of %d draws\n", successCount, drawCount);
  ...
}

Fabriquez à nouveau ce programme et exécutez-le afin de vérifier que le nombre de tirages respectant ce critère avoisine bien les trois dixièmes du nombre total de tirages (trois-cents mille).

{} Distributions de valeurs pseudo-aléatoires réelles

Il est très courant d'avoir besoin de valeurs pseudo-aléatoires qui soient réelles.
Il est même parfois nécessaire de choisir une loi de distribution de ces valeurs.
Il en existe de très nombreuse ; nous n'en aborderons ici que deux très classiques.
(https://en.wikipedia.org/wiki/List_of_probability_distributions)

Le programme doit maintenant être complété par un nouveau module composé du fichier de définition random.c et du fichier d'en-tête random.h qui respecteront les consignes usuelles en matière de programmation modulaire (voir ce chapitre).
Ce module doit fournir la fonction Random_uniform() suivante :

double // random value in [0.0,1.0)
Random_uniform(void)
{
  return rand()/(RAND_MAX+1.0);
}

Son rôle est de fournir une valeur réelle pseudo-aléatoire comprise entre 0.0 (inclus) et 1.0 (exclus).
La distribution de cette fonction est uniforme c'est-à-dire que toutes les valeurs de l'intervalle sont équiprobables.
Un tel résultat est facile à obtenir puisque nous savons que la distribution de la fonction standard rand() est elle-même équiprobable sur l'intervalle [0;RAND_MAX].
Il suffit donc de diviser la valeur entière obtenue par le réel RAND_MAX+1.0.

Le programme principal du fichier prog10.c doit faire appel à une nouvelle fonction test_distribution() qui sera réalisée dans ce même fichier.

void
test_distribution(void)
{
  printf("\n~~~~ %s() ~~~~\n", __func__);
  int drawCount=1000000;
  double values[40]={0.0};
  int count=(int)(sizeof(values)/sizeof(values[0]));
  printf("uniform distribution:\n");
  for(int i=0; i<drawCount; ++i)
  {
    int r=(int)(count*Random_uniform());
    values[r]+=1.0/drawCount;
  }
  RealArray_display(values, count, 0.0, 1.0/count);
}

Cette fonction déclare un tableau de quelques dizaines de réels, tous nuls initialement, et évalue dans la variable count le nombre d'éléments de ce tableau.
Ce tableau sert à déterminer l'histogramme d'un million de tirages aléatoires avec la fonction Random_uniform().
Pour cela, le résultat du tirage (dans [0.0;1.0)) est multiplié par count et la partie entière de cette valeur désigne une case du tableau (dans [0;count-1]) à laquelle on ajoute un millionième.
La fonction RealArray_display() sert alors à visualiser le tableau avec 0.0 comme valeur minimale et 1.0/count comme valeur maximale.
Fabriquez à nouveau ce programme et exécutez-le afin de vérifier que la distribution des valeurs aléatoires tirées est bien uniformément répartie dans toutes les cases du tableau.

Une seconde distribution aléatoire sera réalisée dans le module random par la fonction Random_gaussian().

double // random value with mean 0.0 and standard-deviation 1.0
Random_gaussian(void)
{
  double r1=Random_uniform();
  double r2=Random_uniform();
  return sin(2.0*M_PI*r1)*sqrt(-2.0*log(1.0-r2)); // Box-Muller method
}

Il s'agit d'une gaussienne de moyenne 0.0 et d'écart-type 1.0.
(https://en.wikipedia.org/wiki/Normal_distribution)
Elle génère une telle valeur aléatoire à partir de deux valeurs aléatoires uniformes selon la méthode de Box-Muller.
(https://en.wikipedia.org/wiki/Box-Muller_transform)

La fonction test_distribution() doit être à nouveau complétée en réinitialisant chaque élément du tableau à 0.0 et en constituant à nouveau un histogramme d'un million de tirages provenant de la fonction Random_gaussian().

{
  ...
  printf("gaussian distribution:\n");
  for(int i=0; i<count; ++i)
  {
    values[i]=0.0;
  }
  double mean=0.5*count;
  double stdDev=0.15*count;
  for(int i=0; i<drawCount; ++i)
  {
    int r=(int)(mean+stdDev*Random_gaussian());
    if((r>=0)&&(r<count))
    {
      values[r]+=1.0/drawCount;
    }
  }
  RealArray_display(values, count, 0.0, 1.0/sqrt(2.0*M_PI*stdDev*stdDev));
  ...
}

Toutefois, contrairement à la distribution uniforme qui borne l'intervalle de ses valeurs possibles, la distribution gaussienne délivre des valeurs aléatoires non bornées.
Pour que cette gaussienne recouvre correctement la largeur de l'histogramme, nous choisissons une moyenne mean=0.5*count et un écart-type stdDev=0.15*count ; la valeur aléatoire retenue sera alors mean+stdDev*Random_gaussian().
Puisque celle-ci n'est pas bornée, nous veillons à n'ajouter un millionième à l'histogramme que si la partie entière de cette valeur est bien dans l'intervalle [0;count-1].
La fonction RealArray_display() sert à nouveau à visualiser le tableau avec 0.0 comme valeur minimale et 1.0/sqrt(2.0*M_PI*stdDev*stdDev) (le sommet de la gaussienne) comme valeur maximale.
Fabriquez à nouveau ce programme et exécutez-le afin de vérifier que la distribution des valeurs aléatoires tirées a bien la répartition gaussienne attendue.

Code source de l'expérimentation

Si chaque étape a été respectée scrupuleusement, vous devez obtenir des fichiers de code source et semblables à ceux-ci :

Fichier realArray.h✎

Fichier realArray.c✎

Fichier random.h✎

Fichier random.c✎

Fichier prog10.c✎

Contenu du fichier prog10.c

//----------------------------------------------------------------------------

#include <stdio.h>
#include <math.h>
#include <stdlib.h>
#include <time.h>
#include "realArray.h"
#include "random.h"

#ifndef M_PI
# define M_PI 3.14159265358979323846
#endif

void
test_maths(double x)
{
  printf("\n~~~~ %s() ~~~~\n", __func__);
  printf("cos(%g)=%g\n", x, cos(x));
  printf("sqrt(2.0)=%g\n", sqrt(2.0));
  printf("exp(1.0)=%g\n", exp(1.0));
  printf("log10(0.01)=%g\n", log10(0.01));
  printf("atan2(-1.0,1.0)=%g\n", atan2(-1.0,1.0));
}

void
test_realArray(void)
{
  printf("\n~~~~ %s() ~~~~\n", __func__);
  double values[80];
  int count=(int)(sizeof(values)/sizeof(values[0]));
  for(int i=0; i<count; ++i)
  {
    values[i]=4.0*M_PI*i/count+M_PI/4.0;
  }
  double minValue, maxValue;
  RealArray_minMax(values, count, &minValue, &maxValue);
  printf("min=%g max=%g\n", minValue, maxValue);
  RealArray_display(values, count, minValue, maxValue);
  printf("sin():\n");
  RealArray_sin(values, count);
  RealArray_minMax(values, count, &minValue, &maxValue);
  printf("min=%g max=%g\n", minValue, maxValue);
  RealArray_display(values, count, minValue, maxValue);
  printf("sqrt(sin()):\n");
  RealArray_sqrt(values, count);
  RealArray_minMax(values, count, &minValue, &maxValue);
  printf("min=%g max=%g\n", minValue, maxValue);
  RealArray_display(values, count, minValue, maxValue);
  for(int i=0; i<count; ++i)
  {
    printf("%g ", values[i]);
  }
  printf("\n");
}

void
test_rand(void)
{
  printf("\n~~~~ %s() ~~~~\n", __func__);
  for(int i=0; i<10; ++i)
  {
    printf("%d\n", rand());
  }
  for(int i=0; i<100; ++i)
  {
    printf("%d ", rand()%10);
  }
  printf("\n");
  int successCount=0, drawCount=1000000;
  for(int i=0; i<drawCount; ++i)
  {
    if((rand()%10)<3)
    {
      ++successCount;
    }
  }
  printf("%d successes out of %d draws\n", successCount, drawCount);
}

void
test_distribution(void)
{
  printf("\n~~~~ %s() ~~~~\n", __func__);
  int drawCount=1000000;
  double values[40]={0.0};
  int count=(int)(sizeof(values)/sizeof(values[0]));
  printf("uniform distribution:\n");
  for(int i=0; i<drawCount; ++i)
  {
    int r=(int)(count*Random_uniform());
    values[r]+=1.0/drawCount;
  }
  RealArray_display(values, count, 0.0, 1.0/count);
  printf("gaussian distribution:\n");
  for(int i=0; i<count; ++i)
  {
    values[i]=0.0;
  }
  double mean=0.5*count;
  double stdDev=0.15*count;
  for(int i=0; i<drawCount; ++i)
  {
    int r=(int)(mean+stdDev*Random_gaussian());
    if((r>=0)&&(r<count))
    {
      values[r]+=1.0/drawCount;
    }
  }
  RealArray_display(values, count, 0.0, 1.0/sqrt(2.0*M_PI*stdDev*stdDev));
}

int
main(void)
{
  srand((unsigned int)time(NULL));
  test_maths(M_PI/3.0);
  test_realArray();
  test_rand();
  test_distribution();
  return 0;
}

//----------------------------------------------------------------------------