tp1 5

Travaux Pratiques d'Algorithmique et
Programmation
J.B. Casimir, I. François, M. Ghienne, P. Leclaire, P.A. Yvars
17 novembre 2021
2021-22 Algorithmique et Programmation
J.B. Casimir, I. François, M. Ghienne, P. Leclaire, P.A. Yvars 2

Table des matières
1 Débuter en Langage C 7
1.1 Préparation de l'environnement de travail . . . . . . . . . . . . . . . . . . 7
1.2 Premier programme élémentaire . . . . . . . . . . . . . . . . . . . . . . . 8
1.2.1 Rappel sur le processus de compilation . . . . . . . . . . . . . . . 8
1.2.2 Édition de la source . . . . . . . . . . . . . . . . . . . . . . . . . . 8
1.2.3 Compilation du chier source . . . . . . . . . . . . . . . . . . . . 9
1.2.4 Ajout d'un chier d'en-tête et d'une macro . . . . . . . . . . . . . 9
1.2.5 Recompiler le programme . . . . . . . . . . . . . . . . . . . . . . 10
1.3 Hello world ! . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10
1.3.1 La structure des chiers du programme . . . . . . . . . . . . . . . 10
1.3.2 Les diérentes sources . . . . . . . . . . . . . . . . . . . . . . . . 12
1.3.3 La compilation . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13
1.4 Structures de contrôle . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13
1.4.1 Structures de contrôle de type sélection . . . . . . . . . . . . . . . 13
1.4.2 Structures de contrôle de type itératif . . . . . . . . . . . . . . . . 14
1.5 Tableaux . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14
1.5.1 Tableaux à une dimension . . . . . . . . . . . . . . . . . . . . . . 14
1.5.2 Tableaux à 2 dimensions . . . . . . . . . . . . . . . . . . . . . . . 15
2 Fonctions 17
2.1 Première partie : Modularisation du TP1 . . . . . . . . . . . . . . . . . . 17
2.2 Deuxième partie : les Caractères . . . . . . . . . . . . . . . . . . . . . . . 17
2.2.1 Le code ascii . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17
2.2.2 Transformation de caractères . . . . . . . . . . . . . . . . . . . . 18
2.3 Troisième partie : les Chaînes de Caractères . . . . . . . . . . . . . . . . 18
2.4 Quatrième partie : le passage d'argument par adresse . . . . . . . . . . . 19
2.4.1 Produit scalaire . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19
2.4.2 Produit vectoriel . . . . . . . . . . . . . . . . . . . . . . . . . . . 19
2.4.3 Transformation de caractères . . . . . . . . . . . . . . . . . . . . 19
2.4.4 Transformation de chaîne de caractères . . . . . . . . . . . . . . . 19
2.5 Cinquième partie : Bibliothèque statique . . . . . . . . . . . . . . . . . . 20
2.5.1 Création de la bibliothèque FonctionsSupmeca.lib . . . . . . . . . 20
2.5.2 Utilisation de la bibliothèque . . . . . . . . . . . . . . . . . . . . 20
3
3 Tableaux 21
3.1 Calcul du champ de température d'une plaque d'acier . . . . . . . . . . . 21
3.2 Méthode numérique utilisée . . . . . . . . . . . . . . . . . . . . . . . . . 22
3.2.1 Algorithme . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 22
3.3 Programmons cet algorithme . . . . . . . . . . . . . . . . . . . . . . . . . 23
3.3.1 Débutons par le main() . . . . . . . . . . . . . . . . . . . . . . . . 23
3.3.2 Fonction CopieMatrice() . . . . . . . . . . . . . . . . . . . . . . . 25
3.3.3 Fonction CalculDi() . . . . . . . . . . . . . . . . . . . . . . . . . 25
3.3.4 Fonction CalculMax() . . . . . . . . . . . . . . . . . . . . . . . . 25
3.3.5 Fonction CalculeConditionsLimites() . . . . . . . . . . . . . . . . 25
3.3.6 Fonction CalculTemperature() . . . . . . . . . . . . . . . . . . . . 26
3.3.7 Bravo ! . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 26
4 Structures 29
4.1 Objectif de l'exercice . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 29
4.2 Le type complexe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 29
4.2.1 Dénition de type . . . . . . . . . . . . . . . . . . . . . . . . . . . 29
4.2.2 Parties réelles, imaginaires, module et argument . . . . . . . . . . 29
4.2.3 Achage . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 30
4.2.4 Conjugué . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 30
4.2.5 Programme principal . . . . . . . . . . . . . . . . . . . . . . . . . 30
4.3 Traitement arithmétique des complexes . . . . . . . . . . . . . . . . . . . 30
4.4 Application : représentation de Nyquist . . . . . . . . . . . . . . . . . . . 31
5 Lecture sur chier formaté 33

5.1 Objectif de l'exercice . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 33
5.1.1 Fichier de données . . . . . . . . . . . . . . . . . . . . . . . . . . 33
5.1.2 Rugosité . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 34
5.1.3 Exemple de prol . . . . . . . . . . . . . . . . . . . . . . . . . . . 35
5.2 Lecture du chier . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 36
5.3 Détermination des paramètres de l'état de surface . . . . . . . . . . . . . 36
5.3.1 Calcul de Rt . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 36
5.3.2 Régression linéaire . . . . . . . . . . . . . . . . . . . . . . . . . . 36
5.3.3 Tracé du prol redressé . . . . . . . . . . . . . . . . . . . . . . . . 37
5.3.4 Calcul de Rp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 38
5.3.5 Calcul de Ra . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 38
5.3.6 Calcul de Rq . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 38
5.4 Tri de la variable Altitude . . . . . . . . . . . . . . . . . . . . . . . . . . 38
5.5 Exploitation du tableau trié . . . . . . . . . . . . . . . . . . . . . . . . . 38
5.5.1 Détermination des quartiles . . . . . . . . . . . . . . . . . . . . . 38
5.5.2 Répartition en classes . . . . . . . . . . . . . . . . . . . . . . . . . 39

Travail Pratique 1
Débuter en Langage C
L'objectif de ce premier sujet est de prendre en main les notions essentielles du
langage C.
Dans un premier temps, nous nous intéresserons à l'aspect compilé des programmes
réalisés grâce au langage C. Pour ceci, nous utiliserons l'interpréteur de commandes et
les programmes en ligne de commandes des outils de Microsoft Visual Studio.
Dans un deuxième temps, nous réaliserons des petits programmes utilisant des struc-
tures de contrôle, des expressions, des variables simples, des tableaux et des constantes
symboliques à l'aide de l'interface graphique de Visual Studio. Nous utiliserons aussi
deux fonctions de la librairie standard du langage C : printf et scanf.
1.1 Préparation de l'environnement de travail

Lancer l'invite de commande de Visual Studio 2010 : "Démarrer" => "Tous les pro-
grammes" => "Microsoft Visual Studio 2010" => "Visual Studio Tools" => "Invite
de commande de Visual Studio 2010".
Au prompt C :\Program les (x86)\Microsoft Visual Studio 10.0\vc, taper les com-
mandes suivantes :
cd /d C:\users\mon_login\mes documents
md ALGO\TP1
cd ALGO\TP1
dir
Descriptif succinct de ces commandes :

cd (change directory) permet de positionner l'invite de commande dans le dossier
voulu (voir "cd /?").
md (make directory) permet de créer des dossiers (voir "md /?").
dir permet de lister les dossiers et chiers d'un dossier (voir "dir /?").

1.2 Premier programme élémentaire

1.2.1 Rappel sur le processus de compilation
Le schéma 1.1 décrit le processus de compilation d'un programme (hello.exe)
d'après un chier source C élémentaire (hello.c).
Figure 1.1 Compilation d'un chier source en C
Description des diérentes abréviations et extensions de chiers :

PP préprocesseur
C compilateur
EL éditeur de liens
*.c chier source en C
*.h chier d'en-tête en C
*.pp chier source après préprocesseur
*.obj chier objet
*.exe chier exécutable
En vert, les chier texte brut et, en rouge, les chiers binaires.
1.2.2 Édition de la source

Taper la commande "notepad hello.c", puis saisir le code source donné par le
listing 1.1.
Listing 1.1 Premier code
1 // Ceci e s t mon premier f i c h i e r c .
2
3 // d é f i n i t i o n de l a f o n c t i o n main
4 int main ( )
5 {
6 int i = 2 ;
7 i = i +5;
8 return i ;
9 }
Enregistrer le chier (Ctrl+s).

1.2.3 Compilation du chier source

Taper les commandes suivantes :
cl /TC /EP hello.c > hello.pp
dir
cl /TC /c hello.pp
dir
link hello.obj
dir
hello
Voici quelques explications pour comprendre ces commandes. La commande
cl /TC /EP hello.c > hello.pp exécute le préprocesseur sur le chier hello.c et
envoie le résultat dans le chier hello.pp. La commande cl /TC /c hello.pp exécute
le compilateur sur le chier hello.pp et envoie le résultat dans le chier hello.obj. La
commande link hello.obj édite les liens du chier hello.obj et crée le programme
hello.exe.
En lançant régulièrement la commande "dir", on peut constater la création des
diérents chiers.
La commande hello permet d'exécuter le programme généré.
Il est possible de consulter le chier généré par le préprocesseur avec la commande
"notepad hello.pp". Que peut-on constater ?
1.2.4 Ajout d'un chier d'en-tête et d'une macro
Figure 1.2 Compilation d'un chier source en C et d'un chier d'en-tête
Éditer un nouveau chier d'en-tête avec la commande "notepad hello.h" et saisir

le code donné par le listing 1.2.

Listing 1.2 Premier en-tête

1 // Ceci e s t mon premier f i c h i e r h .
2
3 // d é c l a r a t i o n d ' une macro
4 #define RET 5
5
6 // d é c l a r a t i o n de l a f o n c t i o n main
7 int main ( ) ;
Modier le chier hello.c avec la commande notepad hello.c et le code du listing
1.3.
Listing 1.3 Premier en-tête
1 // Ceci e s t mon premier f i c h i e r c .
2
3 // i n c l u s i o n du f i c h i e r d ' en= t ê t e
4 #include " h e l l o . h"
5
7 int main ( )
8 {
9 return RET;
10 }
1.2.5 Recompiler le programme

Utiliser les commandes suivantes pour recompiler le programme :
cl /TC /c hello.pp
link hello.obj
Vérier que le programme s'exécute sans erreur avec la commande "hello".
Éditer le chier hello.pp avec la commande "notepad hello.pp". Que peut-on
dire ?
1.3 Hello world !

Nous allons maintenant réaliser un programme élémentaire qui achera Hello
world ! . Nous réaliserons une méthode main qui sera simplement chargée d'appeler
une seconde méthode hello qui se chargera de l'achage.
1.3.1 La structure des chiers du programme

La structure des chiers est donnée par le shéma 1.3

Figure 1.3 Compilation du programme "Hello World !".

1.3.2 Les diérentes sources

Le contenu des diérents chiers sources est donné par les listing 1.6, 1.7, 1.4, 1.5.
Listing 1.4 Premier chier d'en-têtes d'"Hello World !"
1 // h e l l o . h
2
3 // d é c l a r a t i o n de l a f o n c t i o n main
4 int main ( ) ;
Listing 1.5 Programme principal d'"Hello World !"

1 // h e l l o . c
2
3 // i n c l u s i o n s d i v e r s e s
4 #include " h e l l o . h" // en= t ê t e c o r r e s p o n d a n t à l a s o u r c e
5 #include " func . h" // i n c l u s i o n de l ' en= t ê t e de l a méthode h e l l o
6
8 int main ( )
9 {
10 hello ();
11 return 0 ;
12 }
Listing 1.6 Second chier d'en-têtes d'"Hello World !"

1 // func . h
2
3 // d é c l a r a t i o n de l a f o n c t i o n h e l l o
4 void h e l l o ( ) ;
Listing 1.7 Fichier des fonctions d'"Hello World !"

1 // func . c
2
3 // i n c l u s i o n s d i v e r s e s
4 #include " func . h" // en= t ê t e c o r r e s p o n d a n t à l a s o u r c e
5 #include <s t d i o . h> // i n c l u s i o n d ' un f i c h i e r d ' en= t ê t e standard
6
7 // d é f i n i t i o n de l a f o n c t i o n h e l l o
8 void h e l l o ( )
9 {
10 p r i n t f ( " H e l l o world ! \ n" ) ;
11 }

1.3.3 La compilation
Utiliser les commandes suivantes :

cl /TC /EP func.c > func.pp
cl /TC /c hello.pp
cl /TC /c func.pp
link hello.obj func.obj
Faire des commentaires sur les chiers générés par le pré-processeur.
1.4 Structures de contrôle

À partir de ce point, c'est l'interface graphique de Microsoft Visual Studio qui sera
utilisée.
1.4.1 Structures de contrôle de type sélection

La structure de contrôle de if (expression) bloc1 else bloc2 permet de rendre condi-
tionnelle l'exécution des éléments de programme bloc1 et bloc2 selon la valeur de ex-
pression au moment de l'exécution du if.
Écrire un programme en langage C qui commence par lire deux variables entières v1
et v2. Il teste v1 et imprime v1 - 15 si v1 est supérieur à 15, il imprime v1 si non, puis
imprime la valeur absolue de v2. Enn, il se termine si les deux valeurs lues valent 0. Le
programme recommence la lecture des deux variables tant que la condition de n n'est
pas atteinte.
Compléter le listing 1.8.
Listing 1.8 Structures de contrôle
1 #include <s t d i o . h>
2
3 int main ( )
4 {
5 int v1 , v2 ;
6 do {
7 p r i n t f ( "\ nEntrer l e s v a l e u r s de v1 e t v2 : " ) ;
8 s c a n f ( "%d%d" , &v1 , &v2 ) ;
9 p r i n t f ( "\nPour v é r i f i c a t i o n : v1 = %d e t v2 = %d\n" , v1 , v2 ) ;
10 if ( . . . )
11 p r i n t f ( "\nv1 = 15 = %d" , v1 = 1 5 ) ;
12 else
13 p r i n t f ( "\nv1 =%d" , v1 ) ;
14 if ( . . . )
15 p r i n t f ( "\n | v2 | = %d" , =v2 ) ;

16 else
17 p r i n t f ( "\n | v2 | = %d" , +v2 ) ;
18 } while ( . . . )
19 return 0 ;
20 }
1.4.2 Structures de contrôle de type itératif

Le programme 1.9 consiste à initialiser un tableau de cent entiers.
Listing 1.9 Structure de contrôle itérative
1 int main ( )
2 {
3 int t [ 1 0 0 ] , i ;
4 for ( i = 0 ; i < 1 0 0 ; ++i )
5 t [ i ] = (4 * ( i +1)) >> 2 ;
6 return 0 ;
7 }
Réécrire ce programme en remplaçant l'instruction for par une instruction while

permettant d'avoir un comportement équivalent et acher le tableau t dans une seconde
boucle.
1.5 Tableaux
1.5.1 Tableaux à une dimension
1/ Calcul de moyenne
Écrire un programme qui aecte à un entier s la moyenne des n premières valeurs
d'un tableau t d'entiers de vingt éléments initialisés par : t[i] = 2 * i + 1.
n est saisi au clavier, si n ne correspond pas à un indice valide du tableau, on ache
un message d'erreur et on met n au programme. Sinon s doit être aché.
2/ Produit scalaire de deux vecteurs

On veut faire le produit scalaire de 2 vecteurs d'entiers. Les 2 vecteurs seront déclarés
et dimensionnés dans la fonction main() à l'aide d'une constante symbolique ; leur taille
exacte ainsi que leurs composantes y seront lues et le calcul y sera eectué. On précise
que la saisie au clavier d'un entier n au format décimal peut être réalisée par l'instruction
suivante :
scanf("%d",&n);

1.5.2 Tableaux à 2 dimensions

1/ Achage d'un tableau
On déclarera un tabeau d'entiers dimensionné à l'aide de 2 constantes symboliques.
Les nombres de lignes et de colonnes réellement utilisés seront lus ainsi que les éléments
du tableau. Ceux-ci seront lus "en ligne".
Ecrivez une suite d'instructions permettant d'acher le tableau sous la forme suivante.
Les éléments sont séparés par une tabulation (caratère '\t').
Figure 1.4 Achage du tableau
2/ Transformation
Vous transformerez le tableau de la façon suivante :
Tout élément sera égal à la somme de lui-même et des éléments situés à sa droite
sur la même ligne.
a) d'abord en appliquant rigoureusement la dénition de la transformation.
b) ensuite en cherchant à minimiser le nombre d'opérations eectuées.


Travail Pratique 2
Fonctions
A chaque changement d'exercice vous conserverez le même programme principal et les
fonctions développées précédemment mais vous mettrez en commentaires les instructions
d'appel relatives aux questions précédentes.
2.1 Première partie : Modularisation du TP1

Créez un nouveau projet (TP2) constitué d'un seul chier contenant :
• un programme principal chargé de réaliser les entrées-sorties utilisateur,
• deux fonctions répondant aux cahiers des charges des questions 1.5.1b/ et 1.5.2b/
du TP précédent. Les prototypes de ces fonctions seront :
double produit_scalaire (double [], double [], int) ;

valeur de retour de la fonction : double est la valeur du produit scalaire cal-
culé.
arguments : deux tableaux à multiplier scalairement et un entier qui est la
dimension des tableaux.
void transformation(int [][N], int , int) ;

arguments : tableau à transformer et deux entiers correspondants aux dimen-
sions du tableau.
2.2 Deuxième partie : les Caractères

2.2.1 Le code ascii
Pour vérier que, dans le code Ascii, les caractères majuscules d'une part et mi-
nuscules d'autre part sont bien consécutifs et dans l'ordre alphabétique vous taperez et
exécuterez le programme donné sur le listing 2.1 :

Listing 2.1 Achage des codes ascii

2 void main ( ) {
3 int i ;
4 for ( i = 'A ' ; i <= 'Z ' ; i ++)
5 p r i n t f ( "%c %c \n" , i , i + ' a ' = 'A ' ) ;
6 }
2.2.2 Transformation de caractères

Vous dénirez une fonction typée qui transforme un caractère de la façon suivante :
si c'est une lettre minuscule elle retourne la lettre majuscule correspondante,
si ce n'est pas une lettre minuscule, elle retourne le caractère non modié.
Son prototype sera :
char transforme_caractere_majuscule (char) ;

Vous écrirez un programme principal qui permet de tester cette fonction.
2.3 Troisième partie : les Chaînes de Caractères

Dans cette partie nous allons utiliser la fonction dénie précédemment.
a/ Vous dénirez une fonction qui copie une chaîne de caractères dans une autre
en transformant les lettres minuscules en lettres majuscules, les autres carac-
tères restant inchangés ; bien entendu cette fonction utilisera la fonction trans-
forme_caractere_majuscule, et son prototype sera :
void copie_chaine_majuscule (char[], char[]) ;
b/ Vous dénirez une fonction qui modie une chaîne de caractères, donc sans en
faire de copie, en transformant les lettres minuscules en lettres majuscules, les
autres caractères restant inchangés ; son prototype sera :
void modification_chaine_majuscule (char[]) ;
c/ Vous dénirez une fonction qui copie une chaine de caractères dans une autre
en inversant l'ordre des caractères et en transformant les lettres minuscules en
lettres majuscules, les autres caractères restant inchangés ; de plus elle retournera
le nombre de lettres transformées et son prototype sera :

int copie_inverse_chaine_majuscule (char[], char[]) ;
Vous écrirez un programme principal qui permet de tester ces trois fonctions ;
pour lire une chaîne de caractères pouvant contenir plusieurs mots, et donc des
espaces, vous utiliserez l'instruction : gets(chaine) ; où chaine est l'identicateur
de la variable lue, l'achage pouvant se faire avec l'instruction : puts(chaine) ;.
2.4 Quatrième partie : le passage d'argument par adresse

2.4.1 Produit scalaire
Dénissez une nouvelle fonction produit_scalaire de prototype :
void produit_scalaire (double [], double [], int, double*) ;
2.4.2 Produit vectoriel

Dénissez une nouvelle fonction produit_vectoriel de prototype :
void produit_vectoriel(double [], double[], double []) ;
Cette fonction retourne rien (void) mais produit le résultat par son troisième argument.
2.4.3 Transformation de caractères

Vous dénirez une fonction non typée, i.e. une procédure, qui modie le caractère
transmis en argument de façon analogue à la fonction transforme_caractere_majuscule
de l'exercice précédent ; cet argument devra donc impérativement être passé par adresse.
Son prototype sera :
void modification_caractere_majuscule (char *) ;
Vous écrirez un programme principal qui permet de tester cette fonction.
2.4.4 Transformation de chaîne de caractères

Dans cette partie vous utiliserez la fonction dénie ci-dessus pour réécrire les fonctions
copie_chaine_majuscule, modication_chaine_majuscule et copie_inverse_chaine_majuscule
de l'exercice précédent.

2.5 Cinquième partie : Bibliothèque statique

2.5.1 Création de la bibliothèque FonctionsSupmeca.lib
Il est possible de créer ses propres bibliothèques de programmes. Pour pouvoir réuti-
liser facilement ces bibliothèques dans Visual Studio, il sut de les créer en tant que
nouveaux projets de la solution active. On se propose de créer la bibliothèque Fonctions-
Supmeca.lib.
Créez, dans cette bibliothèque, une fonction d'achage de matrices dont le prototype
sera :
void AfficheMatrice(double [][MMAX], int, int);
Le prototype sera placé dans un chier .h dans lequel la constante symbolique MMAX
sera dénie.
2.5.2 Utilisation de la bibliothèque

Pour indiquer à l'éditeur de liens l'utilisation d'une bibliothèque particulière, les pro-
priétés du projet doivent être modiées. Propriétés -> Propriétés communes -> Struc-
tures et références -> Ajouter une nouvelle référence.
Utilisez la fonction AcheMatricede la bibliothèque pour acher la matrice avant

et après transformation de la 1ère partie.

Travail Pratique 3
Tableaux
3.1 Calcul du champ de température d'une plaque d'acier

L'objectif de ce TP est de calculer le champ stationnaire de température d'une plaque
plane lorsque celle-ci est soumise à des conditions aux limites en température sur chacune
de ses faces. Le problème consiste à résoudre l'équation de Laplace. Il s'agit de résoudre
une équation aux dérivées partielles de type elliptique.
Aperçu du champ de température calculé :

Problème de thermique à résoudre :

Pour une plaque de dimensions x ∈ [0; a] et y ∈ [0; b],
∀x ∈ [0, a], ∀y ∈ [0, b], ∆T (x, y) = 0 soit ∂2T ∂2T


 ∂x2
+ ∂y 2
=0
 T (x = 0, y) = Tgauche


T (x = a, y) = Tdroite



 T (x, y = 0) = Thaut

T (x, y = b) = Tbas
3.2 Méthode numérique utilisée

La résolution du problème est numérique, et utilise une discrétisation en espace dans
les deux directions x et y . La température en chaque point de discrétisation sera donc
calculée à partir des températures des points juxtaposés. La discrétisation utilisée sera
basée sur la méthode des diérences nies : ∆x2 . ∂f
∂x
(x) = f (x − ∆x) − 2f (x) + f (x + ∆x)
La discrétisation de l'équation de la chaleur nous donne :
1 1
0= 2
[Ti,j−1 − 2Ti,j + Ti,j+1 ] + [Ti−1,j − 2Ti,j + Ti+1,j ]
∆x ∆y 2

2 2 1 1
⇔ + Ti,j = [Ti,j−1 + Ti,j+1 ] + [Ti−1,j + Ti+1,j ]
∆x2 ∆y 2 ∆x2 ∆y 2
Il nous faut balayer la plaque en x et y pour calculer toutes les températures.
On voit que la température en un point dépend des 4 points juxtaposés. Certains de
ces points ont des températures qui ne sont pas encore calculées. . .... Nous partirons donc
de valeurs de température arbitraires, et après plusieurs itérations, les températures
seront approchées de plus en plus nement et convergeront vers la solution.
Attention : les diérents pas de calcul ne sont en rien liés à l'évolution de la température
au cours du temps. Cette évolution est purement numérique.
3.2.1 Algorithme
Les températures seront stockées dans un tableau bidimensonnel T. La température
au coin haut-gauche de la plaque sera stokée en T[0][0], la température au coin bas-droit
de la plaque sera stockée en T[n-1][m-1]. n et m sont des variables de l'algorithme per-
mettant de xer la nesse de la grille.
L'algorithme se décompose selon les opérations suivantes :
Initialiser le tableau des températures à la valeur moyenne des températures im-

posées sur les bords.
tant que la précision voulue n'est pas pas atteinte et que le nombre d'itérations
est inférieur à 100 :
acher le numéro d'itérations sur la sortie standard,
(Re-)Calculer les températures aux bords

(Re-)Calculer les températures de chaque point intérieur de la plaque

acher les températures courantes sur la sortie standard
calculer la précision actuelle en évaluant le maximum de la diérence entre les
températures courantes et les températures de l'itération précédente.
acher la précision actuelle sur la sortie standard
acher la position du point où la précision est la plus mauvaise
sauvegarder les températures courantes pour l'itération suivante et incrémen-
ter le compteur d'itérations
n tant que
Ecrire les températures calculées dans un chiers grace à la fonction fournie :
EcrireSurface 1
3.3 Programmons cet algorithme

Pour simplier les tests de votre programme, nous n'utiliserons pas d'entrée de valeurs
numériques au clavier. Toutes les données seront initialisées dans le code : dimensions
de la plaque, etc. . .
3.3.1 Débutons par le main()

Création du projet
Créer un nouveau projet intitulé TP3 de type Application Console. L'arborescence
de la solution doit ressember à celle-ci.
1. Cette fonction est à placer dans la bibliothèque FonctionsSupmeca.lib créée au TP2 et fera l'objet
de prototypes à placer dans le chier .h de cette librairie

Initialisations
Déclarez le tableau et les variables nécessaires au stockage des températures puis ini-
tialisez le tableau (premier point de l'algorithme décrit en section 3.2.1). On utilisera les
constantes symboliques N M AX , M M AX dénies dans le chier FonctionsSupmeca.h
de la bibliothèque créée au TP2 pour déclarer le tableau des températures. Deux va-
riables entières n, m permettant de xer le nombre de points de discrétisations à n × m
seront déclérées et utilisées dans vos algorithmes (n ≤ N M AX , m ≤ M M AX ).
Ainsi, on pourra débuter le programme principal de la façon suivante :

1 #include " . . / FonctionsSupmeca / FonctionsSupmeca . h"
3 #include <math . h>
4
5 int main ( ) {
6 // d e c l a r a t i o n s
7 double T[NMAX] [MMAX] , Tancien [NMAX] [MMAX] , D i f f [NMAX] [MMAX] ;
8 int n=18 ,m=12;
9 double a =0.5 , b =0.5 ,Tg=20 ,Td=20 ,Th=20 ,Tb=100 ,Tmoy ;
10 int i , j , imax , jmax , i t e r a t i o n =0;
11 double P r e c i s i o n V o u l u e =0.5 , P r e c i s i o n A c t u e l l e , dx=a /(m= 1) , dy=b /( n = 1);
12 // c o m p l é t e r par l ' i n i t i a l i s a t i o n des t e m p é r a t u r e s
13 ...
14 return 0 ;
15 }
De manière à vérier cette opération, utilisez la fonction AcheMatrice de la biblio-
thèque pour acher le tableau ainsi créé.
Implémentation de l'algorithme de haut niveau

Implémentez la suite de l'algorithme de haut niveau décrit en section 3.2.1. On sup-
pose disposer des cinq fonctions décrites ci-dessous. Dans un premier temps ces fonctions
ne sont pas implémentées. Elles sont simplement créées en respectant leur en-tête mais
en leur dénissant un corps vide constitué d'un jeu d'accolades ouvrante et fermante.
void CopieMatrice( double T1[ ][MMAX], double T2[ ][MMAX], int n, int m ){ ... }
Cette fonction copie T1 dans T2, les dimensions n, m de ces deux tableaux sont
passées en argument, elle ne renvoie rien.
void CalculDiff(double T1[ ][MMAX], double T2[ ][MMAX], double diff[ ][MMAX],
int n, int m){ ... }
Cette fonction calcule la diérence des matrices T1 et T2 et stocke le résultat
dans la matrice di, les dimensions n, m de ces tableaux sont passées en argu-
ment, elle ne renvoie rien.

double CalculMax ( double A[][MMAX] , int *ierr, int *jerr, int n, int m ){ ...
Cette fonction permet de calculer le maximum d'un tableau en valeur absolue
et de l'envoyer en valeur de retour. Cette fonction devra aussi calculer ierr et
jerr, qui représentent la position du point où la précision du calcul est la plus
mauvaise. Pour que cette fonction puisse "produire" 3 valeurs, il faudra
utiliser le passage par adresse.
void CalculeConditionsLimites (double T[][MMAX], double Th, double Td,
double Tb, double Tg, int n, int m ){ ... }
Cette fonction impose les températures T h, T b, T d et T g sur le bord haut, bas,
droit et gauche respectivement.
void CalculeTemperature (double T[][MMAX], double dx, double dy, int n, int m){
Cette fonction calcule la température courante en tout point intérieur à la plaque.
dx, dy sont les distances respectivement selon x et selon y des points de discréti-
sation spatiale.
3.3.2 Fonction CopieMatrice()

Implémentez la fonction CopieMatrice. Une fois cette fonction écrite et compilée,
testez la en lançant le programme.
3.3.3 Fonction CalculDi()

Implémentez la fonction CalculDi. Une fois cette fonction écrite et compilée, testez
la en lançant le programme.
3.3.4 Fonction CalculMax()

Implémentez la fonction CalculMax. Une fois cette fonction écrite et compilée, testez
la en lançant le programme.
Rem : vous pourrez utiliser la fonction double fabs(double) qui renvoie la valeur
absolue d'un nombre ottant. Elle est déclarée dans math.h
3.3.5 Fonction CalculeConditionsLimites()

Implémentez la fonction CalculeConditionsLimites. Cette fonction impose les tempé-
ratures sur les bords de la plaque. On pourra placer une température moyenne au coin
situé sur deux cotés adjacents.

3.3.6 Fonction CalculTemperature()

Implémentez la fonction CalculTemperature. Cette fonction permet de mettre à jour
le tableau des températures pour l'itération en cours de la manière suivante :
pour tout i et j à l'intérieur

h de la plaque,
i appliquer la formule de calcul issue de
l'équation de la chaleur : ∆x2 + ∆y2 Ti,j = ∆x1 2 [Ti,j−1 + Ti,j+1 ]+ ∆y1 2 [Ti−1,j + Ti+1,j ]
2 2
Les arguments dx et dy de la fonction CalculeTemperature correspondent au pas

de la discrétisation en espace notés ∆x et ∆y .
3.3.7 Bravo !
Vous avez réalisé votre première résolution numérique. Cet algorithme de résolution
n'est pas vraiment optimisé, mais a l'avantage d'être assez simple.
Pensez à vérier le comportement de votre programme vis-a-vis de l'algorithme pro-
posé au paragraphe 3.2.1
les achages demandés sont-ils bien présents ?

les températures sur les bords sont-elles bien respectées ?
l'algorithme converge-t-il ?
Pour aller plus loin, vous pouvez modier votre programme pour
créer une interface utilisateur : introduction des données au clavier.

acher une carte sous la forme d'une matrice contenant de -, , +, ++ selon le
niveau de température.
qu'il prenne en compte un bord isolé thermiquement (ux nul)
qu'il puisse résoudre des problèmes in-stationnaires en résolvant pas de temps
successifs avec la méthode déjà programmée
...
Annexes

Ordre fj−3 fj−2 fj−1 fj fj+1 fj+2 fj+3 Dérivées

1 à gauche -1 1 h.f (1)
1 à droite -1 1 h.f (1)
2 à gauche 1 -4 3 2h.f (1)
2 centré -1 0 1 2h.f (1)
2 à droite -3 4 -1 2h.f (1)
1 à gauche 1 -2 1 h2 .f (2)
1 à droite 1 -2 1 h2 .f (2)
2 à gauche -1 4 -5 2 h2 .f (2)
2 centré 1 -2 1 h2 .f (2)
2 à droite 2 -5 4 -1 h2 .f (2)
1 centré 1 -4 6 -4 1 h4 .f (4)
Table 3.1 Diérences nies
Masse Conductibilité Capacité

Matériau volumique thermique calorique
ρ [kg/m3] λ [W/m/K] Cp [J/K/kg]
Aluminium peu allié 2700 240 929
alliage d'Aluminium pour moulage 2700 146 929
Cuivre peu allié 8960 400 380
Acier peu allié 7850 35 450
Acier inox 7850 30 450
Fer 7870 52 460
Fonte FGS 7200 35 460
Fonte FGL 7200 50 460
Platine 21450 71.6 130
Alumine Al2 O3 (céramique) 3970 12 10.9 [500°C]
6.2 [1000°C]
Zircone Zr O2 (céramique) 5890 2
Air 1.023 0.024 -
Eau 1000 0.552 -
Table 3.2 Propriétés thermiques


Travail Pratique 4
Structures
4.1 Objectif de l'exercice

On ne dispose pas en langage C de type numérique standard associé au nombres
complexes. On se propose, dans cet exercice d'en construire un et de dénir un jeu de
fonctions permettant de les utiliser simplement.
4.2 Le type complexe
4.2.1 Dénition de type

Proposez un type structure permettant de déclarer un nombre complexe à partir
de sa partie réelle et de sa partie imaginaire. Vous utiliserez l'instruction typedef pour
dénommer ce type complexe.
4.2.2 Parties réelles, imaginaires, module et argument

Dénissez les fonctions ReelImaginaire2Cplx et ModuleArgument2Cplx permettant de
construire un complexe respectivement à partir des parties réelles et imaginaires puis
du module et de l'argument. Inversement, dénissez une fonction Cplx2ModuleArgument
permettant d'obtenir le module et l'argument d'un nombre complexe. Les prototypes
des fonctions développées seront ceux donnés sur le listing 4.1 :
Listing 4.1 Prototypes des fonctions à dénir

1 complexe R e e l I m a g i n a i r e 2 C p l x ( double , double ) ;
2 complexe ModuleArgument2Cplx ( double , double ) ;
3 void Cplx2ModuleArgument ( complexe , double * , double * ) ;

4.2.3 Achage
On souhaite pouvoir acher à l'écran des nombres complexes pour contrôler leur
valeur. L'achage sera réalisé selon les deux formats des complexes :
partie réelle et partie imaginaire

module et argument
selon une représentation semblable à celle donnée ci-dessous :
z = a + bi = r e^(it)
Dénissez cette fonction d'achage AcheCplx.
4.2.4 Conjugué
Dénissez une fonction Conjugue produisant le conjugué d'un complexe donné. Le
prototype de cette fonction sera :
complexe Conjugue(complexe);
4.2.5 Programme principal

An de valider vos fonctions, déclarez dans la fonction main un complexe, ini-
tialisez le et achez son conjugué. Proposez une instruction de test de la fonction
Cplx2ModuleArgument.
4.3 Traitement arithmétique des complexes

On souhaite pouvoir réaliser simplement des opérations arithmétiques sur les nombres
complexes. Dénissez les fonctions dont les prototypes sont donnés sur le listing 4.2
Listing 4.2 Prototypes des fonctions arithmétiques

1 complexe SommeCplx ( complexe , complexe ) ;
2 complexe D i f f e r e n c e C p l x ( complexe , complexe ) ;
3 complexe M u l t i p l i c a t i o n C p l x ( complexe , complexe ) ;
4 complexe D i v i s i o n C p l x ( complexe , complexe ) ;
5 complexe PuissanceCplx ( complexe , int ) ;
6 complexe PuissanceCplxRec ( complexe , int ) ;
Les deux derniers prototypes correspondent respectivement à une version itérative

puis récursive de la fonction puissance.

4.4 Application : représentation de Nyquist

La fonction de transfert d'un oscillateur harmonique amorti à un degré de liberté est
donnée par :
1
ĥ(ω) = 2 2
(4.1)
ω0 − ω + 2iηωω0
ω0 est la pulsation propre du système non amorti, η est l'amortissement du système et
ω la pulsation d'excitation du système.
Ecrire une fonction qui stocke dans un tableau de complexes les valeurs de la fonction
de transfert ĥ(f ) sur l'intervalle fréquentiel [fmin , fmax ] discrétisé par nf points fréquen-
tiels. On rappelle que pulsation ω et fréquence f sont liées par ω = 2πf . Le prototype
de cette fonction sera :
int Nyquist(complexe[],double, double, int, double,double);
Les paramètres de cette fonction seront respectivement :
le tableau de stockage des valeurs de la fonction de transfert.
les fréquences fmin et fmax .
le nombre de fréquences discrétisant l'intervalle [fmin , fmax ].
la pulsation propre ω0
l'amortissement η .
La fonction retourne le nombre de valeurs contenues dans le tableau, c'est à dire nf ou

0 dans le cas où nf est supérieur à la taille maximale du tableau qui est xée à N M AX ,
constante symbolique dénie dans FonctionsSupmeca.h de la librairie créée au TP2.
On pourra implémenter et utiliser la fonction Af f icheN yquist des Travaux Dirigés

pour générer un chier 'Excel-compatible' permettant de visualiser la courbe. On rappelle
le prototype de cette fonction.
void AfficheNyquist(complexe[],int,char*,char);
Le 3ème paramètre est le nom du chier à créer alors que le dernier paramètre est le
caractère souhaité pour séparer les valeurs dans ce chier.


Travail Pratique 5
Lecture sur chier formaté
5.1 Objectif de l'exercice

5.1.1 Fichier de données
On souhaite traiter des données provenant d'un appareil de mesure d'états de surface
(Figure 5.1 : SURFASCAN 3S). Cet appareil à contact utilise un palpeur se déplaçant
sur la surface à caractériser selon une ou plusieurs lignes droites.
Figure 5.1 Contrôle de surface par Surfascan 3S
Le déplacement vertical du palpeur est enregistré le long de sa trajectoire et donne

lieu à un prol stocké sur chier texte. Le listing 5.1 présente le contenu du chier généré
lors de la mesure.

Listing 5.1 Format du chier texte généré par SURFASCAN 3S

1 3.0000000000E=01
2 3925
3 4.0000000000E+00
4 1.0000000000E+03
5 1.0000000000E+00
6 1.2401393581E+03
7 ...
8 1.2401396507E+03
Les informations stockées sur ce chier sont :
ligne 1 : vitesse de la mesure en mm.s−1 : double

ligne 2 : nombre de points de la mesure (<4096) : int
ligne 3 : pas d'acquisition en µm : double
ligne 4 : plage du capteur en µm : double
ligne 5 : rayon de pointe du capteur en µm : double
ligne 6 : première valeur du prol en µm : double
lignes suivantes : valeurs suivantes du prol en µm
5.1.2 Rugosité
La norme AFNOR NFE 05-015 décrit certains des paramètres de l'état de surface.
On distingue, entre autres :
Les paramètres géométriques de rugosité : Rt et Rp .
Les paramètres statistiques de rugosité : Ra et Rq .
La dénition de chacun de ces paramètres est la suivante :
Rt : diérence d'altitude entre le point le plus haut et le point le plus bas du prol.
Rp : altitude du point le plus élevé du prol par rapport à la ligne moyenne (ou
droite des moindres carrés).
Ra : moyenne arithmétique de la valeur absolue des altitudes du prol par rapport

à la ligne moyenne.
Rq : moyenne quadratique de la valeur absolue des altitudes du prol par rapport

à la ligne moyenne.

5.1.3 Exemple de prol

La gure 5.2 présente un exemple de prol mesuré puis redréssé après calcul de la
ligne moyenne.
Relevé du profil :
(µm)
100
50
0 1 2 3 4 (mm)
Profil redréssé par la droite des moindres
(µm)
0,5
0,0
-0,5
-1,0
0 1 2 3 4 (mm)
Figure 5.2 Représentation graphique d'une mesure d'état de surface

5.2 Lecture du chier

Vous dénirez une fonction de lecture des données permettant de remplir deux ta-
bleaux statiques, l'un pour les abscisses xi et l'autre pour les altitudes yi ; le nombre de
points de mesure étant lui aussi conservé pour la suite des traitements. Le prototype
d'une telle fonction sera :
int Lecture_fichier (FILE*, double[], double[]) ;
Le chier sera ouvert dans la fonction main() grâce à la fonction fopen, bien entendu
avant d'appeler la fonction précédente, et le programme non exécuté au cas où le chier
ne serait pas trouvé ; ceci peut se faire de la façon suivante :
Listing 5.2 Test d'ouverture dans programma principal
2 int main ( ) {
3 FILE * p f e ;
4 i f ( ( p f e = fopen ( " r u g o s i t e . t x t " , " r " ) ) == ( FILE * )NULL) {
5 p r i n t f ( " Erreur en o u v e r t u r e du f i c h i e r \n" ) ;
6 return = 1;
7 }
8 ...
9 return 0 ;
10 }
Après l'appel de la fontion Lecture_chier, vous vérierez par un achage à l'écran

(printf) les premières valeurs lues avant de traiter les questions suivantes.
5.3 Détermination des paramètres de l'état de surface

5.3.1 Calcul de Rt
Du point de vue statistique ce paramètre correspond à l'étendue de la variable Y =
Altitude, à savoir :
Rt = Ymax − Ymin
Vous dénirez une fonction permettant de calculer ce paramètre, son prototype étant :
double Rt (double[], int) ;
5.3.2 Régression linéaire

Les trois autres paramètres faisant intervenir la ligne moyenne, il est nécessaire de la
déterminer auparavant.

Il s'agit de la droite dite des moindres carrés, c'est-à-dire telle que la somme des
carrés des distances des points à une droite d'équation y = ax + b soit minimale.
Le coecient directeur a de cette droite est donné par :

cov(X, Y )
a=
Sx2
L'ordonnée à l'origine b de cette droite a pour valeur :
b = Y − aX
Vous dénirez une fonction permettant de calculer la moyenne de données stockées

dans un tableau ; son prototype sera :
double Moyenne (double[], int) ;
Vous dénirez ensuite une fonction permettant de calculer la variance de données
stockées dans un tableau ; son prototype sera :
double Variance (double[], double, int) ;
On rappelle l'expression de la variance :
n
1X 2 2
Sx2 = Xi − X
n i=1
Vous dénirez enn une fonction permettant de calculer la covariance de deux va-
riables aléatoires dont les échantillons sont stockés dans deux tableaux ; son prototype
sera :
double Covariance (double[], double, double[], double, int) ;
On rappelle l'expression de la covariance :

n
1X
cov(X, Y ) = Xi Yi − X.Y
n i=1
Votre programme principal sera alors en possession de tous les éléments permettant de
déterminer les coecients a et b de la droite de régression de Y en X .
5.3.3 Tracé du prol redressé

On désire tracer sous Excel le prol de la surface. Pour cela, on stocke dans un
troisième tableau les valeurs yi − yi∗ où yi∗ représente la valeur de l'altitude obtenue par
le modèle linéaire précédent (yi∗ = axi + b). Pour l'achage proprement dit, vous créérez
une fonction qui sauvegarde sur chier texte les valeurs du tableau des abscisses et du
tableau des valeurs yi − yi∗ . Le prototype de cette fonction pourra être :
void Profil(FILE*, double[], double[], int) ;

5.3.4 Calcul de Rp
Vous dénirez une fonction permettant de calculer ce paramètre dont la dénition
est :
Rp = yk tel que (yi − yi∗ ) soit maximal
yi∗ étant la valeur de l'altitude obtenue grâce au modèle linéaire précédent.
Le prototype de cette fonction sera :

double Rp (double[], double[], double, double, int) ;
5.3.5 Calcul de Ra
est : n
1X
Ra = |yi − yi∗ |
n i=1
double Ra (double[], double[], double, double, int) ;
5.3.6 Calcul de Rq
est : n
1X
Rq = (yi − yi∗ )2
n i=1
double Rq (double[], double[], double, double, int) ;
5.4 Tri de la variable Altitude

Vous dénirez une fonction permettant de trier par ordre croissant un tableau de
données et l'utiliserez pour trier la variable Y dénie précédemment ; vous utiliserez la
méthode de tri par extraction vue à la dernière séance de TD. Son prototype sera :
void Tri_extraction (double[], int) ;
5.5 Exploitation du tableau trié

5.5.1 Détermination des quartiles
Vous dénirez une fonction qui déterminera les trois quartiles à partir du tableau
obtenu au paragraphe précédent ; son prototype sera :
void Quartiles (double[], int, double*, double*, double*) ;

5.5.2 Répartition en classes

Dans le but de pouvoir construire aisément un histogramme des mesures réalisées,
vous générerez, toujours à partir du tableau trié, un tableau contenant les nombres
de mesures observées dans k classes de même amplitude ; la valeur de k sera saisie au
clavier dans le programme principal et au plus égale à 10. Ce travail sera eectué dans
une fonction dont le prototype est :
void Repartition_en_classes (double[], int, int, int[]) ;

tp1 5

Transféré par

Informations du document

Titre original

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Formats disponibles

tp1 5

Transféré par

Droits d'auteur :

Formats disponibles

Travaux Pratiques d'Algorithmique et

J.B. Casimir, I. François, M. Ghienne, P. Leclaire, P.A. Yvars

J.B. Casimir, I. François, M. Ghienne, P. Leclaire, P.A. Yvars 2

5 Lecture sur chier formaté 33

J.B. Casimir, I. François, M. Ghienne, P. Leclaire, P.A. Yvars 4

1.1 Préparation de l'environnement de travail

Descriptif succinct de ces commandes :

J.B. Casimir, I. François, M. Ghienne, P. Leclaire, P.A. Yvars 5

1.2 Premier programme élémentaire

Figure 1.1  Compilation d'un chier source en C

Description des diérentes abréviations et extensions de chiers :

1.2.2 Édition de la source

Enregistrer le chier (Ctrl+s).

J.B. Casimir, I. François, M. Ghienne, P. Leclaire, P.A. Yvars 6

1.2.3 Compilation du chier source

1.2.4 Ajout d'un chier d'en-tête et d'une macro

Figure 1.2  Compilation d'un chier source en C et d'un chier d'en-tête

Éditer un nouveau chier d'en-tête avec la commande "notepad hello.h" et saisir

J.B. Casimir, I. François, M. Ghienne, P. Leclaire, P.A. Yvars 7

Listing 1.2  Premier en-tête

1.2.5 Recompiler le programme

1.3 Hello world !

1.3.1 La structure des chiers du programme

J.B. Casimir, I. François, M. Ghienne, P. Leclaire, P.A. Yvars 8

Figure 1.3  Compilation du programme "Hello World !".

J.B. Casimir, I. François, M. Ghienne, P. Leclaire, P.A. Yvars 9

1.3.2 Les diérentes sources

Listing 1.5  Programme principal d'"Hello World !"

Listing 1.6  Second chier d'en-têtes d'"Hello World !"

Listing 1.7  Fichier des fonctions d'"Hello World !"

J.B. Casimir, I. François, M. Ghienne, P. Leclaire, P.A. Yvars 10

cl /TC /EP hello.c > hello.pp

Faire des commentaires sur les chiers générés par le pré-processeur.

1.4 Structures de contrôle

1.4.1 Structures de contrôle de type sélection

J.B. Casimir, I. François, M. Ghienne, P. Leclaire, P.A. Yvars 11

1.4.2 Structures de contrôle de type itératif

Réécrire ce programme en remplaçant l'instruction for par une instruction while

2/ Produit scalaire de deux vecteurs

J.B. Casimir, I. François, M. Ghienne, P. Leclaire, P.A. Yvars 12

1.5.2 Tableaux à 2 dimensions

Figure 1.4  Achage du tableau

J.B. Casimir, I. François, M. Ghienne, P. Leclaire, P.A. Yvars 13

J.B. Casimir, I. François, M. Ghienne, P. Leclaire, P.A. Yvars 14

2.1 Première partie : Modularisation du TP1

• un programme principal chargé de réaliser les entrées-sorties utilisateur,

 double produit_scalaire (double [], double [], int) ;

 void transformation(int [][N], int , int) ;

2.2 Deuxième partie : les Caractères

J.B. Casimir, I. François, M. Ghienne, P. Leclaire, P.A. Yvars 15

Listing 2.1  Achage des codes ascii

2.2.2 Transformation de caractères

 si c'est une lettre minuscule elle retourne la lettre majuscule correspondante,

Son prototype sera :

char transforme_caractere_majuscule (char) ;

2.3 Troisième partie : les Chaînes de Caractères

void copie_chaine_majuscule (char[], char[]) ;

void modification_chaine_majuscule (char[]) ;

J.B. Casimir, I. François, M. Ghienne, P. Leclaire, P.A. Yvars 16

int copie_inverse_chaine_majuscule (char[], char[]) ;

2.4 Quatrième partie : le passage d'argument par adresse

void produit_scalaire (double [], double [], int, double*) ;

2.4.2 Produit vectoriel

5 Lecture sur chier formaté 33

Figure 1.1 Compilation d'un chier source en C

Description des diérentes abréviations et extensions de chiers :

Enregistrer le chier (Ctrl+s).

1.2.3 Compilation du chier source

1.2.4 Ajout d'un chier d'en-tête et d'une macro

Figure 1.2 Compilation d'un chier source en C et d'un chier d'en-tête

Éditer un nouveau chier d'en-tête avec la commande "notepad hello.h" et saisir

Listing 1.2 Premier en-tête

1.3.1 La structure des chiers du programme

Figure 1.3 Compilation du programme "Hello World !".

1.3.2 Les diérentes sources

Listing 1.5 Programme principal d'"Hello World !"

Listing 1.6 Second chier d'en-têtes d'"Hello World !"

Listing 1.7 Fichier des fonctions d'"Hello World !"

Faire des commentaires sur les chiers générés par le pré-processeur.

Figure 1.4 Achage du tableau

double produit_scalaire (double [], double [], int) ;

void transformation(int [][N], int , int) ;

Listing 2.1 Achage des codes ascii

si c'est une lettre minuscule elle retourne la lettre majuscule correspondante,

Utilisez la fonction AcheMatricede la bibliothèque pour acher la matrice avant

Initialiser le tableau des températures à la valeur moyenne des températures im-

(Re-)Calculer les températures de chaque point intérieur de la plaque

3.3.3 Fonction CalculDi()

pour tout i et j à l'intérieur

les achages demandés sont-ils bien présents ?

créer une interface utilisateur : introduction des données au clavier.

Table 3.1 Diérences nies

4.2.1 Dénition de type

Listing 4.1 Prototypes des fonctions à dénir

partie réelle et partie imaginaire

Dénissez cette fonction d'achage AcheCplx.

Listing 4.2 Prototypes des fonctions arithmétiques

le tableau de stockage des valeurs de la fonction de transfert.

les fréquences fmin et fmax .

le nombre de fréquences discrétisant l'intervalle [fmin , fmax ].

Figure 5.1 Contrôle de surface par Surfascan 3S

Listing 5.1 Format du chier texte généré par SURFASCAN 3S

Les informations stockées sur ce chier sont :