Stocker des coordonées généré aléatoirment( x y et z) dans un tableau (en java)

Version imprimable

Bonjour,
je suis débutante en java. Le but du programme que je réalise est de générer aléatoirement des objets (cylindres) dans un cube avec des conditions de non recouvrement. je cherche donc à stocker les coordonnées de ces objets dans un tableau ( 3 colonnes et cnum lignes, cnum étant le nombre de cylindres).
je cherche à stocker les valeurs hx,hy et hz du programme ci-dessous.
voici le début du programme qui génère les objets :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 int cnum = 100; // 100 cylindres sont crées int ind = 0; double hx, hy, hz = 0.0; int Lc = 177; double hc = 17.5; double dx = 500.0; double dy = 500.0; double dz = 500.0; double esp = 10.0; while (ind < cnum) { hx = Math.random()*(dx-Lc); hy = Math.random()*(dy-hc-esp); hz = Math.random()*(dz-hc-esp); if (hx > (dx-esp)) {continue; } if ((hy-hc) < esp) {continue; } if ((hz-hc) < esp) {continue; } ind++; }
Merci pour votre aide

Salut,

Il te suffit simplement de créer un tableau de cnum lignes et de trois colonnes :

Code:

double[][] data = new double[cnum][3];

Ensuite à la fin du while, juste d'avant d'incrément ind, tu affectes la ligne correspondante :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 while (ind < cnum) { hx = Math.random()*(dx-Lc); hy = Math.random()*(dy-hc-esp); hz = Math.random()*(dz-hc-esp); if (hx > (dx-esp)) {continue; } if ((hy-hc) < esp) {continue; } if ((hz-hc) < esp) {continue; } data[ind][0] = hx; data[ind][1] = hy; data[ind][2] = hz; ind++; }
Tu peux également initialiser le tableau comme ça :

Code:

double[][] data = new double[cnum][];

et pour le remplir
Code:

1 2 data[ind] = new double[]{ hx, hy, hz}; ind++;

calculer la norme des vecteurs du tableau

Bonjour,
Mercii pour votre réponse rapide! ça marche
J'ai stocker l'ensemble de mes coordonnées dans le tableau.
je souhaite maintenant calculer les normes de tous les vecteurs possibles. je m'explique par exemple pour 3 objets j'ai hx1,hy1,hz1-hx2,hy2,hz2 et hx3,hy3,hz3.
je dois calculer la norme du vecteur 1, V1= Math.sqrt(Math.pow(hx1-hx2,2)+Math.pow(hy1-hy2,2)+Math.pow(hx1-hx2,2)+Math.pow(hz1-hz2,2))
et du vecteur 2 V2= Math.sqrt(Math.pow(hx2-hx3,2)+Math.pow(hy2-hy3,2)+Math.pow(hx2-hx3,2)+Math.pow(hz2-hz3,2))
j'impose une condition sur les vecteurs V1 et V2<Lc/2 (condition de non recouvrement).
Dans matlab je sais qu'on peut utiliser la commande ifany pour résoudre le problème mais en Java?
Dans le code suivant la seule chose que j'arrive a calculer c'est la norme entre le 1er objets et les autres (1 à n), j'aimerais savoir comment peut-on calculer la norme de toutes les combinaison possibles de vecteur pour n objets (cnum=20 dans le code)
Merci
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 int cnum = 20; // 20 cylindres sont crées int ind = 0; double hx, hy, hz = 0.0; int Lc = 177; double hc = 17.5; double dx = 500.0; double dy = 500.0; double[][] data = new double[cnum][]; // création de la première coordonée double h1x = Math.random()*(dx-Lc); double h1y = Math.random()*(dy-hc-esp); double h1z = Math.random()*(dz-hc-esp); double dz = 500.0; double esp = 10.0; while (ind < cnum) { hx = Math.random()*(dx-Lc); hy = Math.random()*(dy-hc-esp); hz = Math.random()*(dz-hc-esp); double V=Math.sqrt(Math.pow(hx1-hx,2)+Math.pow(hy1-hy,2)+Math.pow(hx1-hx,2)+Math.pow(hz1-hz,2)) // cette ligne est-elle exacte ? je pense qu'elle sert à calculer la norme entre le 1 objet de coordonnée hx1,hy1 et hz1 et les autres il manque tous les autres vecteurs. if (V < Lc/2) {continue; } if (hx > (dx-esp)) {continue; } if ((hy-hc) < esp) {continue; } if ((hz-hc) < esp) {continue; } // du coup je ne sais pas si j'ai besoin de ces lignes ? data[ind][0] = hx; data[ind][1] = hy; data[ind][2] = hz; data[ind] = new double[]{ hx, hy, hz}; ind++; }

Déjà :
Code:

1 2 3 4 5 data[ind][0] = hx; data[ind][1] = hy; data[ind][2] = hz; data[ind] = new double[]{ hx, hy, hz};
Quand j'ai dit que tu pouvair faire aussi data[ind] = new double[]{ hx, hy, hz}; ça voulait dire que c'était une alternative. Les deux en même temps ça n'a aucun intérêt, à part exécuter du code qui fait deux fois la même chose et utilise plein de mémoire pour rien !

Citation:

Envoyé par newjavauser

Code:

// du coup je ne sais pas si j'ai besoin de ces lignes ?

Tu as besoin des trois premiers ou de la quatrième pour stocker les vecteurs dans le tableau...

Citation:

Envoyé par newjavauser

j'impose une condition sur les vecteurs V1 et V2<Lc/2 (condition de non recouvrement).
Dans matlab je sais qu'on peut utiliser la commande ifany pour résoudre le problème mais en Java?

Je ne connais pas matlab, donc je ne sais pas ce que signifie ifany. D'après la doc, il semble qu'il s'agit de déterminer si un tableau contient au moins une valeur non nulle. Il n'y a pas de méthode toute faite en Java pour tester cette condition, mais il suffit de l'écrire :
Code:

1 2 3 4 5 6 public boolean static any(double[] array) { for(double val : array) { if ( val!=0 ) return true; } return false; }
Mais il semble qu'on puisse également passer une fonction, ce qu'on pourrait écrire comme ça :
Code:

1 2 3 4 5 6 public boolean static any(double[] array, DoublePredicate filter) { for(double val : array) { if ( filter.test(val) ) return true; } return false; }
Et qu'on peut appeler comme ça :
Code:

1 2 if ( any(array, val-> val!=0) ) { }
pour savoir si le tableau contient au moins une valeur non null.
En fait, on peut le faire directement en Java, mais l'écriture n'est pas forcément plus simple qu'en faisant sa propre fonction :
Code:

1 2 3 if ( Arrays.stream( array ).anyMatch(val-> val!=0) ) { // le tableau contient au moins une valeur non nulle }
Citation:

Envoyé par newjavauser

Dans le code suivant la seule chose que j'arrive a calculer c'est la norme entre le 1er objets et les autres (1 à n), j'aimerais savoir comment peut-on calculer la norme de toutes les combinaison possibles de vecteur pour n objets (cnum=20 dans le code)

Déjà, tu ne peux pas le faire lors de la boucle de remplissage, puisque tu n'as pas tous les points (tu les génères au fur et à mesure de la boucle). On pourrait le faire partiellement, parce que quand on a 2 points, on peut commencer à traiter une première combinaison, puis quand on en a 3, on peut faire deux combinaison de plus, mais le plus simple est de le faire quand on a générer tous les points.

Ensuite, s'il s'agit de comparer, il suffit de refaire une boucle :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 for(int i=0; i<cnum; i++) { double[] pointi = data[i]; // on doit faire la combinaison avec les autres points, donc on fait une boucle sur tous les points, mais on ignore le point qu'on est déjà en train de traiter for(int j=0; j<cnum; j++) { if ( i==j ) continue; // on ignore le point "i" double[] pointj = data[j]; double normeij = calculNorme(pointi, pointj); } }
Pour pouvoir conserver les normes calculées, il faut les stocker. Dans un tableau par exemple. La question est de savoir pour quoi les stocker, et qu'est ce qui est le plus pratique.
De manière absolue, on peut imaginer simplement un tableau à 2 dimension :

Code:

double[][] normes = new double[cnum][cnum];

ainsi normes[5][27] serait la norme entre data[5] et data[27]

donc à la place de double normeij = calculNorme(pointi, pointj); :

Code:

normes[i][j] = calculNorme(pointi, pointj);

mais si je comprends bien, le but c'est d'exclure les points tels que leur norme avec un point exitant est inférieur à Lc/2. Donc ce tableau à 2 dimension n'est pas pratique, et ce n'est pas pratique de faire le calcul après la boucle. Il faut le faire dans la boucle, au fur et à mesure.

c'est juste le même principe que précédemment mais en considérant le nouveau point comme point courant, et calculer la norme avec tous les précédents créés :
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 while (ind < cnum) { hx = Math.random()*(dx-Lc); hy = Math.random()*(dy-hc-esp); hz = Math.random()*(dz-hc-esp); if (hx > (dx-esp)) {continue; } if ((hy-hc) < esp) {continue; } if ((hz-hc) < esp) {continue; } double[] normes = new double[ind]; // ce tableau est suffisant pour contenir les normes entre ce nouveau point et tous les précdents // on calcule maintenant toutes les normes entre ce nouveau point et les précédent : for(int j=0; j<ind; j++) { norme[j] = calculNorme( hx, hy, hz, data[j][0], data[j][1], data[j][2] ); // par exemple } // ici tu as besoin de ta condition équivalent à ça : if (V < Lc/2) {continue; } data[ind][0] = hx; data[ind][1] = hy; data[ind][2] = hz; // et maintenant }
Du coup, comme on stocke, on peut tester la condition " if (V < Lc/2)". Si je comprends bien ce que veux dire "ifany" ça donnerait ça :

Code:

if ( any( norme, val-> val<Lc/2 ) ) continue;

Maintenant, comme il en suffit de un seul qui valide la condition, on pourrait également simplement le faire au fur et à mesure du calcul des normes, comme ça pas besoin de tout calculer : dès qu'on a une condition valide, on s'arrête. Et on n'a même plus besoin de stocker les normes

On peut faire ça directement comme ça :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 while (ind < cnum) { hx = Math.random()*(dx-Lc); hy = Math.random()*(dy-hc-esp); hz = Math.random()*(dz-hc-esp); if (hx > (dx-esp)) {continue; } if ((hy-hc) < esp) {continue; } if ((hz-hc) < esp) {continue; } // on calcule les normes et on teste au fur et à mesur si elle valide la condition, if ( Arrays.stream(data) // on prend tous les points dans le tableau data .limit(ind) // mais on se limite à ceux qu'on a déjà calculés .map(point-> calculNorme(hx,hy,hz, point)) // on calcule la norme entre ces points et le point qu'on est en train de calculer .anyMatch(val-> val<LC/2) ) continue; // si l'une des normes valide la condition, on passe à la fin de la boucle sans stocker le point en cours data[ind][0] = hx; data[ind][1] = hy; data[ind][2] = hz; }

bonjour,
J'ai tenté de mettre en place les lignes de codes mais il reste des erreurs de syntaxe que je n'arrive pas à comprendre voici le code résultant (si j'ai bien compris) :
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 int cnum = 4; int ind = 0; double hx = 0.0; double hy = 0.0; double hz = 17.5; double Lc = 177.0; double hc = 17.5; double dx = 500.0; double dy = 500.0; double dz = 500.0; double esp = 10.0; double[][] data = new double[cnum][]; double[][] normes = new double[cnum][cnum]; while (ind < cnum) { hx = Math.random()*(dx-Lc); hy = Math.random()*(dy-hc-esp); hz = Math.random()*(dz-hc-esp); if (hx > (dx-esp)) {continue; } if ((hy-hc) < esp) {continue; } if ((hz-hc) < esp) {continue; } for (int j = 0; j < ind; j++) { normes[j] = calculNorme(hx, hy, hz, data[j][0], data[j][1], data[j][2]); public static boolean any(double[] array, DoublePredicate filter) { if (Arrays.stream(data).limit(ind).map(point-- > calculNorme(hx, hy, hz, point)) .anyMatch(val-- > val < Lc/2)) {continue; } }} ind++; data[ind] = new double[]{hx, hy, hz}; }
j'aurais besoin de comprendre le sens de cette phrase :

Code:

public static boolean any(double[] array, DoublePredicate filter)

et j'aimerais savoir a quoi renvoi le terme calculNorme ?

Code:

normes[j] = calculNorme(hx, hy, hz, data[j][0], data[j][1], data[j][2]);

car l'erreur sur la ligne est la suivante :
The method calculNorme(double, double, double, double, double, double) is undefined for the type modelmethod2 (modelmethod2 correspond au nom du fichier)

En Java, on ne peut pas définir de méthode à l'intérieur d'une autre méthode. Donc ce que j'ai surligné ci-dessous n'a rien à faire là.
Code:

1 2 3 4 5 6 7 8 9 10 11 /** ... **/ if ((hz-hc) < esp) {continue; } for (int j = 0; j < ind; j++) { normes[j] = calculNorme(hx, hy, hz, data[j][0], data[j][1], data[j][2]); public static boolean any(double[] array, DoublePredicate filter) { if (Arrays.stream(data).limit(ind).map(point-- > calculNorme(hx, hy, hz, point)) .anyMatch(val-- > val < Lc/2)) {continue; } }} /** ... **/ }
C'est dans le corps d'une classe qu'on défini les méthodes.

En l’occurrence, le code de la méthode que tu as définie n'a aucun sens ici. Soit tu définie une méthode que tu peux appeler à plusieurs endroits sans dupliquer le code et qui t'évite d'avoir un code principal qui fait trois kilomètres, mais qui retourne une valeur que tu exploites dans ton code principale, soit tu écris directement le code dans ton code principal, exactement comme je l'ai écrit dans mon dernier exemple dans mon dernier message (il y a juste à implémenter la méthode calculNorme, ou remplacer l'appel de calculNorme par la formule qui va bien).

Citation:

Envoyé par newjavauser

bonjour,

j'aurais besoin de comprendre le sens de cette phrase :

Code:

public static boolean any(double[] array, DoublePredicate filter)

Il s'agit de la déclaration d'une méthode, qui prend 2 arguments en paramètres (un tableau de double, et une instance de DoublePredicate) et qui retourne un booléen.

Citation:

Envoyé par newjavauser

et j'aimerais savoir a quoi renvoi le terme calculNorme ?

Au nom d'une méthode censée calculée la norme (c'était un exemple de nom, dont le sens m'a semblé assez évident). Il faut bien sûr que tu écrives cette méthode si tu veux l'invoquer. Tu peux aussi mettre le code directement sans faire de méthode. Dans mon exemple j'ai mis ça à titre générique, pour éviter d'avoir à taper la formule complète.

Je t'ai donné plusieurs alternatives, avec les explications associées.

Bonjour,
j'ai retravaillé mon programme, ne maitrisant pas les fonction dans java j'ai écrit un code sans fonction. j'ai effectué quelques modification dans mon code. il me reste encore un problème lors de la boucle for. voici le programme :

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
 
int cnum = (int) (Math.random()*10);
int cnum_max = 10;
int ind = 0;
int inb = 0;
double hx = 0.0;
double hy = 0.0;
 
//double hzm = 17.5;
double Lc = 177.0;
double marg = 10.0;
double dvex = Lc+marg;
 
double hc = 17.5;
 
double incr = 37;
//double ei = 5;
double esp = 5.0;
double hz = hc+esp;
double dx = 500.0;
double dy = 500.0;
double dz = 500.0;
int nblay = (int) ((dz-2*esp)/incr);
//int nblay = 27;
 
double[][] data = new double[cnum_max*nblay][];
while (inb < nblay) {
 
  while (ind < cnum) {
    hx = Math.random()*dx;
    hy = Math.random()*dy;
    if (hx > (dx-esp-Lc)) {continue; }
    if (hx < esp) {continue; }
    if (hy < esp+hc) {continue; }
    if (hy > (dx-esp-hc)) {continue; }
    data[ind] = new double[]{hx, hy, hz};
    for (int i = 0; i <= ind; i++) {
// je calcul la norme entre le point courant (hx,hy,hz) et tous les points stocker dans le tableau data      
double calculNorme = Math.sqrt(Math.pow(hx-data[i][0], 2)+Math.pow(hy-data[i][1], 2)+Math.pow(hz-data[i][2], 2));
// si la condition n'est pas respectée, je souhaite retourner au while précédent pour générer un autre points et non tourner en rond dans la boucle for    
  if (calculNorme < dvex && calculNorme > 0) {continue; }
    }
 
    ind++;
  }
  hz = hz+incr;
  cnum = cnum+(int) (Math.random()*10);
  inb++;
}

si la condition if dans la boucle for n'est pas respectée, je souhaite retourner au while précédent pour générer un autre points et non tourner en rond dans la boucle for. j'ai déplacé ma boucle for avant le while mais ça ne va pas non plus.
auriez vous une idée ?
merci de votre aide

Cela n'a pas de sens de dire retourner au while précédent. Le principe c'est que le while incrément un indice de point, et tu as une condition pour générer ou pas le point. Cette condition est évaluée dans le for.

Donc le principe c'est :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 while( ind<cnum ) { // évaluer une condition // tester la condition if ( condition ) { data[ind] = point... // générer le point ind++; // et passer au suivant } }
Dans le cas simple "évaluer la condtion", c'est tester quelque chose et déterminer la valeur d'un booléen. Dans ton cas, c'est faire un for, pour tester des conditions :
cas simple

Code:

boolean condition = ...une formule...

cas for : on dit par défaut que la condition est true, on boucle, dans cette boucle on teste une autre condition, et si elle est vraie, on dit que condition est false et on arrête de boucler :
Code:

1 2 3 4 5 6 7 8 9 boolean condition = true; for ( une boucle ) { if ( unecondition ) { condition=false; break; // on arrête la boucle for } }
du coup, après la boucle, le if ( condition ) sera faux, le bloc du if ne sera pas exécuté et on rebouclera le while, pour le même ind.