Discussion :

[newjavauser]

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 :

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

[joel.drigo]

Salut,

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

Code :

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

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

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

Code :

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

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 :

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

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

et pour le remplir

Code :

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

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

[newjavauser]

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 :

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

[joel.drigo]

Déjà :

Code :

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

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 !

Code :

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

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

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 :

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

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 :

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

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 :

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

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 :

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

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

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 :

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

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 :

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

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 :

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

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 :

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
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 :

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

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 :

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

[newjavauser]

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 :

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
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 :

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

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

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

Code :

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

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)

[joel.drigo]

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 :

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

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

bonjour,

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

Code :

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

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.

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.

[newjavauser]

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 :

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

[joel.drigo]

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 :

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

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 :

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

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 :

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

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.