Discussion :

[Taserface]

Bonjour,
je voudrais créer un type(class) qui s'occupe de gerer des matrices à partir d'un nombre de lignes et de colonnes fourni(qui sont les deux attributs).
j'ai imaginé presque tous les scénarios que je peux pour faire le constructeur mais aucune idée.
Pouvez-vous m'apporter quelques indices. Voici un extrait

Code :

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

1
2
3
4
public class Matrice {
    private int lignes;
    private int colonnes;
}

[professeur shadoko]

Amis d'APL bonjour!
Ce qui est important c'est ce que cette matrice contient: des ints? des doubles? des objets?
Le nombre de lignes et de colonnes te servira juste à créer un tableau à deux dimensions (et pourquoi pas plus? les matrices à N dimensions c'est rigolo!)

[Taserface]

Non simplement une matrice de nombres entiers.
Et le constructeur aucune idée j'ai même rajouté un attribut de type tableau[][] ça marche pour la création et l'affichage mais pour des méthodes comme additionner deux matrices et retourner une nouvelle matrice je vois que l'idée de l'attribut tableau [][] est une mauvaise idée

[professeur shadoko]

Non simplement une matrice de nombres entiers.
Et le constructeur aucune idée j'ai même rajouté un attribut de type tableau[][] ça marche pour la création et l'affichage mais pour des méthodes comme additionner deux matrices et retourner une nouvelle matrice je vois que l'idée de l'attribut tableau [][] est une mauvaise idée

pas du tout pourquoi?
lqu'est ce qui t'empêche de définir

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
 
public classe Matrice {
  private int[][] données;
 
 Matrice addition(Matrice autre) {
  // tu crée une matrice résultat (si tout est ok)
  // tu remplis les données
  // et tu livres
 }
 // etc. etc.
 
 int[][] contenu() {
  return données.clone() ;
 ]
}

[Taserface]

@professeur shadoko en fait c'est le constructeur de l'objet qui me pose problème dès que je sais comment écrire le constructeur le reste sera un peu moins difficile. Toujours en revenant sur l'exemple de l'addition je dois savoir dès le debut si les 2 matrices sont de même taille pour effectuer l'addition si tel n'est pas le cas je ne fais pas l'addition et je dois savoir cela à travers les attributs lignes et colonnes

[thelvin]

@professeur shadoko en fait c'est le constructeur de l'objet qui me pose problème dès que je sais comment écrire le constructeur le reste sera un peu moins difficile.

Ce travail te pose problème parce que tu n'arrives pas à voir qu'il n'y a aucun travail à faire.

Une matrice, c'est un tableau de int à deux dimensions, et absolument rien de plus que ça.
Ce que tu cherches à faire, c'est un constructeur de cette matrice. C'est à dire, le constructeur d'un objet qui n'est absolument rien d'autre qu'un tableau de int à deux dimensions.

Donc, ton constructeur :
- doit prendre en paramètre un tableau de int à deux dimension. Et aucun autre paramètre.
- doit stocker ce tableau dans une variable private int[][]. Et ne rien faire d'autre. La matrice est désormais entièrement construite, il ne lui manque plus rien pour être une matrice.

Le nombre de lignes et de colonnes se déduit immédiatement de ta variable private int[][]. Il n'y a aucun besoin d'en faire des variables. Tu peux en faire des méthodes getNbLignes() et getNbColonnes() si ça te rassure.

A la rigueur, tu peux ajouter les contrôles de programmation défensive suivants :
- S'assurer que les tableaux passés dans le constructeur ont tous la même taille et que cette taille n'est pas zéro, sinon déclencher un IllegalArgumentException.
- Faire une copie du tableau avec clone() et ne stocker que cette copie en interne, pour être sûr que ce sont bien des données privées qui ne peuvent pas être modifiées.

[Taserface]

Merci @thelvin ton aide a été précieuse je m'étais compliqué la vie pour rien à la fin donc en clair la façon dont je l'avais imaginé ne marchera pas ?
En plus j'ai fait ceci mais je suis bloqué au niveau de l'addition lorsque j'initialise s à Null il me dit sort une erreur NullPointerException mais si je ne l'affecte pas null à la création il refuse de compiler

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
public class Matrice {
    private int [][] matrice;
 
    //constructeur par defaut
    public Matrice(int [][] tab){
        matrice = tab.clone();
    }
    //methode toString
 
    //methode getNbLignes
    public int getNbLignes(){
        return matrice.length;
    }
    public int getNbColonnes(){
        return matrice[0].length;
    }
 
    public void Affichage(){ 
        for(int i=0; i<this.getNbLignes(); i++){
            for(int j=0; j<this.getNbColonnes(); j++){
                System.out.println("A l'indice [" +i+ "] et [" +j+ "] on a: "+matrice[i][j]);
            }
        }
    }
    //matrice somme
    public Matrice Ajouter(Matrice autreMatrice){
        Matrice somme = null;
        int [][] t1;
        t1 = matrice.clone();
        int [][] t2;
        t2=autreMatrice.matrice.clone();
        int [][] s = null;
        //t2 = matrice.clone();
        for(int i=0;i<this.getNbLignes();i++){
            for(int j=0;j<this.getNbColonnes();j++){
                s[i][j] = t1[i][j] + t2[i][j];
 
            }
        }
        somme.matrice = s.clone();
        return somme;
    }
 
}

A noter aussi que ma variable matrice étant privé comment faire la somme sans faire

Code :

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

int [][] copie_matrice1 = this.matrice.clone();

[joel.drigo]

Salut,

Ce qui est intéressant avec la portée private, c'est qu'elle concerne les classes, pas les instances. Ainsi, la classe Matrice a accès à toutes les variables private de toutes les instances de Matrice, donc tu peux faire :

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
public class Matrice {
 
	private int[][] tab;
 
	public Matrice(int[][] tab) {
		this.tab=tab.clone();
                for(int i=0; i<tab.length; i++) {
			this.tab[i]=tab[i].clone();
		}
	}
 
         public Matrice add(Matrice autre) {
	    // ici controle si les deux sont additionnable (même taille), sinon exception...
	    int[][] op1 = tab.clone(); // un clone pour calculer la somme
            for(int i=0; i<tab.length; i++) {
			op1[i]=op1[i].clone();
		}
	    int[][] op2 = autre.tab; // le tableau à ajouter
	    for(int i=0; i<op1.length; i++) {
	    	for(int j=0; j<op1[i].length; j++) {
		    	op1[i][j]+=op2[i][j];
		    }	
	    }
	    return new Matrice(op1);
	}
 
}

Voire

Code :

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

1
2
3
4
5
6
7
8
9
10
public Matrice add(Matrice autre) {
	    // ici controle si les deux sont additionnable, sinon exception...
            Matrice somme = new Matrice(tab);
	    for(int i=0; i<somme.tab.length; i++) {
	    	for(int j=0; j<somme.tab[i].length; j++) {
	    		somme.tab[i][j]+=autre.tab[i][j];
		    }	
	    }
	    return somme;
}

PS : clone() d'un tableau n'est pas en cascade.

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
 
		 int[] t = {1,2,3};
		 int[] t2 = t.clone();
		 t2[0]=0;
		 System.out.println(Arrays.toString(t));
		 System.out.println(Arrays.toString(t2));
 
		int[][] tab = { { 1, 2, 3 }, { 4, 5, 6 } };
		 int[][] tab2 = tab.clone();
		 tab2[0][0] = 0;
		 System.out.println(Arrays.deepToString(tab));
		 System.out.println(Arrays.deepToString(tab2));

affiche :

[1, 2, 3]
[0, 2, 3]
[[0, 2, 3], [4, 5, 6]]
[[0, 2, 3], [4, 5, 6]]

(On se demandait l'autre fois pourquoi ne pas utiliser clone() pour copier des tableaux...)

[Taserface]

Merci de ta réponse entre temps j'ai aussi trouvé cette version elle n'est pas optimale mais elle vaut ce qu'elle vaut:

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
public Matrice Ajouter(Matrice autreMatrice){
        if(matrice.length != autreMatrice.matrice.length){
            throw new IllegalArgumentException("Le nombre de ligne ne correspond pas");
        }
        int [][] s = new int[this.getNbLignes()][this.getNbColonnes()];
        for(int i=0;i<this.matrice.length;i++){
            if(matrice[i].length != autreMatrice.matrice[i].length){
                throw new IllegalArgumentException(
                        "Le nombre de colonne ne correspond pas"
                );
            }
            for(int j=0;j<matrice[i].length;j++){
                s[i][j]= matrice[i][j] + autreMatrice.matrice[i][j];
            }
 
        }
        Matrice somme = new Matrice(s);
        return somme;
    }

[joel.drigo]

Oui, c'est aussi une solution, et la différence de temps d'éxécution doit être assez minime.

A noter, par ailleurs, que si tu veux encore blinder, il faut penser qu'on peut faire des trucs de vicelar comme ça :

Code :

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

1
2
3
4
5
6
7
8
int[][] tab = new int[5][];
 
tab[0] = new int[]{ 0,1,2,3,4 };
tab[1] = new int[]{ 0 };
tab[2] = new int[]{ 0,1,2 };
tab[4] = new int[0];
 
System.out.println(Arrays.deepToString(tab));

qui affiche :

[[0, 1, 2, 3, 4], [0], [0, 1, 2], null, []]

d'où nécessité, en théorie de vérifier la longueur de toutes les lignes...

[bouye]

Bah ce qui est bien avec les implémentations c'est qu'elles sont privées et donc on peut les faire varier a volonté en conservant la même interface publique. En première approche, pour débuter, il parait assez évident de coder une matrice 2D sous forme d'un tableau de tableaux (int[][]). En seconde approche c'est quand même plus rapide de coder une matrice 2D sous forme de tableau 1D (int[]) de longueur (cols x rows). Pas mal de trucs dans les API 2D de bas niveau (Raster dans Java2D, PixelWriter dans JavaFX) représentent des matrices "bitmap" 2D comme de simples tableaux a 1 dimension...

[Taserface]

Lorsque nous essayons de coder une matrice avec un tableau à une dimension le problème c'est qu'il n'y a pas de colonnes alors la formule (cols * rows) ne tient pas en ce qui concerne les api j'ai pas poussé le sujet j'apprends le java et il me faut maitriser des concepts comme les collections avant de franchier le pas.
Ceci étant dit y a t-il un moyen de créer un structure de donnée triangulaire une matrice mais lorsque i > j on n'alloue pas la mémoire or en java la gestion de la mémoire est automatique.

[joel.drigo]

Lorsque nous essayons de coder une matrice avec un tableau à une dimension le problème c'est qu'il n'y a pas de colonnes alors la formule (cols * rows) ne tient pas en ce qui concerne les api j'ai pas poussé le sujet j'apprends le java et il me faut maitriser des concepts comme les collections avant de franchier le pas.

Même s'il est vrai que dans le cadre d'un apprentissage de la programmation (pas de Java, mais en général), traiter les matrices par un tableau 2D est plus abordable que le faire par un tableau 1D, la gestion par un tableau 1D demande juste quelques bases arithmétiques :

passer de coordonnées 2D à 1D : index = y*nbcol+x
passer d'une coordonnée 1D à 2D :
x = index%nbcol
y = index/nbcol

cela impose uniquement de stocker dans un attribut le nombre de colonnes nbcol (le nombre de ligne correspondant à la taille du tableau 1D divisé par nbcol).

Ceci étant dit y a t-il un moyen de créer un structure de donnée triangulaire une matrice mais lorsque i > j on n'alloue pas la mémoire or en java la gestion de la mémoire est automatique.

Aucun rapport avec la gestion de la mémoire automatique ou pas.

Avec un tableau 2D, de base, il suffit de prendre en compte uniquement les éléments dans une ligne tel que l'indice soit inférieur à l'index de la ligne dans la matrice, (ou inférieur au nombre de ligne moins l'index selon l'ordre).
L'autre technique étant simplement d'utiliser ce que j'expose dans le post 10, ce qui permet de parcourir la matrice triangulaire avec la même boucle qu'on utiliserait pour parcourir la matrice rectangulaire. Il est juste important de pouvoir distinguer par les classes les deux types de matrice : certains traitements peuvent être commun, mais pas tous, et on ne peut pas faire toutes les opérations qu'on veut de la même façon entre matrice rectangulaire et triangulaire, tout comme entre matrice du même type.

[Taserface]

ok merci je vois tout ça et je vous fait un rétour

[bouye]

Même s'il est vrai que dans le cadre d'un apprentissage de la programmation (pas de Java, mais en général), traiter les matrices par un tableau 2D est plus abordable que le faire par un tableau 1D, la gestion par un tableau 1D demande juste quelques bases arithmétiques :

passer de coordonnées 2D à 1D : index = y*nbcol+x
passer d'une coordonnée 1D à 2D :
x = index%nbcol
y = index/nbcol

cela impose uniquement de stocker dans un attribut le nombre de colonnes nbcol (le nombre de ligne correspondant à la taille du tableau 1D divisé par nbcol).

Et outre le fait d'allouer moins d'objets (1 seul tableau au lieu de 1 + cols tableaux ou 1 + rows tableaux suivant comment on agence la matrice) ça a aussi l'avantage d'utiliser un espace mémoire contigüe. Ce n'est pas pour rien que comme je le disais c'est beaucoup utilisé en 2D. C'est aussi aisément utilisable pour des matrices a N dimensions. Après c'est évidement peu optimisé pour des cas particuliers (matrices symétriques, etc.).

[Taserface]

Bonjour,
désolé pour tout ce temps sans nouvelle. En fait @joel.drigo je ne vois pas comment le système pourrait refuser d'allouer de la mémoire pour les élements dela matrice triangulaire inferieure peut-être qu'une image sera plus parlante
voici le système que je veux avoir comme dit possible d'acceder par exemple à la case (3,3) mais pas à la case (2,3) ou (1,2)

[joel.drigo]

Bonjour,

En fait @joel.drigo je ne vois pas comment le système pourrait refuser d'allouer de la mémoire pour les élements dela matrice triangulaire inferieure

Moi non plus. Et je vois encore moins ce qui te fait penser que j'ai pu évoquer ça ?

peut-être qu'une image sera plus parlante

Moui...mais non... plus parlante à quel sujet exactement ?

voici le système que je veux avoir comme dit possible d'acceder par exemple à la case (3,3) mais pas à la case (2,3) ou (1,2)

Bah, tu as trois solutions, avec un tableau en attribut, entre autres.

• utiliser un tableau 2D "carré", et contrôler l'accès par les coordonnées (si on passe en paramètre des coordonnées non autorisées, on soulève une exception, par exemple IllegalArgumentException ou ArrayIndexOutOfBoundException)
• utiliser un tableau 1D, et contrôler l'accès par les coordonnées
• utiliser un tableau 2D "triangulaire", et laisser Java soulever une ArrayIndexOutOfBoundException, ou contrôler l'accès par les coordonnées

[Grogro]

Amis d'APL bonjour!
Ce qui est important c'est ce que cette matrice contient: des ints? des doubles? des objets?
Le nombre de lignes et de colonnes te servira juste à créer un tableau à deux dimensions (et pourquoi pas plus? les matrices à N dimensions c'est rigolo!)

C'est rigolo (moins à manier à la main), mais ça ne s'appelle plus des matrices mais des tenseurs.