Vous êtes sur la page 1sur 11

Biblmath

# include <stdio.h>
# include <stdlib.h>
// ----------------------Dfinition de la fonction d'allocation d'un vecteur
float* allouerVecteur(unsigned int nbre)
{
float *ptr;
ptr = (float *)malloc(nbre* sizeof(float));
if (ptr==NULL)
{
printf("\n Erreur d'allocation mmoire \n");
exit(1);
}
return ptr;
}
//---------------La saisie des donnes du tableau -----------------------void saisirVecteur(float *Vect, unsigned int nbre)
{
unsigned int i;
for(i=0;i<nbre;i++)
{
printf("Vect[%d]= ",i);
scanf("%f",&Vect[i]);
}
}
//-----------------Affichage des donnes du tableau--------void afficherVecteur(float *Vect, unsigned int nbre)
{
unsigned int i;
for(i=0;i<nbre;i++)
{
printf("V[%d]= %f\t",i, Vect[i]);
}
printf("\n");
}
//--------------------Liberation de la mmoire------------void libererVecteur(float *Vect)
{
free(Vect);
}
//------------------Allocation dynamique d'une matrice-----------float** allouerMatrice(unsigned int nl,unsigned int nc)
{
float **A;
unsigned int i;
// allocation des lignes de la matrice
A = (float **)malloc(nl * sizeof(float*));
if (A==NULL)
{

printf("\n Erreur d'allocation dynamique de la mmoire \n");


exit(1);
}
// Allocation des colonnes de la matrice
for (i = 0;i<nl;i++)
{
A[i] = (float *)malloc(nc * sizeof(float));
if (A[i]==NULL)
{
printf("\n Erreur d'allocation dynamique de la mmoire \n");
exit(1);
}
}
return A;
}
//----------------------------Saisie des donnes de la matrice------------------void saisirMatrice(float **Mat,unsigned int nl,unsigned int nc)
{
unsigned int i,j;

for(i=0;i<nl;i++)
for(j=0;j<nc;j++)
{
printf("A[%d][%d] = ",i,j);
scanf("%f",&Mat[i][j]);
}

}
//-----------------------Affichage des donnes de la matrice -----------------void afficherMatrice(float **Mat,unsigned int nl,unsigned int nc)
{
unsigned int i,j;
for(i=0;i<nl;i++)
{
for(j=0;j<nc;j++)
printf("\t%f ",Mat[i][j]);
printf("\n");
}
printf("\n");
}
//----------------------Libration de la moire rserve pour la matrice
void libererMatrice(float **Mat,unsigned int nl)
{
unsigned int i;
for(i=0;i<nl;i++)
free(Mat[i]);
free (Mat);
}

//---------------------Produit Vecteur avec une matrice------------------void produitVecteurMatrice(float *Vres, float *Vect, float **Mat, unsigned int nl, unsigned int
nc)
{
unsigned int i,j;
for(i=0;i<nl;i++)
{
Vres[i]=0;
for(j=0;j<nc;j++)
Vres[i] += Vect[i]*Mat[i][j];
}

}
//---------------------Produit une matrice avec Vecteur ------------------void produitMatriceVecteur(float *Vres, float **Mat, float *Vect, unsigned int nl, unsigned int
nc)
{
unsigned int i,j;
for(i=0;i<nl;i++)
{
Vres[i]=0;
for(j=0;j<nc;j++)
Vres[i] +=Mat[i][j]* Vect[j];
}
}
//---------------------Produit une matrice avec Matrice A(n,m)*B(m,p)= C(n,p)------------------void produitMatriceMatrice(float **C, float **A, float **B, unsigned int m, unsigned int
n,unsigned int p)
{
unsigned int i,j,k;
for(i=0;i<n;i++)
for(j=0;j<p;j++)
{
C[i][j] =0;
for(k=0;k<m;k++)
C[i][j] += A[i][k]*B[k][j];
}
}
//---------------------------Produit scalaire ------------------float produitScalaire(float *V1, float *V2, unsigned int n)
{

float S;
unsigned int i;
S=0;
for(i=0;i<n;i++)
S += V1[i]*V2[i];
return S;
}
//---------------------------Produit scalaire ------------------void produitVectoriel(float *Vres,float *V1, float *V2, unsigned int n)
{
unsigned int i;
for(i=0;i<n;i++)
Vres[i] = V1[i]*V2[i];
}
// -----------------Mthode de gauss direct -------------------------------void Gauss(float *X, float **A,float *B,unsigned int nl)
{
int i,j,k;
float s;
//------------------------Triangularisation de la matrice--------------for(k=0;k<nl;k++)
{
for(i=k+1;i<nl;i++)
{
for(j=k+1;j<nl;j++)
A[i][j] -= (A[i][k]*A[k][j])/A[k][k] ;
B[i] -= (A[i][k]*B[k])/A[k][k];
A[i][k]=0;
}
}
//-----------------------Calcul de X --------------X[nl-1] = B[nl-1]/A[nl-1][nl-1];
// attention la dclaration ed i en unsigned int !!!!!!!!!!!!!!!!!!!!!!!!!
for(i=nl-2;i>=0;i--)
{
s = 0;
for(j=i+1;j<nl;j++)
s+=A[i][j]*X[j];
X[i] = (B[i] - s) /A[i][i] ;
}
}
void decompositionlu( float **A, float **L, float **U, unsigned int n)
{
float s;
unsigned int i,k, j;
U[0][0]= A[0][0];
for(j=1; j<n; j++)
{
U[0][j]=A[0][j];
L[j][0]/=A[j][0]/A[0][0];
}

for(i=1;i<n-1;i++)
{
s=0;
for(k=0;k<i-1;k++)
{
s+=L[i][k]*U[k][i];
}
U[i][i]=A[i][i]-s;
for(j=i+1;j<n;j++)
{
s=0;
for(k=0;k<i-1;k++)
{
s +=L[i][k]*U[k][j];
}
U[i][j]=A[i][j]-s;
s=0;
for(k=0;k<i-1;k++)
{
s +=L[j][k]*U[k][i];
}
L[j][i]=(A[j][i]-s)/U[i][j];
}
}
s=0;
for(k=0;k<n-1;k++)
{
s+=L[n-1][k]*U[k][n-1];
}
U[n-1][n-1]=A[n-1][n-1]-s;
}

GAUSS
#include<stdio.h>
#include<alloc.h>
#include<stdlib.h>
float*allouerVecteur(unsigned int nbre)
{
float*ptr;
ptr=(float*)malloc(nbre*sizeof(float));
if(ptr==NULL)
{
printf("erreur d'allocation memoire\n");
exit(1);
}
return(ptr);
}
void saisirVecteur(float*Vect,unsigned int nbre)
{unsigned int i;
for(i=0; i<nbre; i++)
{printf("Vect[%d] =",i);
scanf("%f",&Vect[i]);

}
}
void afficherVecteur(float*Vect,unsigned int nbre)
{unsigned int i;
for(i=0; i<nbre; i++)
{printf("Vect[%d] =%f\n", i, Vect[i]);
}
}
void libererVecteur(float*Vect)
{free(Vect);
}

float** allouerMatrice(unsigened int n, unsigend int m)


float**A;
unsigned int i,j;
printf("donner le nbre de lignes m=");
scanf("%d",&m);
printf("donner le nbre de colonnes n=");
scanf("%d",&n);
A=(float**)malloc(n*sizeof(float));
if(A==NULL)
{
printf("erreur d'allocation dynamique de la mmoire \n");
exit(1);
void saisirMatrice(float**A,intn,unsigned int m)
for(i=0;i<m;i=i++)
{ A[i]=(float*)malloc(n*sizeof(float));
if(A[i]==NULL)
{printf("erreur d'allocation dynamique de la memoire \n");
exit(1);
}
}
void afficherMatrice(float**A,unsigned intn,unsigned int m)
for(i=0;i<n;i++)
{
for(j=0;j<n;j++)
{
printf("A[%d][%d]=",i,j);
scanf("%f",&A[i][j];
}
printf("\n");
}
void libereMatrice(flaot**A,unsigned int n)
for(i=0;i<m;i++)
{
for(j=0;j<n;j++)
{printf("A[%d][%d]=%f\t=",i,j,A[i][j];
}
printf("\n");
}
for(i=0;i<n;i++)
{
free(A[i]);
}
free(A);
}

//remplissage de A et de B//
for(i=0;i<nl;i++)
{
for(j=0;j<nc;j++)
{
fscanf("%f",&A[i][j]);
printf("\nA[%d][%d] = %f",i,j,A[i][j]) ;
}
fscanf("%f",&B[i]);
printf("\nB[%d] = %f",i,B[i]) ;
}
for(k=0;k<nl;k++)
{
for(i=k+1;i<nl;i++)
{
for(j=k+1;j<nc;j++)
{
A[i][j]=A[i][j]-(A[i][k]*A[k][j])/A[k][k];
printf("\n%f\t",A[i][j]) ;
}
printf("\n");
A[i][k]=0;
B[i]=B[i]-(A[i][k]*B[k])/A[k][k];
}
}
X[nl-1]=B[nl-1]/A[nl-1][nc-1];
for(i=nl-2;i>1;i--)
{
for(j=i+1;j<nl;j++ )
{
s=A[i][j]*X[j];
s++
}
X[i]=(1/A[i][j])*(B[i]-s);
}
printf("\n%f\t",X[i]) ;
}
system(''pause'');

TP2
#include<stdio.h>
#include<stdlib.h>
# include "biblmath.h"
void main (void)
{
unsigned int nl,nc;
float **A;
float *B,*X;

printf("entrer nl: ");


scanf("%d",&nl);
printf("\n");
printf("entrer nc : ");
scanf("%d",&nc);
B=allouervecteur(nl);
saisirvecteur(B,nl);
affichervecteur(B,nl);
X=allouervecteur(nl);
A=allouermatrice(nl,nc);
saisirmatrice(A,nl,nc);
affichermatrice(A,nl,nc);
gauss(A,B,X,nl);
}

TP 3
#include<stdio.h>
#include<stdlib.h>
#include"biblmath.h"

main()
{
FILE *in;
int nl,nc,i,j;
float *B,*X;
float **A, **L, **U;
printf("donner nl",nl);
scanf("%d",&nl);
printf("donner nc",nc);
scanf("%d",&nc);
A = allouerMatrice(nl,nc);
saisirMatrice(A,nl,nc);
afficherMatrice(A,nl,nc);
L = allouerMatrice(nl,nc);
U = allouerMatrice(nl,nc);
decompositionlu(A,L,U,nl);
afficherMatrice(L,nl,nc);
afficherMatrice(U,nl,nc);
in=fopen("C:\\systeme.txt","r");
if(in == NULL)
{
fprintf(stdout,"erreur de lecture \n");
exit(1);
}
fscanf(in,"%d",&nl);
fprintf(stdout, "nl= %d\n",nl);
fscanf(in,"%d",&nc);
fprintf(stdout, "nc= %d\n",nc);
A=allouerMatrice(nl,nc);
X=allouerVecteur(nl);
B=allouerVecteur(nl);

for(i=0;i<nl;i++)
{
for(j=0;j<nl;j++)
{
fscanf(in,"%f",&A[i][j]);
}
fscanf(in,"%f",&B[i]);
}
afficherMatrice(A,nl,nl);
afficherVecteur(B,nl);
}

TP 4
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
typedef struct personne
{
char nom[20];
char prenom[15];
char cin[10];
}personne;
typedef struct enregcin
{
char cin[10];
int index;
}enregcin;
void main(void)
{
FILE *in,*out;
int i,j;
int nbr,n;
personne *liste,structtemp,*T;
enregcin *V,temp;
/*in=fopen("C:\\personne.txt","r");
if(in==NULL)
{
fprintf(stdout,"erreur de lecture \n");
exit(0);
}
n=0;
while(fscanf(in,"%s %s %s",structtemp.nom,structtemp.prenom,structtemp.cin)==3)
{n++;}
//--Allouer liste
liste=(personne*)malloc(n*sizeof(personne));
//--replacer le curseur au dbut
fseek(in,0,0);
for(i=0;i<n;i++)
{
fscanf(in,"%s %s %s",liste[i].nom,liste[i].prenom,liste[i].cin);

}
fclose(in);
out=fopen("C:\\personne.bin","wb");
if(out==NULL)
{
fprintf(stdout,"erreur de lecture \n");
exit(0);
}
fwrite(liste,sizeof(personne),n,out);*/
out=fopen("C:\\personne.bin","rb");
fseek(out,0,SEEK_END);
nbr=ftell(out);
n=nbr/(sizeof(personne));
fprintf(stdout,"%d \n",n);
T=(personne*)malloc(n*sizeof(personne));
fseek(out,0,SEEK_SET);
fread(T,sizeof(personne),n,out);
V=(enregcin*)malloc(n*sizeof(enregcin));
for(i=0;i<n;i++)
{
strcpy(V[i].cin,T[i].cin);
V[i].index=i;
}
for(i=0;i<n;i++)
{for(j=0;j<n-1;j++)
{
if(strcmp(V[j].cin,V[j+1].cin)>0)
{
temp=V[j];
V[j]=V[j+1];
V[j+1]=temp;
}
}
for(i=0;i<n;i++)
{
printf("T[%d]=%s %s %s \n",i,T[V[i].index].nom,T[V[i].index].prenom,V[i].cin);
}
}
}
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
typedef struct personne
{
char nom[20];
char prenom[15];
char cin[10];
}personne;
typedef struct enregcin
{
char cin[10];
int index;

}enregcin;
void main(void)
{
FILE *in,*incin;
int n,nbr,i;
personne str1temp;
enregcin str2temp;
in=fopen("C:\\personne.bin","rb");
if(in==NULL)
{
fprintf(stdout,"erreur de lecture \n");
exit(0);
}
//--taille
fseek(in,0,SEEK_END);
nbr=ftell(in);
n=nbr/(sizeof(personne));
fprintf(stdout,"%d \n",n);
fseek(in,0,0);
incin=fopen("C:\\cin.bin","wb");
if(incin==NULL)
{
fprintf(stdout,"erreur de lecture \n");
exit(0);
}
for(i=0;i<n;i++)
{ fseek(in,i*sizeof(personne),0);
fread(&str1temp,sizeof(personne),1,in);
strcpy(str2temp.cin,str1temp.cin);
str2temp.index=i;
fwrite(&str2temp,sizeof(enregcin),1,incin);
}
fclose(in);
fclose(incin);
incin=fopen("C:\\cin.bin","rb");
for(i=0;i<n;i++)
{ fseek(incin,i*sizeof(enregcin),0);
fread(&str2temp,sizeof(enregcin),1,incin);
fprintf(stdout,"%s ",str2temp.cin);
fprintf(stdout,"%d \n",str2temp.index);
}
}

Vous aimerez peut-être aussi