Discussion :

[souleyman]

Bonjour,

Je travaille sur un projet qui permet de faire la résolution d'un système d’équations d'ordre n ; dans mon projet, j'intègre aussi GTK pour la gestion de l'interface graphique.
J'ai en retour une erreur que je n'arrive pas à résoudre. Il s'agit d'une erreur de segmentation.

J'ai isolé le problème, finalement je pense que ça se trouve dans la fonction recherche_pivot.

Merci d 'avance, voila mon programme :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
int *mat1;
int entier;
int num(int i,int   j)
{
    return  (entier*i+j);
}
/* cette fonction fait la conversion d'une matrice vers un tableau. la variable entier definit la grandeur de la matrice,si elle vaut 2 alors la matrice créee est une matrice d 'ordre 2
 
j'ai fait l'allocation dynamique dans une autre fonction qui appelle recherche_pivot voila la syntaxe 
mat1=malloc(entier*entier*sizeof(int));
*/
 
    int recherche_pivot(int k)
        {
            k=0;
            int    i=k;
            do
            {
                if(mat1[num(i,k)]==0)
                i++;
            }
            while((mat1[num(i,k)]==0)||(i!=(entier+1)));
 
            if(i==(entier+1))
            i=-1;
            return  i;
        }

[souviron34]

et où est la définition et/ou initialisation de la variable entier ??

[souleyman]

j'avais juste isolé le probleme mais voila le code au complet .
et merci pour votre reponse.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
#include<stdio.h>
#include<gtk/gtk.h>
#include<stdlib.h>
 
char *temp,*temp2;
int entier,temp3;
int mat[10][10];
int *mat1;
GtkWidget *entre[100];
 
int num(int i,int   j)
{
    return  (entier*i+j);
}
    int recherche_pivot(int k)
        {
            k=0;
            int    i=k;
            do
            {
                if(mat1[num(i,k)]==0)
                i++;
            }
            while(mat1[num(i,k)]==0);
 
            if(i==(entier+1))
            i=-1;
            return  i;
        }
 
void initialisation(GtkWidget *Widget, GtkWidget *data)
    {
        int i,j,k=0;
        mat1=NULL;
        mat1=malloc(entier*entier*sizeof(int));
        for(i=0;i<entier;i++)
            {
                    for(j=0;j<entier;j++)
                    {
                        temp2=gtk_entry_get_text(GTK_ENTRY(entre[k]));
                        temp3=atoi(temp2);
                        mat1[num(i,j)]=temp3;
                        g_print("%d\t",mat1[num(i,j)]);
                        k++;
                    }
            g_print("\n");
            }
 
            mat1=NULL;
            k=0;
            j=recherche_pivot(k);
           g_print("%d",j);
    }
 
void creation(GtkWidget *Widget, gpointer *Data)
    {
        int i,j,k=0;
        GtkWidget *fenetre,*boxv,*boxh[20];
        GtkWidget *evaluer,*fermer;
// recupere la chaine contenu dans l'entree
 
    temp = gtk_entry_get_text(GTK_ENTRY(Data));
    entier=atoi(temp);
    fenetre=gtk_window_new(GTK_WINDOW_TOPLEVEL);
    gtk_window_set_title(GTK_WINDOW(fenetre),"les entres de donnees avec les matrices");
    g_signal_connect(G_OBJECT(fenetre),"destroy",G_CALLBACK(gtk_main_quit),NULL);
 
 
    boxv=gtk_vbox_new(TRUE,0);
    gtk_container_add(GTK_CONTAINER(fenetre),boxv);
 
    for(i=0;i<entier;i++)
    {
        boxh[i]=gtk_hbox_new(FALSE,0);
        gtk_box_pack_start(GTK_BOX(boxv),boxh[i], TRUE,FALSE, 0);
 
        for(j=0;j<entier;j++)
            {
                entre[k]=gtk_entry_new();
                gtk_box_pack_start(GTK_BOX(boxh[i]),entre[k], TRUE, FALSE, 0);
                k++;
            }
    }
 
    evaluer=gtk_button_new_with_label("evaluer");
    fermer=gtk_button_new_with_label("fermer");
    gtk_box_pack_start(GTK_BOX(boxv),evaluer, TRUE, FALSE, 0);
    gtk_box_pack_start(GTK_BOX(boxv),fermer, TRUE, FALSE, 0);
    gtk_signal_connect(GTK_OBJECT(evaluer), "clicked", GTK_SIGNAL_FUNC (initialisation),(gpointer)entre);
    g_signal_connect(G_OBJECT(fermer), "clicked", gtk_main_quit, NULL);
    gtk_widget_show_all(fenetre);
    gtk_main();
}
 
 
int main(int argc,char **argv)
{
GtkWidget *pwindows,*pvbox,*label,*pbouton;
GtkWidget *pentry;
gchar *texte=NULL;
gtk_init(&argc,&argv);
pwindows=gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_window_set_default_size(GTK_WINDOW(pwindows),200,200);
gtk_window_set_title(GTK_WINDOW(pwindows),"les entres de donnees avec les matrices");
g_signal_connect(G_OBJECT(pwindows),"destroy",G_CALLBACK(gtk_main_quit),NULL);
pvbox=gtk_vbox_new(TRUE,0);
gtk_container_add(GTK_CONTAINER(pwindows),pvbox);
texte="veillez donner la taille de la matrice";
label=gtk_label_new(texte);
gtk_box_pack_start(GTK_BOX(pvbox),label,TRUE,FALSE,0);
pentry=gtk_entry_new();
gtk_box_pack_start(GTK_BOX(pvbox),pentry,TRUE,FALSE,0);
pbouton=gtk_button_new_with_label("valider");
gtk_box_pack_start(GTK_BOX(pvbox),pbouton,TRUE,FALSE,0);
 
 
gtk_signal_connect(GTK_OBJECT(pbouton), "clicked", GTK_SIGNAL_FUNC (creation), (gpointer)pentry);
gtk_signal_connect(GTK_OBJECT(pentry), "activate", GTK_SIGNAL_FUNC (creation), (gpointer)pentry);
//g_signal_connect(G_OBJECT(pbouton), "clicked", G_CALLBACK(gtk_main_quit), NULL);
gtk_widget_show_all(pwindows);
gtk_main();
return 0;
}

[Trademark]

Dans recherche_pivot, tu attends en paramètre k et puis tu écrases directement la valeur après... Il y a déjà un problème à ce niveau.

Ensuite si ta matrice mat1 est composée seulement de 0 alors ta boucle ne va simplement jamais s'arrêter et tu sortiras forcément des bornes après un certain temps.

Il faudrait aussi que tu sépares mieux la couche graphique et la logique applicative (les calculs) car c'est un bordel monstre pour s'y retrouver. (Et encore il n'y a pas beaucoup de lignes). Finalement, tu ferais mieux de proscrire les variables globales car ça ne contribue pas du tout à la lisibilité.

[anacharsis]

salut !

après avoir corrigé ta faute dans la boucle de recherche du pivot, tu vas devoir te poser la question de la résolution du système :

- ou bien tu veux une approximation de la (ou des) solution(s) en float ou en double,
- ou bien tu veux une résolution en fraction.

dans les deux cas, pour des raisons de précision (dans le premier cas) ou de taille des résultats (dans le second), on ne peut pas adopter la même implémentation de recherche_pivot :

- le plus grand possible (sauf les puissances de 2) dans le premier cas,
- le plus petit possible (dans un sens à préciser si ton niveau en maths le permet) dans le second.

dans les 2 cas on ne peut pas se contenter de pivot != 0.

A+

[souleyman]

merci pour votre aide
la fonction recherche_pivot n est pas encore tout a fait au point.pour la variable k elle represente l indice de colonne de la matrice ,et la je fait le teste pour rechercher le pivot juste a la colonne k;et si elle marche je ferait ensuite varier k;

et pour votre idee concernant l utilisattion des types double ou float ou bien les fraction ;je prefere les fraction ,mais je vais continuer mon projet avec le type int ensuite si tout marche bien ;je utiliser la resolution en fraction.

[souleyman]

bonjour j 'ai finalement reussi a resoudre le probleme ;j'ai a effacer la ligne 49 dans la fonction initialisation :
mat1=NULL;
et j ' ai un peu modifier la fonction recherche_pivot :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
int recherche_pivot(int k,int   *mat)
        {
            int    i=k;
 
            do
            {
                if(mat[num(i,k)]==0)
                i++;
            }
            while((mat[num(i,k)]==0)&&(i!=(entier+1)));
 
            if(i==(entier+1))
            i=-1;
            return  i;
        }

et merci pour votre aide;