ENIB LANG-C Ex_1001 - Fonctions mathématiques et tirages aléatoires

Connaissances requises pour cet exercice

Réaliser l'édition de liens avec la bibliothèques mathématique standard (ajout de l'option -lm).
Utiliser des fonctions de la bibliothèques mathématique standard.
Initialiser le générateur de nombres pseudo-aléatoires standard (srand() avec le résultat de time()).
Générer des nombres aléatoires entiers et réels.
- Utiliser % (modulo) pour restreindre la plage de valeurs entières.
- Utiliser RAND_MAX (converti en réel) pour obtenir un réel entre 0.0 et 1.0.

{1} Première variante

D'une part, il faut déclarer et définir dans les fichiers random.h et random.c la fonction suivante :

double
rndPrecision(int decimals)
{
  // ...
}

Son rôle est de fournir un réel aléatoire dans l'intervalle semi-ouvert [0.0;1.0[, ayant au maximum le nombre de décimales indiqué en paramètre✍

Par exemple :

avec une décimale, le résultat sera parmi 0.0, 0.1, 0.2 ... 0.7, 0.8 ou 0.9,
avec deux décimales, le résultat sera parmi 0.0, 0.01, 0.02 ... 0.97, 0.98 ou 0.99,
avec trois décimales, le résultat sera parmi 0.0, 0.001, 0.002 ... 0.997, 0.998 ou 0.999,
avec quatre décimales, le résultat sera parmi 0.0, 0.0001, 0.0002 ... 0.9997, 0.9998 ou 0.9999,
...

.
Elle comporte trois étapes :

obtenir la puissance de dix correspondant au nombre de décimales choisi✍
10 pour une décimale, 100 pour deux, 1000 pour trois...
; la fonction mathématique standard pow() vous servira à ce propos pour calculer 10^decimals,
tirer aléatoirement un entier dans cette plage de valeurs✍
De 0 à 9 pour une décimale, de 0 à 99 pour deux, de 0 à 999 pour trois...
,
diviser cet entier aléatoire par cette plage de valeurs pour obtenir un réel dans [0.0;1.0[.

D'autre part, il faut réaliser, dans le fichier prog_ex1001.c, cette fonction :

void
test_rndPrecision(void)
{
  printf("\n~~~~ %s() ~~~~\n", __func__);
  for(int p=1; p<=4; ++p)
  {
    printf("precision: %d\n", p);

    // ...invoquer un nombre significatif de fois rndPrecision()...

    printf("\n");
  }
}

qui sera appelée depuis la fonction main().
Pour chaque précision choisie, elle doit afficher une séquence de résultats de la fonction rndPrecision() afin d'en constater l'effet.
Il faudra avoir pris soin d'initialiser le générateur pseudo-aléatoire afin que les séquences obtenues ne soient pas identiques à chaque exécution du programme.

{2} Deuxième variante

D'une part, il faut déclarer et définir dans les fichiers random.h et random.c la fonction suivante :

double
rndDecibel(double maxLinearGain)
{
  // ...
}

Son rôle est de fournir un réel aléatoire représentant un gain en décibels inférieur ou égal à un gain maximal exprimé de manière linéaire transmis en paramètre✍

Par exemple :

avec un gain maximal linéaire de √ 2.0 , le résultat sera compris entre 0.0 et 3.0 dB,
avec un gain maximal linéaire de 2.0, le résultat sera compris entre 0.0 et 6.0 dB,
avec un gain maximal linéaire de 2√ 2.0 , le résultat sera compris entre 0.0 et 9.0 dB,
avec un gain maximal linéaire de 4.0, le résultat sera compris entre 0.0 et 12.0 dB,
...

.
Elle comporte trois étapes :

obtenir le gain maximal en décibels correspondant au gain maximal linéaire ; la fonction mathématique standard log10() vous servira à ce propos pour calculer 20.log₁₀maxLinearGain,
tirer aléatoirement un réel dans l'intervalle [0.0;1.0],
multiplier ce réel aléatoire par le gain maximal en décibels.

D'autre part, il faut réaliser, dans le fichier prog_ex1001.c, cette fonction :

void
test_rndDecibel(void)
{
  printf("\n~~~~ %s() ~~~~\n", __func__);
  double gain=1.0;
  for(int i=0; i<4; ++i)
  {
    gain*=1.4142135623730951; // square-root of 2.0
    printf("max linear gain: %g\n", gain);

    // ...invoquer un nombre significatif de fois rndDecibel()...

    printf("\n");
  }
}

qui sera appelée depuis la fonction main().
Pour chaque gain linéaire maximal choisi, elle doit afficher une séquence de résultats de la fonction rndDecibel() afin d'en constater l'effet.
Il faudra avoir pris soin d'initialiser le générateur pseudo-aléatoire afin que les séquences obtenues ne soient pas identiques à chaque exécution du programme.

{3} Troisième variante

D'une part, il faut déclarer et définir dans les fichiers random.h et random.c la fonction suivante :

bool
rndDetect(double angle)
{
  // ...
}

Son rôle est d'indiquer par son résultat si un objet visible sous un certain angle a été détecté ou non✍

Par exemple :

si l'objet est pile en face (l'angle est proche de 0.0), alors il doit être détecté presque à coup sûr,
si l'objet se décale légèrement sur le côté (l'angle augmente) alors il doit être détecté moins souvent,
si l'objet est complètement sur le côté (l'angle est proche de 1.57, c'est-à-dire π/2), alors il n'est quasiment jamais détecté.

.
Elle comporte trois étapes :

calculer le cosinus de l'angle,
tirer aléatoirement un réel dans l'intervalle [0.0;1.0],
tester si ce réel aléatoire est inférieur au cosinus calculé.

D'autre part, il faut réaliser, dans le fichier prog_ex1001.c, cette fonction :

void
test_rndDetect(void)
{
  printf("\n~~~~ %s() ~~~~\n", __func__);
  for(int i=0; i<4; ++i)
  {
    const double angle=0.2+0.4*i;
    printf("detection for angle %g:\n", angle);

    // ...invoquer un nombre significatif de fois rndDetect()...

    printf("\n");
  }
}

qui sera appelée depuis la fonction main().
Pour chaque angle choisi, elle doit afficher une séquence de résultats de la fonction rndDetect() afin d'en constater l'effet.
Il faudra avoir pris soin d'initialiser le générateur pseudo-aléatoire afin que les séquences obtenues ne soient pas identiques à chaque exécution du programme.

Les règles de mise en œuvre et d'écriture recommandées dans toutes nos réalisations doivent impérativement être respectées.
(#ifndef..., fichiers d'en-tête, programmation modulaire...)
Seule la fonction de test produit des affichages (la fonctionnalité testée rend son service silencieusement) ; un examen attentif des affichages produits doit permettre de vérifier le bon fonctionnement de la fonctionnalité testée.
L'utilisation des fonctions mathématiques et aléatoires conventionnelles constitue l'essentiel de l'exercice ; il n'est pas question de recourir à une formulation alternative qui produirait malgré tout un résultat équivalent.

Code source résultant

Si vous suivez scrupuleusement les énoncés et les consignes, vous devez obtenir des fichiers de code source semblables à ceux-ci :

Fichier random.h✎

Contenu du fichier random.h

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

#ifndef RANDOM_H
#define RANDOM_H

#include <stdbool.h>

double
rndPrecision(int decimals);

double
rndDecibel(double maxLinearGain);

bool
rndDetect(double angle);

#endif // RANDOM_H

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

Fichier random.c✎

Contenu du fichier random.c

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

#include "random.h"

#include <stdlib.h>
#include <math.h>

double
rndPrecision(int decimals)
{
  const int multiple=(int)pow(10.0, decimals);
  return rand()%multiple/(double)multiple;
}

double
rndDecibel(double maxLinearGain)
{
  const double dB=20.0*log10(maxLinearGain);
  return dB*rand()/RAND_MAX;
}

bool
rndDetect(double angle)
{
  return (rand()/(double)RAND_MAX)<cos(angle);
}

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

Fichier prog_ex1001.c✎

Contenu du fichier prog_ex1001.c

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

#include "random.h"

#include <stdio.h>
#include <stdlib.h>
#include <time.h>

void
test_rndPrecision(void)
{
  printf("\n~~~~ %s() ~~~~\n", __func__);
  for(int p=1; p<=4; ++p)
  {
    printf("precision: %d\n", p);
    for(int i=0; i<9; ++i)
    {
      printf(" %g", rndPrecision(p));
    }
    printf("\n");
  }
}

void
test_rndDecibel(void)
{
  printf("\n~~~~ %s() ~~~~\n", __func__);
  double gain=1.0;
  for(int i=0; i<4; ++i)
  {
    gain*=1.4142135623730951; // square-root of 2.0
    printf("max linear gain: %g\n", gain);
    for(int i=0; i<9; ++i)
    {
      printf(" %g", rndDecibel(gain));
    }
    printf("\n");
  }
}

void
test_rndDetect(void)
{
  printf("\n~~~~ %s() ~~~~\n", __func__);
  for(int i=0; i<4; ++i)
  {
    const double angle=0.2+0.4*i;
    printf("detection for angle %g:\n", angle);
    for(int i=0; i<30; ++i)
    {
      printf(" %d", rndDetect(angle));
    }
    printf("\n");
  }
}

int
main(void)
{
  srand((unsigned int)time(NULL));
  test_rndPrecision();
  test_rndDecibel();
  test_rndDetect();
  return 0;
}

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