ArrayList<Double> Comment trouver la valeur la plus proche

Version imprimable

15/04/2024, 21h09
Pied-Moutet

ArrayList<Double> Comment trouver la valeur la plus proche
Bonsoir,

Je suis dans une impasse !!!

J'ai une :
Code:

1 2 Arraylist<Double> distance [2.54678, 3.59865, 5.85689, 6.32653, 7.13523, 8.52478, 10.46789] double interval = 1.5
Si j'ajoute l'intervalle au chiffre de l'index demandé comment peut-on trouver l'index du chiffre (supérieur ou inférieur) se rapprochant le plus de la somme ?

Merci pour l'aide que vous pourrez m'apporter
16/04/2024, 13h27
Népomucène

Peux-tu poster le code effectif en java ?
(parce que là, cela ne fonctionne pas ...)

Citation:

Envoyé par Népomucène

Peux-tu poster le code effectif en java ?
(parce que là, cela ne fonctionne pas ...)

Désolé de reprendre si tard.
En faite j'ai créé un graphique d'un profil altimetrique d'une trace GPX avec JFreeChart.
Maintenant j'aimerais pouvoir indiquer les pourcentages tous les km ou tous les 500 m.
Pour cela il faut que je retrouve la valeur la plus proche dans l'ArrayList.

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
 
import java.util.ArrayList;
 
public class ValeurProche {
 
	public Double ValeurProche() {
 
		ArrayList<Double> distance;
		Double laDistance = (double) 0;
		Double maDistance = (double) 0;
		distance = new ArrayList<Double>();
 
 
		distance.add(0.00);
		distance.add(1.23456789);
		distance.add(1.87654321);
		distance.add(2.5432678);
		distance.add(2.97865432);
		distance.add(3.5678432);
		distance.add(3.987654321);
		distance.add(4.0756432);
		distance.add(4.9786543);
 
		double interval = 1.26578905;
 
		maDistance = distance.get(0)+ interval;
 
		for (int i = 0; i< distance.size();) {
 
			if (maDistance == distance.get(i+1)) {
 
				return maDistance;
			}
 
			else
				if (maDistance > distance.get(i+1)) {
 
					laDistance = distance.get(i+2);
 
				}
// A partir de là je ne sais plus, je suis complètement perdu
// J'ai essayé les docs mais n'étant pas du tout anglophone !!!
// je voudrais récupérer la valeur la plus proche de maDistance dans la liste distance
 
}
 
public class main {
 
	public static void main(String[] args) {
 
		ValeurProche maValeur = new ValeurProche();
 
		double valeur = maValeur.ValeurProche();
		System.out.println(valeur);
 
	}
 
}

22/04/2024, 10h41
PhilippeGibault

Je pense que c'est plus un problème d'algorithmique que de Java.

Peux-tu déjà poser, sans java, avec des mots simple, le problème?

Parce que je reconnais ne même pas le comprendre ce qui est demandé.
22/04/2024, 11h14
PhilippeGibault
Je crois que j'ai enfin compris!!!!

En fait, c'est super simple à comprendre le principe, plus compliqué dans la résolution.

Avec ce qui est présenté, on peut faire très simple.
Il y a deux méthodes. Ici, le problème est présenté de façon simpliste, mais en réalité, il est plus compliqué (j'ai fait de la physique), en particulier si on va d'abord vers les X négatifs avant d'aller vers les X positifs. Pire, en 2D, c'est des intégrales curvilignes.

Dans ton cas, comme par hasard, le problème devient simple, car comme par hasard, les points sont ordonnés de manière croissante.

Mieux, on part de l'abscisse X=0.

Donc, au final, la distance à parcourir est ici:
Code:

1 2 double distanceAParcourir = distance.get(distance.size() - 1);
Je note que le nommage est vraiment horrible, ce qui explique que je n'ai pas compris le problème tout de suite, et le nommage de la Liste ne correspond en rien au nommage de ce qu'elle représente fonctionnellement.

On en déduit facilement le pourcentage:
Code:

1 2 double pourcentage = (intervalle / distanceAParcourir) * 100.0;
Là aussi, le nommage de "intervalle" ne correspond pas à la réalité du fonctionnel.
Difficile de comprendre de quoi on parle par la suite.

Évidement, le suis resté simpliste car le problème en réalité est plus complexe, surtout si on passe en 2D, voir pire en 3D:
http://hebergement.u-psud.fr/iut-ors...Curviligne.pdf

Si je passais en 1D (déplacement sur une droite), et que je me déplaçais dans les 2 sens, il faudrait que j'ai une modélisation plus fine, en introduisant par exemple une classe Point, qui permettrait d'avoir le point précédent, le suivant, ce qui permettrait de calculer sur un trajet définit la distance d'un point. En donnant un point, on déterminerait la distance que l'on a parcouru. Sachant qu'il faudrait prendre en considération le fait que l'on puisse passer 2 fois par un même point....

Effectivement, même en 1D, ce problème n'est pas facile.
22/04/2024, 18h38
Pied-Moutet

Je crois que vous n'avez pas compris

Bonsoir Philippe,

Ma ArrayList est ordonnée.

Si je veux trouver la valeur la plus proche de

0 + 1.26578905 = 1.26578905

dans ma liste cette valeur se trouve entre l'index (1) et l'index (2), et plus près de l'index(1)
la fonction devra me retourner soit la valeur de l'index(1) soit l'index lui-même.
Ainsi je peux recréer une nouvelle liste.
Si maintenant je crée une boucle pour trouver toutes les valeurs de la liste

j'aurai au 2eme tour :

1.23456789 + 1.26578905 =2,50035694

la fonction me retournera la valeur de l'index(3) ou l'index 3

au 3eme tour:

2.5432678 + 1.26578905 = 3,80905685

la fonction me retournera la valeur de l'index(5) ou l'index 5

et ainsi de suite

et le pourcentage : c'est le pourcentage de la pente dans l'intervalle mais cela je sais le faire

Valeur la plus proche resolu

Bonsoir,

J'ai trouvé la solution.
peut être pas orthodox à vous de me le dire.
le code ci dessous si cela peux rendre service:

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
75
76
77
78
79
80
81
82
 
import java.util.ArrayList;
 
public class RechercheValeur {
 
	public double RechercheValeur() {
 
		double maValeurRecherchee = 1234.56790;
		double maValeurApprochee = (double) 0;
 
		ArrayList<Double> maListe = new ArrayList<Double>();
 
		maListe.add(0.00);
		maListe.add(125.387694);
		maListe.add(234.56789);
		maListe.add(567.89432);
		maListe.add(890.76543);
		maListe.add(1098.76543);
		maListe.add(1234.56789);
		maListe.add(1567.89432);
		maListe.add(1876.54328);
		maListe.add(2123.45678);
 
		int i = 1;
 
		double d = maListe.get(0);
		while(d < maValeurRecherchee) {
 
			d = maListe.get(i);
 
			double e = maListe.get(i+1);
 
			// Conversion e et de maValeurRecherchee en  int pour permettre de faire la condition
			// Java ne permet pas à une condition de comparer 2 doubles de cette manière
 
			int ee = (int) Math.round(e);
			int recherchee = (int) Math.round(maValeurRecherchee);
 
			if(recherchee > d && recherchee < ee) {
 
				double differenceInferieur = maValeurRecherchee - d;
				double differenceSuperieur = e - maValeurRecherchee; 
 
				System.out.println(" --- " + d);
				System.out.println("differenceInferieur -- " + differenceInferieur);
				System.out.println("differenceSuperieur -- " + differenceSuperieur);
 
				if(differenceInferieur < differenceSuperieur) {
 
					maValeurApprochee = d;
				}
 
				else if(differenceInferieur > differenceSuperieur){
 
					maValeurApprochee = e;
				}
 
			}
			i++;
		}
		System.out.println("ma valeur approchee est : " + maValeurApprochee);
		return maValeurApprochee;
 
	}	
 
}
 
import java.io.IOException;
 
public class main {
 
 
	public static void main(final String[] args) throws IOException {
 
 
		RechercheValeur maValeur = new RechercheValeur();
 
		double lesValeurs = maValeur.RechercheValeur();
 
		System.out.println("la distance resultante : " + lesValeurs);
	}
}

27/04/2024, 23h37
Népomucène

Citation:

J'ai trouvé la solution.

C'est bien mais tu n'as toujours pas trouvé la balise CODE (c'est le bouton #)
29/04/2024, 19h37
Pied-Moutet

Balise #

Désolé maintenant je sais merci