Vérification de système linéaire, avec tableaux

Version imprimable

08/06/2006, 11h32
lenny_

Vérification de système linéaire, avec tableaux

Bonjour,

J'ai besoin de multiplier chaque ligne d'un tableau à deux dimensions de n lignes et n+1 colonnes par un tableau à une dimension de n éléments, et ce en vue de vérifier un systeme linéaire. Je dois placer le résultat dans un tableau à une dimension.
Je dois programmer cela en java, mais je ne sais pas du tout comment m'y prendre !
J'ai déjà ceci, mais qui ne donne rien de convenable :

(tableau du système : tab[][] et tableau de solutions : sol[])

double tmp[] = new double [tab.length];
for (i=0 ; i<1 ; i++){
for (j=0 ; j<4 ; j++){
tmp[i] = tab[i][j] * sol[i];
}
}

Quelqu'un pourrait-il m'éclairer s'il vous plait ?
Merci
08/06/2006, 11h53
progfou

On parle de matrice (pour le tableau à 2 dimensions) et de vecteur (pour le tableau à 1 dimension).
Multiplier une matrice par un vecteur, il y a, je pense, suffisament de docs sur le net, non ?
08/06/2006, 17h35
lenny_

Je me suis mal exprimé :
en fait, je dois vérifier que les solutions présentes dans le vecteur sont correctes, en retournant un true si oui, et un false si non. Je n'ai rien trouvé en java qui puisse me faire évoluer.

Voici où j'en suis actuellement, mais ça retourne des valeurs éronnées.

Code:

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
    public static void main(String[] args) {
        // TODO code application logic here
        //
        double tab[][] = new double[3][4];
        int i=0, j=0;
        double sol[] = new double [3];
        // Remplissage du tableau de systeme lineaire
        for (i=0 ; i<3 ; i++){
            for (j=0 ; j<4 ; j++){
                tab[i][j] = Lire.d("Entrez l'élément "+(i+1)+","+(j+1)+" :");
            }
        }
 
        // Remplissage du tableau de solution
        for (i=0 ; i<3 ; i++){
            sol[i] = Lire.d("Entrez l'élément "+(i+1)+" :");
        }
 
        // Affichage du tableau de systeme lineaire
        for (i=0 ; i<3 ; i++){
            System.out.printf("\n");
            for (j=0 ; j<4 ; j++){
                System.out.printf(""+tab[i][j]+" ");
            }
        }
 
        // Affichage du tableau de solution
        System.out.printf("\n\n");
        for (i=0 ; i<3 ; i++){
            System.out.printf(""+sol[i]+" ");
        }
 
        // Vérification des solutions
        // Création d'un tableau temporaire
        double tmp[] = new double [tab.length];
        for (i=0 ; i<1 ; i++){
            for (j=0 ; j<4 ; j++){
                tmp[i] = tab[i][j] * sol[i];
            }
        }
        // Affichage du tableau temporaire
        System.out.printf("\n\n");
        for (i=0 ; i<tab.length ; i++){
            System.out.printf(""+tmp[i]+" ");
        }
 
    }
 
}

09/06/2006, 09h04
progfou
C'est un forum d'algorithmie, si tu ne donnes pas le problème formel, vas directement dans le forum Java. Sinon, explique ta multiplication pour vérifier, hors contexte, c'est sympa, mais on ne peut pas deviner (en tout cas, pas moi).
En plus, :tagcode: !!
Code:

1 2 3 for (i=0 ; i<1 ; i++){ for (j=0 ; j<4 ; j++){ tmp[i] = tab[i][j] * sol[i];}}
Ca, ça ne va pas faire grand chose, tu commences à 0, tu finis à 0 pour i ? Il sert à quoi :aie:
10/06/2006, 10h13
lenny_

OK, mettons Java de coté !

En fait :
- 1 tableau à deux dimensions de n lignes, n+1 colonnes (une matrice)

==> Contient les éléments d'un système linéaire

- 1 tableau à une dimension, de dimension n

==> Contient les solutions que l'on doit vérifier

Voici mon problème expliqué un peu plus simplement :

Ce qu'il faut faire, c'est multiplier l'élément (0,0) de la matrice par l'élément 0
du vecteur, puis stocker la reponse dans un tableau à une dimension. Ensuite, multiplier l'élémen (0,1) par l'élément 1 du vecteur, et stocker la réponse dans le tableau à une dimension temporaire, mais à la case suivante. Il faut repeter cette opération sur les n premiers éléments de la ligne (pas le dernier). Il faut également répéter cette opération pour chaque ligne de la matrice.

Je ne parviens vraiment pas à programmer cela, mais je pense que une fois que j'aurai un algorithme clair, ça ne devrait plus poser problèmes.

Voila, merci
Julien
10/06/2006, 11h51
Trap D

Le meiux serait que tu écrives ton calcul avec une matrice 2 X 3 qu'on y voie un peu mieux.
11/06/2006, 10h23
lenny_

Exemple :

Matrice 2 x 3 :

2 4 3
1 3 2

Vecteur :

1 3

L'algorithme doit faire :
1*2 + 3*4 = 3
1*1 + 3*3 = 2
Si ces deux équations se vérifient, alors la fonction retourne true, sinon elle renvoit false.
Voila, et je coince toujours...

Merci,
Julien

Je suppose dans la suite que tab est un tableau bi-dimensionnel (col x line) et que sol est un tableau unidimensionnel de taille (line).

Je propose :
Code:

1 2 3 Pour j allant de 0 à line-1 <div style="margin-left:40px">Pour i allant de 0 à col-2</div><div style="margin-left:40px"><div style="margin-left:40px">res[j]=tab[i][j]*sol[j]</div></div><div style="margin-left:40px">Fin Pour</div><div style="margin-left:40px">Si res[j] == tab[col-1][j] Alors retourne VRAI Sinon retourne FAUX</div>Fin Pour
Je n'ai pas testé, donc, à vérifier :D

12/06/2006, 20h21
khayyam90

bien le bonjour,

je pense que le problème vient du fait que dans le calcul du produit matriciel, il n'y a pas de += mais un = tout court.

Déjà dans le premier post de Lenny et dans le post précédent, tmp[i] (res[j]) est allègrement écrasé lors de chaque tour de boucle suivant.

Je propose donc de faire un res[j]+= ... à la place du res[j]=
On prendra juste soin d'initialiser le tableau résultat à 0 avant de le calculer.

Merci à vous, j'ai pris en compte vos deux remarques, et j'y suis arrivé ! Je l'ai transcit en java directement. J'insère toujours ma fonction, on ne sait jamais que ça rende service à quelqu'un !!!

Code:

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
 
/////////////////////////////////////////////////////////////////////////////
//                            estSolution                                  //
/////////////////////////////////////////////////////////////////////////////
// ATTENTION : Ne prend en charge que la vérification d'un système 3 x 4
//             (système à 3 inconnues)
    static boolean estSolution(double[][] tab, double[] sol){
        // Déclaration des variables
        int i=0, j=0;
        double somme=0, somme2=0;
 
        // Remplissage du tableau de système linéaire
        for (i=0 ; i<3 ; i++){
            for (j=0 ; j<4 ; j++){
                tab[i][j] = Lire.d("Entrez l'élément "+(i+1)+","+(j+1)+" :");
            }
        }
 
        // Remplissage du tableau de solution
        for (i=0 ; i<3 ; i++){
            sol[i] = Lire.d("Entrez l'élément "+(i+1)+" :");
        }
 
        // Affichage du tableau de systeme lineaire
        for (i=0 ; i<3 ; i++){
            System.out.printf("\n");
            for (j=0 ; j<4 ; j++){
                System.out.printf(""+tab[i][j]+" ");
            }
        }
 
        // Affichage du tableau de solution
        System.out.printf("\n\n");
        for (i=0 ; i<3 ; i++){
            System.out.printf(""+sol[i]+" ");
        }
 
        // Vérification des solutions
        // Création d'un tableau temporaire
        double tmp[] = new double [tab.length];
        // Multiplication des éléments du vecteur par les éléments 
        // de la matrice :
        for (i=0 ; i<3 ; i++){
            for (j=0 ; j<3 ; j++){
                tmp[j] = tmp[j] + (tab[i][j] * sol[j]);
            }
        }
         // Affichage du tableau temporaire
        System.out.printf("\n\n");
        for (i=0 ; i<tab.length ; i++){
            System.out.printf(""+tmp[i]+" ");
        }
        // Addition des 3 nombres indépendants dans la variable somme
        for (i=0 ; i<3 ; i++){
            for (j=3 ; j<4 ; j++){
                somme = somme + tab[i][j];
            }
        }
        // Addition des 3 nombres du tableau temporaire
        for (i=0 ; i<3 ; i++){
            somme2 = somme2 + tmp[i];
        }
        // Vérification de l'égalité et impression du résultat
        System.out.printf("\n\n");
        if (somme == somme2){
            System.out.println("Solutions correctes !");
            return true;
        }
        else{
            System.out.println("Solutions incorrectes !");
            return false;
        }
 
    }

13/06/2006, 15h12
progfou

:resolu: ;)

Je ne suis pas bien sûr que la deuxième boucle soi utile :

Code:

1
2
3
4
5
6
       // Addition des 3 nombres indépendants dans la variable somme
        for (i=0 ; i<3 ; i++){
            for (j=3 ; j<4 ; j++){
                somme = somme + tab[i][j];
            }
        }

On peut écrire

Code:

1
2
3
4
       // Addition des 3 nombres indépendants dans la variable somme
        for (i=0 ; i<3 ; i++){
                 somme += tab[i][3];
        }