Discussion :

[Drébon]

Voila je viens de débuter en C++ et je cherche a faire une procédure de décomposition ALU...

Mon problème est que ma procédure ne donne que la moitié des résultats qu elle devrait donner (seulement le L et pas le U)

Bon donc j'ai écrit un truc sous le type void qui prend comme variable des matrices (déclarées en fait en tant que float [N][N])) les variables en sont A, L et U...

Au cours de la procédure tous les calculs se passent bien (j'ai rajouté des sorties intermédiaires) et donc la procédure calcule les bons L et U ici on est juste avant la dernière accolade de la procédure ALU...

Seulement lorsque j'utilise la procédure dans un programme, seule la matrice L ressort correctement, U semble perdue et donne une matrice a peu près nulle (avec des coefficient en e-40)....

En gros je ne comprend pas comment U peut passer de la bonne valeur a un truc non initialisé en l'espace d'une accolade, tandis que L se comporte normalement...

voici la structure de la procédure (je ne détails pas la source a priori les calculs se passent bien) :

Code :

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

1
2
3
4
5
6
 
        void ALU(float L[N][N], U[N][N], A[N][N])
                    {
                      calcul de L et U ....
                      affichage de L et U, les deux sont corects
                     }

Et le problème c'est que si dans un programme je fais

Code :

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

1
2
3
4
 
           ALU(L,U,A);
           afficher( L);
           afficher(U);

eh bien L est correcte, tandis que U est nulle...


Merci de votre aide.

[Strab]

Je ne vois pas de quoi cela peut venir à part une bête erreur de programmation. Il faudrait donc qu'on voie le code, au moins la fin.

[Drébon]

Bon si vous le voulez voici le code :

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
 
void ALU(float L[N][N], float U[N][N], float A[N][N], int dim)
        {
         float L1[N][N],R[N][N],U1[N][N];
         U=A;
         DispMat(U,dim,dim);
         ScalxMat(L1,0,L,dim,dim);
         ScalxMat(L,0,L,dim,dim);
         for(int i0=0;i0<dim;i0++)
            {
             L1[i0][i0]=1;
             L[i0][i0]=1;            
            }
 
         for(int j=0;j<dim-1;j++)
            {
             for(int i=j+1;i<dim;i++)
                {
                 L1[i][j]=-(U[i][j])/(U[j][j]);
                }
             cout<<"L "<<j<<endl;   
             DispMat(L1,dim,dim);   
             PMat(U1,L1,U,dim,dim,dim);
             DispMat(U1,dim,dim);
             U=U1;
             cout<<"U "<<j<<endl;
             DispMat(U,dim,dim);
             PMat(R,L1,L,dim,dim,dim);
             InvMatL(L,R,dim);   
             cout<<"res"<<endl;
             DispMat(U,dim,dim);
             DispMat(L,dim,dim);
            }
           DispMat(U,dim,dim);
         }

Comme vous pouvez le voir le dernier DispMat(U,dim,dim) est juste avant la fin de la procédure, et la je vois dans le programme de test ci dessous que U est correcte, par contre dans test quand après ALU je fais un DispMat(U,dim,dim) je tombe sur du rien du tout...

bon ça c'est pour la procédure ALU, les procédures y intervenant marchent très bien PMat produit matriciel, InvMatL inversion d'une matrice L, ScalxMat produit d'un scalaire par une matrice,afficher une matrice... ce sont toutes des procedures void qui stoquent leurs éventuels résultatd intéressantd dans leurs 1er arguments...

et ici le programme pour tester ALU :

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
 
# include <iostream>
# include <math.h>
# include "./mtdnum.h"
# define N 10
 
using namespace std;
 
int main()
    {
     int dim;
     float D[N][N],C[N][N],B[N][N],R[N][N],x;
     cout<<"dim ?"<<endl;
     cin>>dim;
     SaisieMat(D,dim,dim);
     ALU(C,B,D,dim);
     DispMat(C,dim,dim);
     DispMat(B,dim,dim);
 
    }

[JolyLoic]

Quand tu fait U=A, ou U=U1, tu modifie la valeur du pointeur U à l'intérieur de ta fonction. Le pointeur U externe à ta fonction n'a pas été modifié, et il pointe sur de la mémoire non modifiée. Du moin bon au mieux :

Solution 1 :
Remplacer chaque U=A par une double boucle sur les éléments :

Code :

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

1
2
3
4
5
6
7
8
 
for(int j=0;j<dim-1;j++)
{
    for(int i=0;i<dim;i++)
    {
        U[i][j]=A[i][j];
    } 
}

Solution 2 :
Faire une fonction AffecteMat qui fait ça

Solution 3 :
Faire une classe Matrice, définir l'opérateur = pour cette classe

[Drébon]

Ok merci beaucoup en effet c'était bien le tout premier U=A !

Mais juste une derniere question, en utilisant des pointeurs il n'y aurait pas moyen de lui dire que quand je fais U=A il faut "vraiment" faire U=A ?

[JolyLoic]

Tu peux passer à ta fonction une référence à U. Mais dans ce cas là, pourquoi ne pas utiliser simplement A dans la fonction.

[Strab]

Si en rédefinissant l'opérateur comme l'a suggéré JolyLoic

[Drébon]

ben en fait U je le construis pas a pas, et A je ne veux pas y toucher.. et dans la construction de U je dois commencer par U=A (dans l'algorythme)