ENIB LANG-C Ex_0701 - Structure de données triviale

{1} Première variante

D'une part, il faut déclarer et définir dans les fichiers newTypes.h et newTypes.c :

un type Interval matérialisé par une structure composée de deux membres low et high de type réel,
une fonction Interval_add() dont le rôle est de fournir un intervalle qui soit la somme de deux autres qui lui sont transmis,
(le calcul se résume, de manière symbolique, à [low1;high1] + [low2;high2] = [low1+low2;high1+high2])
une fonction Interval_mul() dont le rôle est de fournir un intervalle qui soit le produit d'un intervalle et d'un réel qui lui sont transmis.
(le calcul se résume, de manière symbolique, à [low;high] * factor = [low1*factor;high*factor])

Les modes de passage des paramètres et du résultat qui sont adaptés à un type aussi trivial devront être choisis avec attention.

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

void
test_Interval(void)
{
  printf("\n~~~~ %s() ~~~~\n", __func__);
  // ...
}

qui sera appelée depuis la fonction main().
Elle doit être complétée en créant deux intervalles correspondant à des bornes de votre choix.
Un troisième intervalle doit être renseigné par la fonction Interval_add() appliquée aux deux premiers.
Un quatrième intervalle doit être renseigné par la fonction Interval_mul() appliquée aux troisième et à un facteur réel de votre choix.
Des affichages explicites devront illustrer les calculs ainsi réalisés.

{2} Deuxième variante

D'une part, il faut déclarer et définir dans les fichiers newTypes.h et newTypes.c :

un type Fraction matérialisé par une structure composée de deux membres numer et denom de type entier,
une fonction Fraction_add() dont le rôle est de fournir une fraction qui soit la somme de deux autres qui lui sont transmises,
(le calcul se résume, de manière symbolique, à a/b + c/d = (a*d+c*b)/(b*d))
une fonction Fraction_mul() dont le rôle est de fournir une fraction qui soit le produit d'une fraction et d'un entier qui lui sont transmis.
(le calcul se résume, de manière symbolique, à a/b * factor = (a*factor)/b)

Les modes de passage des paramètres et du résultat qui sont adaptés à un type aussi trivial devront être choisis avec attention.

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

void
test_Fraction(void)
{
  printf("\n~~~~ %s() ~~~~\n", __func__);
  // ...
}

qui sera appelée depuis la fonction main().
Elle doit être complétée en créant deux fractions de votre choix.
Une troisième fraction doit être renseignée par la fonction Fraction_add() appliquée aux deux premières.
Une quatrième fraction doit être renseignée par la fonction Fraction_mul() appliquée à la troisième et à un facteur entier votre choix.
Des affichages explicites devront illustrer les calculs ainsi réalisés.

{3} Troisième variante

D'une part, il faut déclarer et définir dans les fichiers newTypes.h et newTypes.c :

un type Rectangle matérialisé par une structure composée de deux membres width et height de type réel,
une fonction Rectangle_add() dont le rôle est de fournir un rectangle qui soit la somme de deux autres qui lui sont transmis,
(le calcul se résume, de manière symbolique, à (width1,height1) + (width2,height2) = (width1+width2,height1+height2))
une fonction Rectangle_mul() dont le rôle est de fournir un rectangle qui soit le produit d'un rectangle et d'un réel qui lui sont transmis.
(le calcul se résume, de manière symbolique, à (width,height) * factor = (width*factor,height*factor))

Les modes de passage des paramètres et du résultat qui sont adaptés à un type aussi trivial devront être choisis avec attention.

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

void
test_Rectangle(void)
{
  printf("\n~~~~ %s() ~~~~\n", __func__);
  // ...
}

qui sera appelée depuis la fonction main().
Elle doit être complétée en créant deux rectangles de votre choix.
Un troisième rectangle doit être renseigné par la fonction Rectangle_add() appliquée aux deux premiers.
Un quatrième rectangle doit être renseigné par la fonction Rectangle_mul() appliquée aux troisième et à un facteur réel de votre choix.
Des affichages explicites devront illustrer les calculs ainsi réalisés.

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

Contenu du fichier newTypes.h

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

#ifndef NEWTYPES_H
#define NEWTYPES_H

typedef struct
{
  double low, high;
} Interval;

Interval
Interval_add(Interval lhs,
             Interval rhs);

Interval
Interval_mul(Interval lhs,
             double rhs);

typedef struct
{
  int numer, denom;
} Fraction;

Fraction
Fraction_add(Fraction lhs,
             Fraction rhs);

Fraction
Fraction_mul(Fraction lhs,
             int rhs);

typedef struct
{
  double width, height;
} Rectangle;

Rectangle
Rectangle_add(Rectangle lhs,
              Rectangle rhs);

Rectangle
Rectangle_mul(Rectangle lhs,
              double rhs);

#endif // NEWTYPES_H

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

Fichier newTypes.c✎

Contenu du fichier newTypes.c

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

#include "newTypes.h"

Interval
Interval_add(Interval lhs,
             Interval rhs)
{
  Interval result;
  result.low=lhs.low+rhs.low;
  result.high=lhs.high+rhs.high;
  return result;
}

Interval
Interval_mul(Interval lhs,
             double rhs)
{
  Interval result={lhs.low*rhs, lhs.high*rhs};
  return result;
}

Fraction
Fraction_add(Fraction lhs,
             Fraction rhs)
{
  Fraction result;
  result.numer=lhs.numer*rhs.denom+rhs.numer*lhs.denom;
  result.denom=lhs.denom*rhs.denom;
  return result;
}

Fraction
Fraction_mul(Fraction lhs,
             int rhs)
{
  Fraction result={lhs.numer*rhs, lhs.denom};
  return result;
}

Rectangle
Rectangle_add(Rectangle lhs,
              Rectangle rhs)
{
  Rectangle result;
  result.width=lhs.width+rhs.width;
  result.height=lhs.height+rhs.height;
  return result;
}

Rectangle
Rectangle_mul(Rectangle lhs,
              double rhs)
{
  Rectangle result={lhs.width*rhs, lhs.height*rhs};
  return result;
}

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

Fichier prog_ex0701.c✎

Contenu du fichier prog_ex0701.c

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

#include "newTypes.h"

#include <stdio.h>

void
test_Interval(void)
{
  printf("\n~~~~ %s() ~~~~\n", __func__);
  const Interval i1={2.5, 6.3};
  const Interval i2={0.4, 2.1};
  const Interval i3=Interval_add(i1, i2);
  const double factor=10.0;
  const Interval i4=Interval_mul(i3, factor);
  printf("[%g;%g] + [%g;%g] = [%g;%g]\n",
         i1.low, i1.high, i2.low, i2.high, i3.low, i3.high);
  printf("[%g;%g] * %g = [%g;%g]\n",
         i3.low, i3.high, factor, i4.low, i4.high);
}

void
test_Fraction(void)
{
  printf("\n~~~~ %s() ~~~~\n", __func__);
  const Fraction f1={2, 3};
  const Fraction f2={4, 5};
  const Fraction f3=Fraction_add(f1, f2);
  const int factor=5;
  const Fraction f4=Fraction_mul(f3, factor);
  printf("%d/%d + %d/%d = %d/%d\n",
         f1.numer, f1.denom, f2.numer, f2.denom, f3.numer, f3.denom);
  printf("%d/%d * %d = %d/%d\n",
         f3.numer, f3.denom, factor, f4.numer, f4.denom);
}

void
test_Rectangle(void)
{
  printf("\n~~~~ %s() ~~~~\n", __func__);
  const Rectangle r1={10.1, 20.2};
  const Rectangle r2={30.3, 40.4};
  const Rectangle r3=Rectangle_add(r1, r2);
  const double factor=0.5;
  const Rectangle r4=Rectangle_mul(r3, factor);
  printf("(%g,%g) + (%g,%g) = (%g,%g)\n",
         r1.width, r1.height, r2.width, r2.height, r3.width, r3.height);
  printf("(%g,%g) * %g = (%g,%g)\n",
         r3.width, r3.height, factor, r4.width, r4.height);
}

int
main(void)
{
  test_Interval();
  test_Fraction();
  test_Rectangle();
  return 0;
}

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