Wikiversité

« C pointeurs/Matrices complexes fractions 2 » : différence entre les versions

Navigation interactive dans l’historique
← Modification précédenteModification suivante →
Contenu supprimé Contenu ajouté
VisuelWikicode
Aucun résumé des modifications
Page blanchie
Ligne 1 :
{{Chapitre
| niveau = 14
| idfaculté = informatique
| numéro = 17
| précédent = [[../Matrices complexes fractions/]]
| suivant = [[../Matrices complexes fractions 3/]]
}}
 
== Introduction (deuxième partie) ==
 
* Un exemple complet à tester (sans sortie).
* Puis nous étudirons la fonction i_mF().
 
== Le code ==
 
=== Exemple indépendant de la librairie ===
 
* Ce fichier est complet.
* Il créé une matrice et la détruit.
* Certain include et define sont inutiles pour le code présenter, mais indispensable si on décide de rajouter certaine fonction de la librairie.
 
 
<source lang="c">
/* ------------------------------ */
/* Save as : c01.c */
/* ------------------------------ */
#include <stdio.h>
#include <stdlib.h>
#include <stddef.h>
#include <ctype.h>
#include <time.h>
#include <math.h>
/* ------------------------------ */
#define C0 0
#define C1 1
#define C2 2
#define C3 3
#define C4 4
#define C5 5
#define C6 6
#define C7 7
#define C8 8
#define C9 9
 
#define R0 0
#define R1 1
#define R2 2
#define R3 3
#define R4 4
#define R5 5
#define R6 6
#define R7 7
#define R8 8
#define R9 9
 
 
#define RC0 0
#define RC1 1
#define RC2 2
#define RC3 3
#define RC4 4
 
#define OF 0
 
#define R_SIZE 0
#define C_SIZE 1
#define C_SIZE_A 2
 
#define ERROR_E +1.E-010
 
#define FIRST 1
#define FILENAME 11
 
#ifndef PI
#define PI 3.14159265359
#endif
/* ------------------------------ */
double **i_mF(
int r,
int c
)
{
double **A;
int ar;
int ac;
int i;
 
if(r<1||c<1)
{
printf(" The size of the matrix must be positive integers.\n\n");
printf(" double **i_mR(); \n\n");
fflush(stdout);
getchar();
exit(EXIT_FAILURE);
}
 
ar = r + C1;
ac = c*C4 + C1;
 
/* Dynamically allocate an array of "ar" rows
and "ac" columns. */
 
A = malloc(ar * sizeof(*A));
if(!A)
{
printf(" I was unable to allocate the memory you requested.\n\n");
printf(" double **i_mR(); \n\n");
printf(" **A = malloc(ar * sizeof(*A));\n\n");
fflush(stdout);
getchar();
exit(EXIT_FAILURE);
}
 
A[0] = malloc(ar * ac * sizeof(**A) );
if(!A[0])
{
printf(" I was unable to allocate the memory you requested.\n\n");
printf(" double **i_mR();\n\n");
printf(" A[0] = malloc(ar * ac * sizeof(**A) );\n\n");
fflush(stdout);
getchar();
exit(EXIT_FAILURE);
}
 
for(i=1; i<ar; i++) A[i] = A[0]+i*ac;
 
/* Memorize the matrix size*/
A[R_SIZE][OF] = ar;
A[C_SIZE][OF] = ac;
 
/* I initialize the zero row and the zero column */
for(r=R2; r<A[R_SIZE][OF]; r++) A[r][C0] = 0.;
for(c=C1; c<A[C_SIZE][OF]; c++) A[R0][c] = 0.;
 
return(A);
}
/* ------------------------------------ */
void f_mF(
double **A
)
{
if(A) free(A[0]);
 
free(A);
}
/* ------------------------------------ */
int main(void)
{
double **A = i_mF(C3,R5);
 
f_mF(A);
 
printf("\n Press return to continue");
 
getchar();
 
return 0;
}
</source>
 
 
== Etudions la fonction i_mF() ==
 
* Elle retourne un double pointeur de double (double **i_mF)
* Il entre le nombre de lignes (r) et le nombre de colonnes (c).
 
<source lang="c">
/* ------------------------------ */
double **i_mF(
int r,
int c
)
{
double **A;
int ar;
int ac;
int i;
 
if(r<1||c<1)
{
printf(" The size of the matrix must be positive integers.\n\n");
printf(" double **i_mR(); \n\n");
fflush(stdout);
getchar();
exit(EXIT_FAILURE);
}
 
/* Je me réserve la colonne zéro et la ligne zéro,
pour mémoriser la taille de la matrice,
je rajoute donc une ligne et une colonne
 
On travail avec des nombres complexes avec fractions.
On multiplie le nombre de colonnes par 4 */
 
ar = r + C1;
ac = c*C4 + C1;
 
/* Dynamically allocate an array of "ar" rows
and "ac" columns. */
 
A = malloc(ar * sizeof(*A));
if(!A)
{
printf(" I was unable to allocate the memory you requested.\n\n");
printf(" double **i_mR(); \n\n");
printf(" **A = malloc(ar * sizeof(*A));\n\n");
fflush(stdout);
getchar();
exit(EXIT_FAILURE);
}
 
A[0] = malloc(ar * ac * sizeof(**A) );
if(!A[0])
{
printf(" I was unable to allocate the memory you requested.\n\n");
printf(" double **i_mR();\n\n");
printf(" A[0] = malloc(ar * ac * sizeof(**A) );\n\n");
fflush(stdout);
getchar();
exit(EXIT_FAILURE);
}
 
/* Ces deux commandes allouent un block mémoire de double.
 
Le premier malloc offre un block de (ar) éléments.
A pointe sur le premier de ces éléments.
Cela correspond a un espace pour un tableau A[ar]. (ar nombres de lignes, ac nombre de colonne)
 
Le deuxième malloc offre un block de (ar*ac) élément pour les éléments du tableau.
A[0] le premier élément du tableau pointe aussi sur A.
 
A[0] pointe sur A.
A[1] pointe sur la deuxième ligne.
A[2] pointe sur la troisième ligne.
...
 
C'est ce que fait la boucle for ci-dessous.
On incrémente chaque A[i] de (i*colonnes) à partir de l'adresse de départ.
*/
 
for(i=1; i<ar; i++) A[i] = A[0]+i*ac;
 
/* On copie la taille de la matrice dans la matrice. */
A[R_SIZE][OF] = ar;
A[C_SIZE][OF] = ac;
 
/* On met zéro dans la ligne zéro et dans la colonne zéro. */
for(r=R2; r<A[R_SIZE][OF]; r++) A[r][C0] = 0.;
for(c=C1; c<A[C_SIZE][OF]; c++) A[R0][c] = 0.;
 
return(A);
}
</source>
 
Important :
 
* Vous n'est pas obliger de comprendre ce code pour utiliser les matrices.
* Dans la librairie je mets à zéro tous les éléments de la matrice avec la fonction m_0_mF(A);
 
 
{{Bas de page
| idfaculté = informatique
| précédent = [[../Matrices complexes fractions/]]
| suivant = [[../Matrices complexes fractions 3/]]
}}
Récupérée de « https://fr.wikiversity.org/wiki/C_pointeurs/Matrices_complexes_fractions_2 »