Discussion :

[lenny_]

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

[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 ?

[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.

[lenny_]

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

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
    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]+" ");
        }
 
    }
 
}

[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, !!

Code :

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

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

[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

[Trap D]

Le meiux serait que tu écrives ton calcul avec une matrice 2 X 3 qu'on y voie un peu mieux.

[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

[progfou]

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 :

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

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

[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.

[lenny_]

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 :

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
 
/////////////////////////////////////////////////////////////////////////////
//                            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;
        }
 
    }

[progfou]

[Trap D]

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

Code :

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

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 :

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

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