code en c ne marche pas

[invite75c2964e]

Bonsoir a tous,

j'ai un problème avec mon code en c quand je le compile il m'affiche erreure de segmentation(core dumped) et quand j'utilise la commande gdb sous ubuntu il m'affiche

Program received signal SIGSEGV, Segmentation fault.
0x0000555555554fda in Rectangles_Gauche ()

je ne sais pas ou est l'erreur dans ma fonction est ce que qq1 peut m'aider, voila mon code

biblio55.h

#ifndef BIBLIO_H_INCLUDED
#define BIBLIO_H_INCLUDED

typedef struct
{
       double debut;
       double fin;
}structIntervalle ;

typedef struct
{
       int nombre;
       structIntervalle *tabIntervalle;
}structSubdivision;

typedef struct
{
       int taille;
       double* tabZeta;
       double* tabOmega;
}structQuadrature;

typedef struct
{
       structQuadrature Quadrature_Echantillonnage;
       structSubdivision Subdivision_Echantillonnage;
       double** matriceFonctionEchantillonnee;
}structEchantillonnage_fonction;


void Calcul_Subdivision(double a,double b,structSubdivision * Sub);
void Lire_Quadrature(structQuadrature *Quadrature);
double calcul_fonction(double x);
void Rectangles_Gauche(structQuadrature *Quadra ,structSubdivision *sub);
void Rectangles_Droite(structQuadrature *Quadra ,structSubdivision *sub);
void Rectangles_Droite(structQuadrature *Quadra ,structSubdivision *sub);
void Methode_trapezes(structQuadrature *Quadra ,structSubdivision *sub);
void Echnatillonne(structEchantillonnage_fonction *Echantillonne_fonction,structSubdivision *sub,structQuadrature *Quadra);
double CalculIntegrale(structEchantillonnage_fonction *Echantillonnage_fonction);
void AffichageGunplot(structEchantillonnage_fonction Echantillonne_Fonction);
void sauvgarder_fichier(char * nomfichier,structQuadrature *Quadra );
void affichage(structSubdivision *Sub);

#endif // BIBLIO_H_INCLUDED

biblio55.c

#include <stdio.h>
#include <stdlib.h>
#include <math.h>
#include "biblio55.h"


void Calcul_Subdivision(double a,double b,structSubdivision * Sub)
{
    double pas ;
    int i;
    Sub->tabIntervalle=(structIntervalle*)malloc((Sub->nombre)*sizeof(structIntervalle));

    pas= (b-a)/(Sub->nombre);  // *(Sub.nombre) <=> Sub->nombre

   Sub->tabIntervalle[0].debut=a;

   for(i=0;i<Sub->nombre;i++)
   {
       Sub->tabIntervalle[i].fin=(Sub->tabIntervalle[i].debut)+ pas ;
       Sub->tabIntervalle[i+1].debut=Sub->tabIntervalle[i].fin;



   }
}

void Lire_Quadrature(structQuadrature *Quadrature)
{
	
	int i=0;
        FILE *fichier= NULL;
	fichier=fopen("quadrature.txt","w");
	if(fichier!=NULL)
	{
	    fscanf(fichier," %d",&Quadrature->taille);
	    printf("%d",Quadrature->taille);
	    Quadrature->tabZeta=(double*)malloc((Quadrature->taille)* sizeof(double));
         Quadrature->tabOmega=(double*)malloc((Quadrature->taille)*sizeof(double));
	   for(i=0;i<Quadrature->taille;i++)
	   {
                                        fscanf(fichier," %lf \t %lf",&Quadrature->tabZeta[i],&Quadrature->tabOmega[i]);

      }

      
	}
fclose(fichier);
}

double calcul_fonction(double x)
{
       double resultat;
       resultat = x;
       return resultat;

}
void Rectangles_Gauche(structQuadrature *Quadra ,structSubdivision *sub)
{
    int i;


    for(i=0;i<sub->nombre;i++)
            {
              Quadra->tabOmega[i] = (sub->tabIntervalle[i].fin) - (sub->tabIntervalle[i].debut);
              Quadra->tabZeta[i] = calcul_fonction(sub->tabIntervalle[i].debut);
                    }

}
void Rectangles_Droite(structQuadrature *Quadra ,structSubdivision *sub)
{
    int i;


    for(i=0;i<sub->nombre;i++)
            {
              Quadra->tabOmega[i] = (sub->tabIntervalle[i].fin) - (sub->tabIntervalle[i].debut);
              Quadra->tabZeta[i] = calcul_fonction(sub->tabIntervalle[i].fin);
                    }

}

void Methode_milieu(structQuadrature *Quadra ,structSubdivision *sub)
{
     int i;


        for(i=0;i<sub->nombre;i++)
                {
                  Quadra->tabOmega[i] = (sub->tabIntervalle[i].fin) - (sub->tabIntervalle[i].debut);
                  Quadra->tabZeta[i] = calcul_fonction((sub->tabIntervalle[i].debut+sub->tabIntervalle[i].fin)/2);
                }
}

void Methode_trapezes(structQuadrature *Quadra ,structSubdivision *sub)
{
        int i;


        for(i=0;i<sub->nombre;i++)
                {
                  Quadra->tabOmega[i] = (sub->tabIntervalle[i].fin) - (sub->tabIntervalle[i].debut);
                  Quadra->tabZeta[i] = 0.5*(calcul_fonction(sub->tabIntervalle[i].debut) + calcul_fonction(sub->tabIntervalle[i].fin));
                }
    }

void Echnatillonne(structEchantillonnage_fonction *Echantillonne_fonction,structSubdivision *sub,structQuadrature *Quadra)
{

    int i,j;
    Echantillonne_fonction->matriceFonctionEchantillonnee=(double **)malloc((sub->nombre)*sizeof(double*));
    for(i=0;i<sub->nombre;i++){Echantillonne_fonction->matriceFonctionEchantillonnee[i]=(double*)malloc((Quadra->taille)*sizeof(double));}
    for(i=0;i<sub->nombre;i++)
    {
            for(j=0;j<Quadra->taille;j++)
            {
                Echantillonne_fonction->matriceFonctionEchantillonnee[i][j] = calcul_fonction(((1-Quadra->tabZeta[j])*(sub->tabIntervalle[i].debut))+((Quadra->tabZeta[j])*(sub->tabIntervalle[i].fin)));


            }
    }
Echantillonne_fonction->Quadrature_Echantillonnage = *Quadra;

Echantillonne_fonction->Subdivision_Echantillonnage = *sub;

}
double CalculIntegrale(structEchantillonnage_fonction Echantillonnage_fonction)
{
    double Resultat=0;
    double somme =0;
    int i,j;
    for(i=0;i<Echantillonnage_fonction.Subdivision_Echantillonnage.nombre;i++)
    {
        for(j=0;j<Echantillonnage_fonction.Quadrature_Echantillonnage.taille;j++)
        {
            somme  = somme  +((Echantillonnage_fonction.Quadrature_Echantillonnage.tabOmega[j]) * (Echantillonnage_fonction.matriceFonctionEchantillonnee[i][j]));
        }
        Resultat = Resultat + (somme * ((Echantillonnage_fonction.Subdivision_Echantillonnage.tabIntervalle[i].fin)-(Echantillonnage_fonction.Subdivision_Echantillonnage.tabIntervalle[i].debut)));
    }
        return Resultat;
}

void AffichageGunplot(structEchantillonnage_fonction Echantillonne_Fonction)
{
FILE *P;
FILE *T;
int i,j;
double somme ,Resultat=0;
P = fopen("courbe_ligne.dat","w");

    for(i=0;i<Echantillonne_Fonction.Subdivision_Echantillonnage.nombre;i++)
    {
        somme  = (Echantillonne_Fonction.Subdivision_Echantillonnage.tabIntervalle[i].fin)-(Echantillonne_Fonction.Subdivision_Echantillonnage.tabIntervalle[i].debut);
        for(j=0;j<Echantillonne_Fonction.Quadrature_Echantillonnage.taille;j++)
        {
            Resultat = Resultat + (Echantillonne_Fonction.Quadrature_Echantillonnage.tabOmega[j])*(Echantillonne_Fonction.matriceFonctionEchantillonnee[i][j]);
        }
        fprintf(P," %lf \n",somme*Resultat);

    }
    fclose(P);

    T = fopen("courbe_Integration_boxes.dat","w");
    for(i=0;i<Echantillonne_Fonction.Subdivision_Echantillonnage.nombre;i++)
    {
        somme  = (Echantillonne_Fonction.Subdivision_Echantillonnage.tabIntervalle[i].fin)-(Echantillonne_Fonction.Subdivision_Echantillonnage.tabIntervalle[i].debut);
        for(j=0;j<Echantillonne_Fonction.Quadrature_Echantillonnage.taille;j++)
        {
            Resultat = Resultat + (Echantillonne_Fonction.Quadrature_Echantillonnage.tabOmega[j])*(Echantillonne_Fonction.matriceFonctionEchantillonnee[i][j]);
        }
        fprintf(T," %lf \n",somme*Resultat);

    }
    fclose(T);
}


void sauvgarder_fichier(char * nomfichier,structQuadrature *Quadra )
{
	FILE *p;
	int i;
	p=fopen(nomfichier,"w");
	fprintf(p,"%d \n\n",Quadra->taille);
	for(i=0;i<Quadra->taille;i++)
	{
	   fprintf(p,"  %lf \t %lf\n",Quadra->tabZeta[i],Quadra->tabOmega[i]);
	}
	fclose(p);

}
void affichage(structSubdivision *Sub)
{
    int i;
     for(i=0;i<Sub->nombre;i++)
	{
	   printf("  %lf \t %lf\n\n",Sub->tabIntervalle[i].debut,Sub->tabIntervalle[i].fin);
	}

}

main55.c

#include <stdio.h>
#include <stdlib.h>
#include "biblio55.h"

int main(void)
{
   // *************************************** Declaration ************************
  int n,i,j;
  double a,b,Int;
  structIntervalle I;
  structSubdivision Sub;
  structEchantillonnage_fonction Echantillonne_Fonction;

  // ********************************************************************************

  structQuadrature Quadrature;
 printf("saisir la valeur de n\n");
  scanf("%d",&Sub.nombre);
  printf("saisir la valeur de a\n");
  scanf("%lf",&a);
   printf("saisir la valeur de b\n");
  scanf("%lf",&b);

  Calcul_Subdivision(a,b,&Sub);
  affichage(&Sub);
  Lire_Quadrature(&Quadrature);



  printf("%d",Quadrature.taille);
   for(i=0;i<Quadrature.taille;i++)
	   {
                                        printf(" %lf \t %lf \n",Quadrature.tabZeta[i],Quadrature.tabOmega[i]);
                                        }

  Rectangles_Gauche(&Quadrature,&Sub);
  sauvgarder_fichier("Rectangle_gauche.txt",&Quadrature);
  Rectangles_Droite(&Quadrature,&Sub);
  sauvgarder_fichier("Rectangle_droite.txt",&Quadrature);

  Methode_milieu(&Quadrature,&Sub);
  sauvgarder_fichier("methode_milieu.txt",&Quadrature);

  Methode_trapezes(&Quadrature,&Sub);
  sauvgarder_fichier("methode_trapezes.txt",&Quadrature);

  for(i=0;i<Quadrature.taille;i++)
	   {
                                        printf(" %lf \t %lf \n",Quadrature.tabZeta[i],Quadrature.tabOmega[i]);
                                        }

  affichage(&Sub);


Echnatillonne(&Echantillonne_Fonction,&Sub,&Quadrature);
printf(" \n\n ");
printf(" \n\n ");
  for(i=0;i<Sub.nombre;i++)
    {
            for(j=0;j<Quadrature.taille;j++)
            {
                                        printf(" %lf \t ",Echantillonne_Fonction.matriceFonctionEchantillonnee[i][j]);
                                        }
            printf(" \n\n ");
    }
Int = CalculIntegrale(Echantillonne_Fonction);
printf(" \n\n %lf",Int);
AffichageGunplot(Echantillonne_Fonction);
//********************************* liberation des memoires allouer *****************************
  free(Sub.tabIntervalle);
  free(Quadrature.tabZeta);
  free(Quadrature.tabOmega);
  free(Echantillonne_Fonction.matriceFonctionEchantillonnee);


  
  return 0;
}

Cordialement
-----

[albanxiii]

Bonjour,

je ne sais pas ou est l'erreur dans ma fonction est ce que qq1 peut m'aider, voila mon code

Avec un debugger et en exécutant pas à pas, cela devrait être facile de voir si tous les objets que vous manipulez sont bien définis (les choses du genre pointeur == NULL ou les débordements de tableaux sont assez facile à voir).

[Ikhar84]

Avec un debugger et un idée de ce qu'est une "segmentation fault", et son lien avec les pointeurs...
Mais le demandeur ne revient jamais sur ses fils après sa demande, si j'en crois son historique.

[invite936c567e]

Bonjour

quand je le compile il m'affiche erreure de segmentation(core dumped)

En principe, quand on génère une erreur de segmentation et un dump du core au moment de la compilation, le problème ne se situe pas au niveau du code compilé mais de l'exécution des programmes de la chaîne de compilation.

[A voir en vidéo sur Futura]

[Jack]

Mais le demandeur ne revient jamais sur ses fils après sa demande, si j'en crois son historique.

En effet, et c'est pour cela que je ne réponds plus.

[albanxiii]

Me suis donc fait avoir comme un lapin de 6 semaines