ENIB PRJ-C Training_1 - Entraînement à la première épreuve

{} Programme structuré minimal

Votre réalisation sera composée des fichiers suivants :

un programme principal prog_training_1.c,
un module de programmation computation.h/computation.c.

Le programme exécutable résultant sera obtenu en utilisant ce fichier GNUmakefile✎

Contenu du fichier GNUmakefile

#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
# this GNU-makefile relies on the GCC toolchain
# nb: on Windows, the Mingw-w64 package provides the mingw32-make.exe command
#     ( see https://web.enib.fr/~harrouet/dev_tools/#windows.mingw )

#~~~~ control global settings ~~~~
# make opt=2 --> enable optimisation, then disable debug, but keep symbols
# make opt=1 --> enable optimisation, then disable debug
# make opt=0 --> disable optimisation, then enable debug
opt=0
# make clang=1 --> use clang/clang++, not gcc/g++
# make clang=0 --> use gcc/g++, not clang/clang++
clang=0
# make wasm=1 --> target webassembly rather than the native platform
# make wasm=0 --> target the native platform rather than webassembly
wasm=0

#~~~~ build library or programs ~~~~
# if LIB_TARGET is provided, this library will be built (with its
# platform-specific name), otherwise ${EXE_PREFIX}* programs will be built
LIB_TARGET=
EXE_PREFIX=prog

#~~~~ detect operating system ~~~~
ifneq (${OS},Windows_NT)
  ifneq (,${findstring Ubuntu,${shell lsb_release -i 2>/dev/null}})
    OS:=Ubuntu
  else ifneq (,${findstring Raspbian,${shell lsb_release -i 2>/dev/null}})
    # Standard distribution for Raspberry-Pi
    OS:=Raspbian
  else
    OS:=${strip ${shell uname -s}}
  endif
  ifneq (,${findstring Microsoft,${shell cat /proc/version 2>/dev/null}})
    # Windows-Subsystem-for-Linux
    OS:=${OS}_WSL
  endif
endif

#~~~~ adjust project-specific settings ~~~~
CPPFLAGS=
# CPPFLAGS+=-I header/path
LDFLAGS=-lm
# LDFLAGS+=-L library/path -Wl,-rpath,library/path -l library_name
CFLAGS=
CXXFLAGS=
BINFLAGS=
ifneq (,${findstring Windows_NT,${OS}})
  # nothing special for now
else
  ifneq (,${strip ${LIB_TARGET}})
    BINFLAGS+=-fPIC
  endif
  ifneq (,${findstring Darwin,${OS}})
    # nothing special for now
  else
    ifneq (,${findstring Ubuntu,${OS}})
      # sanitizer sometimes requires gold-linker on Ubuntu
      LDFLAGS+=-fuse-ld=gold
    else ifneq (,${findstring Raspbian,${OS}})
      # some warnings may appear when mixing g++-6 and g++-7 on Raspbian
      CXXFLAGS+=-Wno-psabi
    else
      # nothing special for now
    endif
  endif
endif

#~~~~ adjust platform-specific features (Posix/Windows/Emscripten...) ~~~~
ifneq (,${findstring Windows_NT,${OS}})
  LIB_PREFIX=
  LIB_SUFFIX=.dll
  EXE_SUFFIX=.exe
  SKIP_LINE=echo.
  REMOVE=del /q
else
  LIB_PREFIX=lib
  ifneq (,${findstring Darwin,${OS}})
    LIB_SUFFIX=.dylib
  else
    LIB_SUFFIX=.so
  endif
  EXE_SUFFIX=
  SKIP_LINE=echo
  REMOVE=rm -rf
endif
ifeq (${strip ${wasm}},1)
  LIB_PREFIX:=lib
  LIB_SUFFIX:=.bc
  EXE_SUFFIX:=.html
endif

#~~~~ deduce file names ~~~~
ifneq (,${strip ${LIB_TARGET}})
  LIB_TARGET:=${LIB_PREFIX}${strip ${LIB_TARGET}}${LIB_SUFFIX}
  MAIN_C_FILES=
  MAIN_CXX_FILES=
else
  LIB_TARGET:=
  MAIN_C_FILES=${wildcard ${strip ${EXE_PREFIX}}*.c}
  MAIN_CXX_FILES=${wildcard ${strip ${EXE_PREFIX}}*.cpp}
endif
COMMON_C_FILES=${filter-out ${MAIN_C_FILES},${wildcard *.c}}
COMMON_CXX_FILES=${filter-out ${MAIN_CXX_FILES},${wildcard *.cpp}}
#
MAIN_OBJECT_FILES=${sort ${patsubst %.c,%.o,${MAIN_C_FILES}} \
                         ${patsubst %.cpp,%.o,${MAIN_CXX_FILES}}}
COMMON_OBJECT_FILES=${sort ${patsubst %.c,%.o,${COMMON_C_FILES}} \
                           ${patsubst %.cpp,%.o,${COMMON_CXX_FILES}}}
OBJECT_FILES=${MAIN_OBJECT_FILES} ${COMMON_OBJECT_FILES}
DEPEND_FILES=${patsubst %.o,%.d,${OBJECT_FILES}}
EXE_FILES=${sort ${patsubst %.c,%${EXE_SUFFIX},${MAIN_C_FILES}} \
                 ${patsubst %.cpp,%${EXE_SUFFIX},${MAIN_CXX_FILES}}}
#
GENERATED_FILES=${DEPEND_FILES} ${OBJECT_FILES} ${LIB_TARGET} ${EXE_FILES}
ifneq (,${findstring Darwin,${OS}})
  GENERATED_FILES+=${wildcard *.dSYM}
endif
ifeq (${strip ${wasm}},1)
  GENERATED_FILES+=${patsubst %.html,%.js,${EXE_FILES}}
  GENERATED_FILES+=${patsubst %.html,%.html.mem,${EXE_FILES}}
  GENERATED_FILES+=${patsubst %.html,%.wasm,${EXE_FILES}}
  GENERATED_FILES+=${patsubst %.html,%.wast,${EXE_FILES}}
endif
GENERATED_FILES+=${wildcard output_* *~}

#~~~~ compiler/linker settings ~~~~
CPPFLAGS+=-MMD -pedantic -Wall -Wextra -Wconversion -Wno-sign-conversion
CPPFLAGS+=-Wno-unused -Wno-unused-parameter
CPPFLAGS+=-Werror -Wfatal-errors
CFLAGS+=-std=c99 -Wc++-compat -Wwrite-strings -Wold-style-definition -Wvla
CXXFLAGS+=-std=c++17 -Wno-missing-braces
LDFLAGS+=
BINFLAGS+=
ifeq (${strip ${wasm}},1)
  CC=emcc
  CXX=em++
  CPPFLAGS+=-Wno-dollar-in-identifier-extension
  LDFLAGS+=-s ALLOW_MEMORY_GROWTH=1
else ifeq (${strip ${clang}},1)
  CC=clang
  CXX=clang++
else
  CC=gcc
  CXX=g++
endif
#
ifneq (,${strip ${MAIN_CXX_FILES} ${COMMON_CXX_FILES}})
  # force c++ link if there is at least one c++ source file
  LD:=${CXX}
else
  LD:=${CC}
endif

#~~~~ debug/optimisation settings ~~~~
ifneq (${strip ${opt}},0)
  CPPFLAGS+=-DNDEBUG
  BINFLAGS+=-O3 -ffast-math
  # BINFLAGS+=-fopt-info-vec-optimized
  ifneq (${strip ${wasm}},1)
    BINFLAGS+=-march=native
  endif
  ifeq (${strip ${opt}},2)
    # optimise but keep symbols for profiling
    BINFLAGS+=-g -fno-omit-frame-pointer
  else
    BINFLAGS+=-fomit-frame-pointer
  endif
else
  CPPFLAGS+=-UNDEBUG
  BINFLAGS+=-g -O0
  ifeq (${strip ${wasm}},1)
    # sanitizer is not available yet with Emscripten
  else ifneq (,${findstring Windows_NT,${OS}})
    # sanitizer is not available yet on Windows
  else
    BINFLAGS+=-fsanitize=address,undefined
    ifneq (,${findstring Raspbian,${OS}})
      # dynamic sanitizer libraries may not be found on Raspbian
      BINFLAGS+=-static-libasan -static-libubsan
    endif
  endif
endif

#~~~~ main target ~~~~
all : ${EXE_FILES} ${LIB_TARGET}

rebuild : clean all

.SUFFIXES:
.SECONDARY:
.PHONY: all clean rebuild

#~~~~ linker command to produce the library (if any) ~~~~
${LIB_TARGET} : ${COMMON_OBJECT_FILES}
	@echo ==== linking [opt=${opt}] $@ ====
	${LD} -shared -o $@ $^ ${BINFLAGS} ${LDFLAGS}
	@${SKIP_LINE}

#~~~~ linker command to produce the executable files (if any) ~~~~
%${EXE_SUFFIX} : %.o ${COMMON_OBJECT_FILES}
	@echo ==== linking [opt=${opt}] $@ ====
	${LD} -o $@ $^ ${BINFLAGS} ${LDFLAGS}
	@${SKIP_LINE}

#~~~~ compiler command for every source file ~~~~
%.o : %.c
	@echo ==== compiling [opt=${opt}] $< ====
	${CC} -o $@ $< -c ${BINFLAGS} ${CPPFLAGS} ${CFLAGS}
	@${SKIP_LINE}

%.o : %.cpp
	@echo ==== compiling [opt=${opt}] $< ====
	${CXX} -o $@ $< -c ${BINFLAGS} ${CPPFLAGS} ${CXXFLAGS}
	@${SKIP_LINE}

-include ${DEPEND_FILES}

#~~~~ remove generated files ~~~~
clean :
	@echo ==== cleaning ====
	${REMOVE} ${GENERATED_FILES}
	@${SKIP_LINE}

#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

Notre module de programmation doit déclarer et définir une fonction dummy_function() (sans paramètre ni résultat) qui sera constituée d'une seule étape :

afficher un message explicite de votre choix (indiquant notamment le nom de cette fonction).

La fonction principale du fichier prog_training_1.c sera constituée de trois étapes :

afficher un message d'entrée dans la fonction principale (indiquant notamment le nom de cette fonction),
appeler la fonction dummy_function(),
afficher un message de sortie de la fonction principale (indiquant notamment le nom de cette fonction).

Les affichages produits à l'exécution du programme doivent montrer très lisiblement l'enchaînement des étapes.

Bien entendu, à des fins d'entraînement, il est très pertinent de changer le nom des fichiers pour le module et le nom de la fonction réalisée.

Aide pour l'entraînement

{} Première variante

{} Équivalence réel/entier

Notre module de programmation doit déclarer et définir une fonction is_int() :

elle attend un paramètre de type réel,
elle renvoie un résultat de type booléen.

Son rôle est d'indiquer par son résultat si le réel passé en paramètre est un entier (c'est à dire s'il n'a pas de partie décimale).
Il suffit de créer un entier à partir de ce paramètre et tester si cet entier a la même valeur que le réel fourni.

Pour tester le bon fonctionnement de cette réalisation, il faut définir dans le programme principal une fonction test_is_int(), sans paramètre ni résultat, qui sera appelée depuis la fonction principale.
Elle commence par afficher lisiblement son nom.
Elle doit réaliser une boucle avec un compteur entier allant de -20 à 20 (ces deux bornes sont incluses).
Pour chaque valeur de ce compteur il faut créer un réel en multipliant cet entier par 0.25.
Si la fonction is_int() indique que ce réel est équivalent à un entier il faut afficher lisiblement la valeur de ce réel.
Le contrôle visuel de l'affichage produit sera l'occasion de corriger la réalisation si elle n'est pas conforme au fonctionnement attendu.

Aide pour l'entraînement

Si nécessaire, des explications détaillées sont accessibles dans ce chapitre.

Sans exigence particulière, le type double est choisi pour représenter un réel.
Sans exigence particulière, le type int est choisi pour représenter un entier.
Le type bool et les constantes true et false sont rendues disponibles grâce à l'entête standard

<stdbool.h>

Lorsque le compilateur est rigoureux, la conversion d'un réel en entier doit être explicite (cast) afin d'assumer la perte éventuelle de la partie décimale.

La construction

if(){}

else{}

permet de choisir les instructions que l'on souhaites exécuter.

Le résultat d'une comparaison est fondamentalement un booléen ; il est inutile de le comparer à un autre booléen pour décider de renvoyer vrai ou faux à l'identique.

Une boucle avec compteur se réalise de préférence avec la construction

for(){}

.
L'opération d'incrémentation du compteur d'une telle boucle utilise habituellement l'opérateur ++.

{} Valeur absolue d'un entier

Notre module de programmation doit déclarer et définir une fonction int_abs() :

elle attend un paramètre de type entier,
elle renvoie un résultat de type entier.

Son rôle est d'indiquer par son résultat la valeur absolue de l'entier passé en paramètre, c'est à dire l'opposé du paramètre s'il est négatif ou bien lui-même s'il est positif ou nul.
Il est demandé de ne pas avoir recours à une fonction existante (comme fabs() par exemple) mais de réaliser tous les détails de ce calcul.

Pour tester le bon fonctionnement de cette réalisation, il faut définir dans le programme principal une fonction test_int_abs(), sans paramètre ni résultat, qui sera appelée depuis la fonction principale.
Elle commence par afficher lisiblement son nom.
Elle doit réaliser une boucle avec un compteur entier allant de -2 à 2 (ces deux bornes sont incluses).
Pour chaque valeur de ce compteur il faut obtenir le résultat de la fonction int_abs() et afficher lisiblement sur une seule ligne le compteur, le résultat obtenu et un message de diagnostic explicite.
Ce diagnostic s'obtiendra en comparant le résultat obtenu avec ce qu'indique la fonction standard fabs() (nécessitant le passage temporaire par des valeurs réelles).
Le contrôle visuel de l'affichage produit sera l'occasion de corriger la réalisation si elle n'est pas conforme au fonctionnement attendu.

Aide pour l'entraînement

Si nécessaire, des explications détaillées sont accessibles dans ce chapitre.

Sans exigence particulière, le type double est choisi pour représenter un réel.
Sans exigence particulière, le type int est choisi pour représenter un entier.

Lorsque le compilateur est rigoureux, la conversion d'un réel en entier doit être explicite (cast) afin d'assumer la perte éventuelle de la partie décimale.

La construction

if(){}

else{}

permet de choisir les instructions que l'on souhaites exécuter.
L'opérateur ternaire ?: permet dans certains cas (pas tous) d'exprimer la même chose sous une forme plus concise et plus lisible.

Une boucle avec compteur se réalise de préférence avec la construction

for(){}

.
L'opération d'incrémentation du compteur d'une telle boucle utilise habituellement l'opérateur ++.

{} Racine carrée d'un entier

Notre module de programmation doit déclarer et définir une fonction int_square_root() :

elle attend un paramètre de type entier,
elle renvoie un résultat de type entier.

Son rôle est d'indiquer par son résultat la racine carrée de l'entier passé en paramètre.
Il faut réaliser une boucle avec compteur qui se poursuit tant que le carré du compteur (le compteur multiplié par lui-même) est inférieur ou égal au paramètre entier.
La dernière valeur de compteur pour laquelle cette condition est vérifiée donne le résultat attendu.
Il est demandé de ne pas avoir recours à une fonction existante (comme sqrt() par exemple) mais de réaliser tous les détails de ce calcul.

Pour tester le bon fonctionnement de cette réalisation, il faut définir dans le programme principal une fonction test_int_square_root(), sans paramètre ni résultat, qui sera appelée depuis la fonction principale.
Elle commence par afficher lisiblement son nom.
Elle doit réaliser une boucle avec un compteur entier allant de 0 et ne devant pas atteindre 10000, mais qui progresse de cette façon : à chaque itération, le compteur est multiplié par 2 et on lui ajoute 3.
Pour chaque valeur de ce compteur, il faut obtenir le résultat de la fonction int_square_root().
Il faut alors afficher lisiblement sur une seule ligne le compteur, le résultat obtenu et un message de diagnostic explicite.
Ce diagnostic s'obtiendra en comparant le résultat obtenu avec ce qu'indique la fonction standard sqrt() (nécessitant le passage temporaire par des valeurs réelles).
Le contrôle visuel de l'affichage produit sera l'occasion de corriger la réalisation si elle n'est pas conforme au fonctionnement attendu.

Aide pour l'entraînement

Si nécessaire, des explications détaillées sont accessibles dans ce chapitre.

Sans exigence particulière, le type int est choisi pour représenter un entier.

Une boucle avec compteur se réalise de préférence avec la construction

for(){}

.
L'opération d'incrémentation du compteur d'une telle boucle utilise habituellement l'opérateur ++.

Lorsque le compilateur est rigoureux, la conversion d'un réel en entier doit être explicite (cast) afin d'assumer la perte éventuelle de la partie décimale.

La construction

if(){}

else{}

permet de choisir les instructions que l'on souhaites exécuter.
L'opérateur ternaire ?: permet dans certains cas (pas tous) d'exprimer la même chose sous une forme plus concise et plus lisible.

{} Seconde variante

{} Pourcentage

Notre module de programmation doit déclarer et définir une fonction unit_to_percent() :

elle attend un paramètre de type réel,
elle renvoie un résultat de type entier.

Son rôle est d'indiquer par son résultat un pourcentage correspondant au réel passé en paramètre considéré comme unitaire (ses valeurs n'ont de sens qu'entre 0.0 et 1.0).
Si ce réel est inférieur à 0.0, le résultat sera 0.
Si ce réel est supérieur à 1.0, le résultat sera 100.
Pour les valeurs intermédiaires, le résultat évoluera proportionnellement entre 0 et 100.

Pour tester le bon fonctionnement de cette réalisation, il faut définir dans le programme principal une fonction test_unit_to_percent(), sans paramètre ni résultat, qui sera appelée depuis la fonction principale.
Elle commence par afficher lisiblement son nom.
Elle doit réaliser une boucle avec un compteur entier allant de -4 à 14 (ces deux bornes sont incluses) en avançant de 2 à chaque itération.
Pour chaque valeur de ce compteur il faut créer un réel en multipliant cet entier par 0.1 et obtenir le résultat de la fonction unit_to_percent() appliquée à ce réel.
Il faut alors afficher lisiblement le réel et le résultat obtenu.
Le contrôle visuel de l'affichage produit sera l'occasion de corriger la réalisation si elle n'est pas conforme au fonctionnement attendu.

Aide pour l'entraînement

Si nécessaire, des explications détaillées sont accessibles dans ce chapitre.

Sans exigence particulière, le type double est choisi pour représenter un réel.
Sans exigence particulière, le type int est choisi pour représenter un entier.

La construction

if(){}

else{}

permet de choisir les instructions que l'on souhaites exécuter.
L'opérateur ternaire ?: permet dans certains cas (pas tous) d'exprimer la même chose sous une forme plus concise et plus lisible.

Lorsque le compilateur est rigoureux, la conversion d'un réel en entier doit être explicite (cast) afin d'assumer la perte éventuelle de la partie décimale.

Une boucle avec compteur se réalise de préférence avec la construction

for(){}

{} Arrondi

Notre module de programmation doit déclarer et définir une fonction int_round() :

elle attend un paramètre de type réel,
elle renvoie un résultat de type entier.

Son rôle est d'indiquer par son résultat l'entier le plus proche du réel passé en paramètre.
Il faut commencer par convertir ce réel en entier, puis calculer la différence du réel moins cet entier.
Trois cas se présentent alors :

si la différence est supérieure ou égale à 0.5, alors le résultat sera cet entier plus un,
si la différence est inférieure ou égale à -0.5, alors le résultat sera cet entier moins un,
dans les autres cas le résultat sera cet entier.

Il est demandé de ne pas avoir recours à une fonction existante (comme round() par exemple) mais de réaliser tous les détails de ce calcul.

Pour tester le bon fonctionnement de cette réalisation, il faut définir dans le programme principal une fonction test_int_round(), sans paramètre ni résultat, qui sera appelée depuis la fonction principale.
Elle commence par afficher lisiblement son nom.
Elle doit réaliser une boucle avec un compteur entier allant de -6 à 6 (ces deux bornes sont incluses).
Pour chaque valeur de ce compteur il faut créer un réel en multipliant cet entier par 0.2 et obtenir le résultat de la fonction int_round() appliquée à ce réel.
Il faut alors afficher lisiblement sur une seule ligne le réel, le résultat obtenu et un message de diagnostic explicite.
Ce diagnostic s'obtiendra en comparant le résultat obtenu avec ce qu'indique la fonction standard round() (nécessitant le passage temporaire par des valeurs réelles).
Le contrôle visuel de l'affichage produit sera l'occasion de corriger la réalisation si elle n'est pas conforme au fonctionnement attendu.

Aide pour l'entraînement

Si nécessaire, des explications détaillées sont accessibles dans ce chapitre.

Sans exigence particulière, le type double est choisi pour représenter un réel.
Sans exigence particulière, le type int est choisi pour représenter un entier.

Lorsque le compilateur est rigoureux, la conversion d'un réel en entier doit être explicite (cast) afin d'assumer la perte éventuelle de la partie décimale.

La construction

if(){}

else{}

permet de choisir les instructions que l'on souhaites exécuter.
L'opérateur ternaire ?: permet dans certains cas (pas tous) d'exprimer la même chose sous une forme plus concise et plus lisible.

Une boucle avec compteur se réalise de préférence avec la construction

for(){}

.
L'opération d'incrémentation du compteur d'une telle boucle utilise habituellement l'opérateur ++.

{} Nombre de chiffres

Notre module de programmation doit déclarer et définir une fonction number_of_digits() :

elle attend un paramètre de type entier,
elle renvoie un résultat de type entier.

Son rôle est d'indiquer par son résultat le nombre de chiffres qui permettent de représenter (en base dix) l'entier passé en paramètre.
Par exemple, de 0 à 9 il faut un chiffre, de 10 à 99 il en faut deux, de 100 à 999 il en faut trois...
Il faut compter le nombre de fois successives où on peut diviser le paramètre entier par dix.
Attention, il y a au moins un chiffre, même quand le paramètre entier vaut initialement zéro.
Il est demandé de ne pas avoir recours à une fonction existante (comme log10() par exemple) mais de réaliser tous les détails de ce calcul.

Pour tester le bon fonctionnement de cette réalisation, il faut définir dans le programme principal une fonction test_number_of_digits(), sans paramètre ni résultat, qui sera appelée depuis la fonction principale.
Elle commence par afficher lisiblement son nom.
Elle doit réaliser une boucle avec un compteur entier allant de 0 et ne devant pas atteindre 10000, mais qui progresse de cette façon : à chaque itération, le compteur est multiplié par 2 et on lui ajoute 1.
Pour chaque valeur de ce compteur, il faut obtenir le résultat de la fonction number_of_digits().
Il faut alors afficher lisiblement sur une seule ligne le compteur, le résultat obtenu et un message de diagnostic explicite.
Ce diagnostic s'obtiendra en comparant le résultat obtenu avec ce qu'indique la fonction standard log10() (nécessitant le passage temporaire par des valeurs réelles) plus 1.
Attention, lorsque le compteur vaut 0, la fonction log10() n'est pas utilisable : il faudra envisager ce cas particulier dans la vérification.
Le contrôle visuel de l'affichage produit sera l'occasion de corriger la réalisation si elle n'est pas conforme au fonctionnement attendu.

Aide pour l'entraînement

Si nécessaire, des explications détaillées sont accessibles dans ce chapitre.

Sans exigence particulière, le type int est choisi pour représenter un entier.

Si la construction

for(){}

est en général le choix par défaut pour réaliser une boucle, ce problème particulier peut tirer avantage de la construction

do{}while()

qui contrôle la condition de continuation après la première itération du corps de la boucle.

Une boucle avec compteur se réalise de préférence avec la construction

for(){}

La construction

if(){}

else{}

permet de choisir les instructions que l'on souhaites exécuter.
Une condition élaborée peut utiliser les opérateurs || (ou logique) ou && (et logique) à partir de plusieurs conditions élémentaires.

Lorsque le compilateur est rigoureux, la conversion d'un réel en entier doit être explicite (cast) afin d'assumer la perte éventuelle de la partie décimale.

Critères pour l'auto-correction

Après la réalisation d'un épreuve d'entraînement, il est nécessaire de s'auto-corriger pour estimer son niveau de préparation et le renforcer si nécessaire.
La correction consiste à attribuer une note de 0 à 20 pour chacun des critères suivants.

“Organiser le code de manière conventionnelle”
Quelques éléments à vérifier (pas nécessairement exhaustifs) :

Le code se compile-t-il avec le fichier GNUmakefile fourni ?
Les indications de l'aide pour l'entraînement de la partie
```
{1}
```
sont-elles suivies ?
Le code est-il difficile à lire (irrégulièrement indenté, compacté...) ?
L'usage de void (en paramètre ou type de retour) est-il correct ?
Les notions de déclaration et de définition sont-elles bien distinguées ?
L'avancée dans la réalisation est-elle suffisante pour évaluer significativement ce critère ?

“Maîtriser les types numériques élémentaires”
Quelques éléments à vérifier (pas nécessairement exhaustifs) :

Les types utilisés respectent-ils toutes les consignes de l'énoncé ?
Les opérations de conversion explicite de type (cast) sont-elles conformes à l'effet attendu ?
Certaines conversions explicites ne sont-elles pas inutiles (conversion d'un type vers lui-même, ou ne répondant à aucune perte potentielle d'information) ?
L'avancée dans la réalisation est-elle suffisante pour évaluer significativement ce critère ?

“Déclarer et appeler des fonctions”
Quelques éléments à vérifier (pas nécessairement exhaustifs) :

Les paramètres et le type de retour des fonctions sont-ils tous conformes à l'énoncé ?
Les appels des fonctions sont-ils tous conformes aux paramètres attendus et au type de retour ?
Plusieurs appels strictement équivalents ne sont-ils pas réalisés alors que le résultat aurait pu être mémorisé dans une variable afin d'être réutilisé ?
L'avancée dans la réalisation est-elle suffisante pour évaluer significativement ce critère ?

“Maîtriser l'alternative simple”
Quelques éléments à vérifier (pas nécessairement exhaustifs) :

La syntaxe de l'alternative simple est-elle toujours correcte ?
L'alternative produit-elle toujours le choix attendu ?
L'opérateur ternaire est-il toujours utilisé à bon escient (il n'apporte que de la confusion sans concision ni lisibilité, ou n'est pas utilisé là où il aurait largement bénéficié à la concision et la lisibilité) ?
L'avancée dans la réalisation est-elle suffisante pour évaluer significativement ce critère ?

“Maîtriser la boucle”
Quelques éléments à vérifier (pas nécessairement exhaustifs) :

La syntaxe de la boucle est-elle toujours correcte ?
Certaines boucles n'ont-elles pas aucune chance de produire l'effet attendu (aucune itération, itérations infinies...) ?
Des imprécisions subsistent-elles (itération en trop ou en moins, pas de progression incorrect...) ?
L'avancée dans la réalisation est-elle suffisante pour évaluer significativement ce critère ?

“Comprendre et respecter l'énoncé d'un problème trivial”
Quelques éléments à vérifier (pas nécessairement exhaustifs) :

Toutes les fonctions tentent-elles de réaliser exactement ce qui est décrit dans l'énoncé ?
Les tests ont-ils une chance fournir un diagnostic significatif (résultats récupéré, comparés, affichés...) ?
Les tests sont-ils suffisamment complets (variété dans les cas, contre-exemples, affichage compréhensible...) ?
L'avancée dans la réalisation est-elle suffisante pour évaluer significativement ce critère ?

Code source résultant

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

Fichier prog_training_1.c✎

Contenu du fichier prog_training_1.c

//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

#include "computation.h"

#include <stdio.h>
#include <math.h>

//~~~~ First variant ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

void
test_is_int(void)
{
    printf("\n~~~~ test_is_int() ~~~~\n");
    for(int i=-20; i<=20; ++i)
    {
        const double v=i*0.25;
        if(is_int(v))
        {
            printf("%g is an integer\n", v);
        }
    }
}

void
test_int_abs(void)
{
    printf("\n~~~~ test_int_abs() ~~~~\n");
    for(int i=-2; i<=2; ++i)
    {
        const int a=int_abs(i);
        printf("%d ~~> %d ", i , a);
        if(a==(int)fabs((double)i))
        {
           printf("correct\n");
        }
        else
        {
            printf("!!! INCORRECT !!!\n");
        }
    }
}

void
test_int_square_root(void)
{
    printf("\n~~~~ test_square_root() ~~~~\n");
    for(int i=0; i<10000; i=2*i+3)
    {
        const int r=int_square_root(i);
        printf("%d ~~> %d ", i, r);
        if(r==(int)sqrt(i))
        {
           printf("correct\n");
        }
        else
        {
            printf("!!! INCORRECT !!!\n");
        }
    }
}

//~~~~ Second variant ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

void
test_unit_to_percent(void)
{
    printf("\n~~~~ test_unit_to_percent() ~~~~\n");
    for(int i=-4; i<=14; i+=2)
    {
        const double unit=i*0.1;
        const int percent=unit_to_percent(unit);
        printf("%g ~~> %d\n", unit, percent);
    }
}

void
test_int_round(void)
{
    printf("\n~~~~ test_int_round() ~~~~\n");
    for(int i=-6; i<=6; ++i)
    {
        const double v=i*0.2;
        const int f=int_round(v);
        printf("%g ~~> %d ", v , f);
        if(f==(int)round(v))
        {
           printf("correct\n");
        }
        else
        {
            printf("!!! INCORRECT !!!\n");
        }
    }
}

void
test_number_of_digits(void)
{
    printf("\n~~~~ test_number_of_digits() ~~~~\n");
    for(int i=0; i<10000; i=2*i+1)
    {
        const int n=number_of_digits(i);
        printf("%d ~~> %d ", i, n);
#if 0 // one possible solution
        if(((i==0)&&(n==1))||
           (n==1+(int)log10(i)))
#else // a more concise solution
        const int expected=(i==0) ? 1 : 1+(int)log10(i);
        if(n==expected)
#endif
        {
           printf("correct\n");
        }
        else
        {
            printf("!!! INCORRECT !!!\n");
        }
    }
}

//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

int
main(void)
{
    printf("~~~~ entering main() ~~~~\n");
    dummy_function();

    test_is_int();
    test_int_abs();
    test_int_square_root();

    test_unit_to_percent();
    test_int_round();
    test_number_of_digits();

    printf("~~~~ leaving main() ~~~~\n");
    return 0;
}

//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

Fichier computation.h✎

Fichier computation.c✎

Contenu du fichier computation.c

//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

#include "computation.h"

#include <stdio.h>
#include <math.h>

void
dummy_function(void)
{
    printf("in dummy_function()\n");
}

//~~~~ First variant ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

bool
is_int(double value)
{
#if 0 // one possible solution
    if(value==(int)value)
    {
        return true;
    }
    return false;
#else // a more concise solution
    return value==(int)value;
#endif
}

int
int_abs(int value)
{
#if 0 // one possible solution
    if(value<0)
    {
        return -value;
    }
    return value;
#else // a more concise solution
    return value<0 ? -value : value;
#endif
}

int
int_square_root(int value)
{
    int square_root=0;
    for(int i=0; i*i<=value; ++i)
    {
        square_root=i;
    }
    return square_root;
}

//~~~~ Second variant ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

int
unit_to_percent(double unit)
{
#if 0 // one possible solution
    if(unit<0.0)
    {
        return 0;
    }
    if(unit>1.0)
    {
        return 100;
    }
    return (int)(unit*100.0);
#else // a more concise solution
    return unit<0.0 ? 0
                    : unit>1.0 ? 100
                               : (int)(unit*100.0);
#endif
}

int
int_round(double value)
{
    const int i_value=(int)value;
    const double delta=value-i_value;
#if 0 // one possible solution
    if(delta>=0.5)
    {
        return i_value+1;
    }
    if(delta<=-0.5)
    {
        return i_value-1;
    }
    return i_value;
#else // a more concise solution
    return delta>=0.5 ? i_value+1
                      : delta<=-0.5 ? i_value-1
                                    : i_value;
#endif
}

int
number_of_digits(int value)
{
#if 0 // one possible solution
    int digits=1;
    for(value/=10; value!=0; value/=10)
    {
        digits+=1;
    }
#else // a more concise solution
    int digits=0;
    do
    {
        value/=10;
        digits+=1;
    } while(value!=0);
#endif
    return digits;
}

//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~