ENIB LANG-C Ex_0301 - Capacité et précision des types

Connaissances requises pour cet exercice

Prendre en considération les limites des types choisis.
- Dépassement de capacité ou perte de précision lors des calculs.
- Distinguer les propriétés des réels, des entiers, notamment ceux du fichier d'en-tête standard
```
<stdint.h>
```
  .
- Choisir les types en fonction des plages de valeurs attendues.
Utiliser l'opération de conversion explicite de type (cast)
- Pour signifier au compilateur le fait que nous assumons la perte d'une partie de l'information manipulée.
- Pour forcer le compilateur à utiliser une représentation qui évitera de perdre une partie de l'information manipulée.

{1} Première variante

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

double
aspectRatio(int32_t width,
            int32_t height)
{
  return width/height;
}

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

void
test_aspectRatio(void)
{
  printf("\n~~~~ test_aspectRatio() ~~~~\n");
  printf(" 640 x  480 --> %g\n", aspectRatio( 640,  480));
  printf("1280 x 1024 --> %g\n", aspectRatio(1280, 1024));
  printf("1920 x 1080 --> %g\n", aspectRatio(1920, 1080));
}

qui sera appelée depuis la fonction main().
Les résultats attendus pour ces trois invocations de la fonction aspectRatio() sont respectivement : 1.33333, 1.25 et 1.77778.
Seulement, vous devriez constater qu'en l'état les résultats obtenus sont tout autres !
Intervenez alors dans la définition de la fonction aspectRatio() (pas sa déclaration !) pour que les résultats obtenus soient effectivement conformes à ce que la formule de calcul suggère.

{2} Deuxième variante

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

int64_t
adjustMeasure(int32_t increment,
              int32_t factor,
              int32_t value)
{
  return increment+factor*value;
}

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

void
test_adjustMeasure(void)
{
  printf("\n~~~~ test_adjustMeasure() ~~~~\n");
  printf("10k + 12k *  3M --> %ld\n", adjustMeasure(10000,   12000, 3000000));
  printf(" 1k +  2M *  4M --> %ld\n", adjustMeasure( 1000, 2000000, 4000000));
  printf("90k + 90k * 90k --> %ld\n", adjustMeasure(90000,   90000,   90000));
}

qui sera appelée depuis la fonction main().
Les résultats attendus pour ces trois invocations de la fonction adjustMeasure() sont respectivement : 36000010000, 8000000001000 et 8100090000.
Seulement, vous devriez constater qu'en l'état les résultats obtenus sont tout autres !
Intervenez alors dans la définition de la fonction adjustMeasure() (pas sa déclaration !) pour que les résultats obtenus soient effectivement conformes à ce que la formule de calcul suggère.

{3} Troisième variante

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

int32_t
rescale(int32_t value,
        int32_t oldRange,
        int32_t newRange)
{
  return value/oldRange*newRange;
}

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

void
test_rescale(void)
{
  printf("\n~~~~ test_rescale() ~~~~\n");
  printf(" 12/20   --> %d/100\n", rescale(12,  20, 100));
  printf(" 68/100  --> %d/300\n", rescale(68, 100, 300));
  printf("90k/100k --> %d/50k\n", rescale(90000, 100000, 50000));
}

qui sera appelée depuis la fonction main().
Les résultats attendus pour ces trois invocations de la fonction rescale() sont respectivement : 60, 204 et 45000.
Seulement, vous devriez constater qu'en l'état les résultats obtenus sont tout autres !
Intervenez alors dans la définition de la fonction rescale() (pas sa déclaration !) pour que les résultats obtenus soient effectivement conformes à ce que la formule de calcul suggère.

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.
Le choix des types, des conversions, et l'ordre des opérations pour effectuer les calculs en respectant les contraintes de capacité et de précision 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 types.h✎

Contenu du fichier types.h

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

#ifndef TYPES_H
#define TYPES_H

#include <stdint.h>

double
aspectRatio(int32_t width,
            int32_t height);

int64_t
adjustMeasure(int32_t increment,
              int32_t factor,
              int32_t value);

int32_t
rescale(int32_t value,
        int32_t oldRange,
        int32_t newRange);

#endif // TYPES_H

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

Fichier types.c✎

Contenu du fichier types.c

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

#include "types.h"

double
aspectRatio(int32_t width,
            int32_t height)
{
  // return width/height; // incorrect
  return (double)width/(double)height;
}

int64_t
adjustMeasure(int32_t increment,
              int32_t factor,
              int32_t value)
{
  // return increment+factor*value; // incorrect
  return (int64_t)increment+(int64_t)factor*(int64_t)value;
}

int32_t
rescale(int32_t value,
        int32_t oldRange,
        int32_t newRange)
{
  // return value/oldRange*newRange; // incorrect
  return (int32_t)((int64_t)value*(int64_t)newRange/(int64_t)oldRange);
  // alternative version:
  // return (int32_t)((double)value/(double)oldRange*(double)newRange);
}

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

Fichier prog_ex0301.c✎

Contenu du fichier prog_ex0301.c

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

#include "types.h"

#include <stdio.h>

void
test_aspectRatio(void)
{
  printf("\n~~~~ test_aspectRatio() ~~~~\n");
  printf(" 640 x  480 --> %g\n", aspectRatio( 640,  480));
  printf("1280 x 1024 --> %g\n", aspectRatio(1280, 1024));
  printf("1920 x 1080 --> %g\n", aspectRatio(1920, 1080));
}

void
test_adjustMeasure(void)
{
  printf("\n~~~~ test_adjustMeasure() ~~~~\n");
  printf("10k + 12k *  3M --> %ld\n", adjustMeasure(10000,   12000, 3000000));
  printf(" 1k +  2M *  4M --> %ld\n", adjustMeasure( 1000, 2000000, 4000000));
  printf("90k + 90k * 90k --> %ld\n", adjustMeasure(90000,   90000,   90000));
}

void
test_rescale(void)
{
  printf("\n~~~~ test_rescale() ~~~~\n");
  printf(" 12/20   --> %d/100\n", rescale(12,  20, 100));
  printf(" 68/100  --> %d/300\n", rescale(68, 100, 300));
  printf("90k/100k --> %d/50k\n", rescale(90000, 100000, 50000));
}

int
main(void)
{
  test_aspectRatio();
  test_adjustMeasure();
  test_rescale();
  return 0;
}

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