ENIB LANG-C Ex_1101 - Réalisation d'un traitement générique

{1} Première variante

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

void
transformReals(double *values,
               int valueCount,
               /* ...function pointer... */ fnct,
               /* ...generic pointer... */ params)
{
  for(int i=0; i<valueCount; ++i)
  {
    values[i]= /* ...use fnct with values[i] and params... */;
  }
}

Son rôle est de transformer chacun des éléments d'un tableau de réels grâce à l'utilisation de la fonction transmise par pointeur (ainsi que ses paramètres génériques).
Il faudra bien entendu inventer un type correspondant à l'usage que nous faisons de fnct :

il s'agit d'un pointeur sur fonctions,
attendant en paramètres un réel et un pointeur générique,
renvoyant un résultat réel.

D'autre part, il faut réaliser, dans le fichier prog_ex1101.c, ces fonctions :

double
scaleAndAdd(double value,
            /* ...generic pointer... */ params)
{
  const double factor= /* ...obtain from params... */;
  const double increment= /* ...obtain from params... */;
  return value*factor+increment;
}

void
test_transformReals(void)
{
  printf("\n~~~~ %s() ~~~~\n", __func__);
  double values[]={0.0, 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0 ,9.0};
  const int valueCount=(int)(sizeof(values)/sizeof(values[0]));

  /* ...use transformReals() to apply scaleAndAdd()
          to each element in values[]
            with any suitable factor and increment... */

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

La fonction test_transformReals() sera appelée depuis la fonction main().
Elle doit être complétée de telle façon qu'un appel à transformReals() applique la fonction scaleAndAdd() à chacun des éléments du tableau values.
Des dispositions doivent être prises pour que le facteur et l'incrément (de votre choix) nécessaires à cette transformation soient accessibles par le pointeur générique de la fonction scaleAndAdd().

{2} Deuxième variante

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

int // found index or -1
findFirstInteger(const int *values,
                 int valueCount,
                 /* ...function pointer... */ fnct,
                 /* ...generic pointer... */ params)
{
  for(int i=0; i<valueCount; ++i)
  {
    if( /* ...use fnct with values[i] and params... */ )
    {
      return i;
    }
  }
  return -1; // not found
}

Son rôle est de parcourir un tableau d'entiers jusqu'à trouver un élément pour lequel la fonction transmise par pointeur (ainsi que ses paramètres génériques) renvoie un résultat vrai.
Il faudra bien entendu inventer un type correspondant à l'usage que nous faisons de fnct :

il s'agit d'un pointeur sur fonctions,
attendant en paramètres un entier et un pointeur générique,
renvoyant un résultat booléen.

D'autre part, il faut réaliser, dans le fichier prog_ex1101.c, ces fonctions :

bool
between(int value,
        /* ...generic pointer... */ params)
{
  const int low= /* ...obtain from params... */;
  const int high= /* ...obtain from params... */;
  return value>=low && value<=high;
}

void
test_findFirstInteger(void)
{
  printf("\n~~~~ %s() ~~~~\n", __func__);
  const int values[]={7, 2, 6, 9, 4, 3, 1, 8, 0, 5};
  const int valueCount=(int)(sizeof(values)/sizeof(values[0]));

  /* ...use findFirstInteger() to get the index of
          the first element in values[] for which
            between() reports that it stands between
              two suitable bounds... */
  const int idx= /* ...found index */;

  if(idx>=0)
  {
    printf("first element between %d and %d is %d (at index %d)\n",
           /* low bound */, /* high bound */, values[idx], idx);
  }
}

La fonction test_findFirstInteger() sera appelée depuis la fonction main().
Elle doit être complétée de telle façon qu'un appel à findFirstInteger() fournisse, grâce à la fonction between(), l'indice du premier élément répondant au critère de recherche choisi.
Des dispositions doivent être prises pour que les deux bornes (de votre choix) nécessaires au test de ce critère soient accessibles par le pointeur générique de la fonction between().

{3} Troisième variante

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

void
combineReals(const double *valuesX,
             const double *valuesY,
             double *valuesZ,
             int valueCount,
             /* ...function pointer... */ fnct,
             /* ...generic pointer... */ params)
{
  for(int i=0; i<valueCount; ++i)
  {
    valuesZ[i]= /* ...use fnct with valuesX[i], valuesY[i] and params... */;
  }
}

Son rôle est de déterminer chaque réel du tableau valuesZ en fonction des réels à l'indice correspondant dans les tableaux valuesX et valuesY grâce à l'utilisation de la fonction transmise par pointeur (ainsi que ses paramètres génériques).
Il faudra bien entendu inventer un type correspondant à l'usage que nous faisons de fnct :

il s'agit d'un pointeur sur fonctions,
attendant en paramètres deux réels et un pointeur générique,
renvoyant un résultat réel.

D'autre part, il faut réaliser, dans le fichier prog_ex1101.c, ces fonctions :

double
combine(double x,
        double y,
        /* ...generic pointer... */ params)
{
  const double xFactor= /* ...obtain from params... */;
  const double yFactor= /* ...obtain from params... */;
  return x*xFactor + y*yFactor;
}

void
test_combineReals(void)
{
  printf("\n~~~~ %s() ~~~~\n", __func__);
  const double valuesX[10]={0.0, 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0 ,9.0};
  const double valuesY[10]={1.0, 1.1, 1.2, 1.3, 1.4, 1.5, 1.6, 1.7, 1.8 ,1.9};
  double valuesZ[10];
  const int valueCount=(int)(sizeof(valuesZ)/sizeof(valuesZ[0]));

  /* ...use combineReals() to apply combine()
          to valuesX[], valuesY[] and valuesZ[]
            with any suitable xFactor and yFactor... */

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

La fonction test_combineReals() sera appelée depuis la fonction main().
Elle doit être complétée de telle façon qu'un appel à combineReals() utilise la fonction combine() pour déterminer chaque élément du tableau valuesZ en fonction des éléments de même indice dans les tableaux valuesX et valuesY.
Des dispositions doivent être prises pour que les deux facteurs multiplicatifs (de votre choix) nécessaires à cette combinaison soient accessibles par le pointeur générique de la fonction combine().

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 generic.h✎

Fichier generic.c✎

Fichier prog_ex1101.c✎

Contenu du fichier prog_ex1101.c

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

#include "generic.h"

#include <stdio.h>

double
scaleAndAdd(double value,
            void *params)
{
  const double *coefs=(const double *)params;
  const double factor=coefs[0];
  const double increment=coefs[1];
  return value*factor+increment;
}

void
test_transformReals(void)
{
  printf("\n~~~~ %s() ~~~~\n", __func__);
  double values[]={0.0, 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0 ,9.0};
  const int valueCount=(int)(sizeof(values)/sizeof(values[0]));
  double coefs[]={1.1, 20.0};
  transformReals(values, valueCount, scaleAndAdd, coefs);
  for(int i=0; i<valueCount; ++i)
  {
    printf("%g ", values[i]);
  }
  printf("\n");
}

bool
between(int value,
        void *params)
{
  const int *bounds=(const int *)params;
  const int low=bounds[0];
  const int high=bounds[1];
  return value>=low && value<=high;
}

void
test_findFirstInteger(void)
{
  printf("\n~~~~ %s() ~~~~\n", __func__);
  const int values[]={7, 2, 6, 9, 4, 3, 1, 8, 0, 5};
  const int valueCount=(int)(sizeof(values)/sizeof(values[0]));
  int bounds[]={8, 12};
  const int idx=findFirstInteger(values, valueCount, between, bounds);
  if(idx>=0)
  {
    printf("first element between %d and %d is %d (at index %d)\n",
           bounds[0], bounds[1], values[idx], idx);
  }
}

double
combine(double x,
        double y,
        void *params)
{
  const double *coefs=(const double *)params;
  const double xFactor=coefs[0];
  const double yFactor=coefs[1];
  return x*xFactor + y*yFactor;
}

void
test_combineReals(void)
{
  printf("\n~~~~ %s() ~~~~\n", __func__);
  const double valuesX[10]={0.0, 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0 ,9.0};
  const double valuesY[10]={1.0, 1.1, 1.2, 1.3, 1.4, 1.5, 1.6, 1.7, 1.8 ,1.9};
  double valuesZ[10];
  const int valueCount=(int)(sizeof(valuesZ)/sizeof(valuesZ[0]));
  double coefs[]={10.0, 0.5};
  combineReals(valuesX, valuesY, valuesZ, valueCount, combine, coefs);
  for(int i=0; i<valueCount; ++i)
  {
    printf("%g ", valuesZ[i]);
  }
  printf("\n");
}

int
main(void)
{
  test_transformReals();
  test_findFirstInteger();
  test_combineReals();
  return 0;
}

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