Problème calcul de durée

Version imprimable

04/12/2008, 11h56
absolut75

Problème calcul de durée

Bonjour,

Je suis confronté à un problème qui semble tout à fait simple, mais que je n'arrive pas à résoudre, du moins simplement :cry:

Je cherche à calculer, pour un évènement pouvant durer 24 heures (mais pouvant être à cheval sur deux jours civils), le temps passé durant une certaine plage horaire (pouvant être à cheval sur 2 jours) et qui se répète tous les jours.

Par exemple :

L'événement est une connexion définie par sa date de début et sa date de fin.
La plage horaire de nuit est : 22h00 - 06h00
-> comment calculer le temps passé de nuit de la connnexion ?

piège : si la connexion dure de 05h00 jusqu'à 02h00 le lendemain, çà doit renvoyer 5 heures (1 heure au début et 4 à la fin)

Je sais à peu près utiliser les Date / Calendar; c'est plus au niveau de l'algo que je patauge ... pourtant çà parait bête. Je dois l'être un peu aussi remarquez :D

Merci de votre aide :-)
04/12/2008, 12h21
Astartee

Parlons maths...

Durée de la connexion : intervalle [A, B].
Plages de nuit : union des intervalles [C+z, D+z] où z est un entier relatif et C < D.
Je cherche l'ensemble des x appartenant à l'intersection de ces deux ensembles.

Pour tout x dans l'intersection, il existe z entier tel que :
A<x<B et C+z<x<D+z
Alors :
A<D+z et C+z<B
Donc :
A-D<z<B-C

Soit [X, Y] un intervalle.
Alors :
[A, B] intersection [X, Y] = [max(A, X), min(B, Y)]

J'en conclus que l'intersection de la connexion et des plages de nuit est l'union des [max(A, C+z), min(B, D+z)] pour z entier dans [A-D, B-C].

Donc la durée que tu cherches est la somme des (min(B, D+z) - max(A, C+z)) pour z entier dans [A-D, B-C].

Tadaaaaa :mrgreen:
Je te laisse comprendre (pas facile les maths sur un forum texte :aie:) et adapter.
04/12/2008, 12h37
Astartee

Petit ajout :

Si tes plages étaient irrégulières au lieu de se répéter tous les jours (notons les [Cn, Dn]), on aurait :

Connexion : [A, B]
Plages : union sur n des [Cn, Dn]

Intersection de la connexion et des plages :
intersection de [A, B] et de (union sur n des [Cn, Dn])
= union sur n des (intersection de [A, B] et de [Cn, Dn])
= union sur n des [max(A, Cn), min(B, Dn)]

Et donc durée commune :
somme sur n des ((min(B, Dn) - max(A, Cn)) si la différence est positive)
(si la différence est négative, l'intervalle est vide !)
EDIT : à condition que les plages [Cn, Dn] ne se chevauchent pas :?

Dans le cas de tes plages régulières, on a une infinité de plages mais on les connaît bien et donc on peut réduire le nombre d'éléments à sommer en calculant dans quel cas la différence sera négative (i.e. intervalle non vide) : c'est le calcul que j'ai effectué pour en déduire que les seuls z à prendre en compte dans le calcul sont les z dans [A/D, B/C].
04/12/2008, 13h02
absolut75

Merci pour ta réponse Astartee... j'espère qu'elle ne va pas faire fuir les autres personnes qui pourraient m'aider :D

En tous cas, belle démonstration mathématique : çà me rappelle ma jeunesse ! Ta formule :

somme sur n des ((min(B, Dn) - max(A, Cn)) si la différence est positive)
(si la différence est négative, l'intervalle est vide !)

est très bien.

Maintenant c'est au niveau de l'algo "Java" que çà me pose problème. Notament mes plages horaires qui sont plutôt du type [C + z*24h ; D + z*24h].
04/12/2008, 13h16
Astartee

Citation:

Envoyé par absolut75

Maintenant c'est au niveau de l'algo "Java" que çà me pose problème. Notament mes plages horaires qui sont plutôt du type [C + z*24h ; D + z*24h].

Arf, oui, je me suis plantée dans mon premier post sur la forme des intervalles :oops: et ensuite, dans les calculs le nez dans le guidon ! :aie:

Mais en reprenant le deuxième post, ça t'indique quand même comment procéder ;)
Pour avoir une liste d'indices finie, donc exploitable, calcule les z qui te donneront des intervalles non vides...

Je tente çà si çà interesse quelqu'un (pas encore testé mais j'y crois):

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
 
static public long calcul(Date eventDebut, Date eventFin, int plageDebut, int plageFin) {
 
		GregorianCalendar cal1 = new GregorianCalendar(); // debut plage
		GregorianCalendar cal2 = new GregorianCalendar(); // fin plage
 
		long intersection = 0;
 
		// On définit la plage horaire qui commence avant debut
		cal1.setTime(eventDebut);
		cal1.set(Calendar.HOUR_OF_DAY, plageDebut);
		cal1.set(Calendar.MINUTE, 0);
		cal1.set(Calendar.SECOND, 0);
		cal1.set(Calendar.MILLISECOND, 0);
		if (cal1.getTime().after(eventDebut)) {
			cal1.add(Calendar.DATE, -1);
		}
 
		cal2.setTime(cal1.getTime());
		cal2.set(Calendar.HOUR_OF_DAY, plageFin);
		if (cal2.getTime().before(cal1.getTime())) {
			cal2.add(Calendar.DATE, 1);
		}
 
		// Tant que la plage horaire n'est pas postérieure à fin :
		while (cal1.getTime().before(eventFin)) {
 
			intersection += Math.max(Math.min(eventFin.getTime(), cal2.getTimeInMillis()) - Math.max(eventDebut.getTime(), cal1.getTimeInMillis()), 0);
 
			// On décale la plage de 24h
			cal1.add(Calendar.DATE, 1);
			cal2.add(Calendar.DATE, 1);
 
		}
 
		return intersection;
	}

N'hésitez pas à me dire si vous trouvez plus simple ou mieux !

Merci Astartee pour ton aide :king:

04/12/2008, 13h51
dingoth

2 petites questions :

Est-ce que JodaTime ne permet pas ce genre de calculs ? Notamment la classe Duration et ses méthodes plus/minus. http://joda-time.sourceforge.net/key_duration.html

Ne créerais-tu pas en plus de tes deux calendriers deux autres calendriers que tu initialiserais respectivement à eventDebut et eventFin ? Ceci permettrait d'éviter de voir des .getTime() redondants dans ton code, notamment dans tes comparaisons ? Les méthodes after(Object) et before(Object) existent également pour la classe Calendar.
04/12/2008, 14h29
absolut75

Je ne connais pas Joda-Time et je ne peux donc pas répondre à ta première question.

Sinon merci pour le conseil, je n'avais pas vu que before et after fonctionnaient également avec des calendars.

Pour info, le code ci-dessus fonctionne. Il faut juste faire gaffe aux TimeZones ...