Philben - Ms Access » Algorithme

VBA : Date de fin d’une période

philben — Sat, 21 Sep 2013 09:24:50 +0000

Pour faire suite au billet précédent, cette fonction retourne la date de fin de la période choisie (mois, bimestre, trimestre, quadrimestre, semestre et année).

La fonction

Public Function DateFinPeriode(ByVal DateRef As Date, ByVal Periode As Integer) As Date
Select Case Periode
Case 1, 2, 3, 4, 6, 12
DateFinPeriode = DateSerial(Year(DateRef), Int((Month(DateRef) - 1) / Periode) * Periode + Periode + 1, 0)
End Select
End Function

Exemples
Des exemples à exécuter dans la fenêtre ‘Exécution’ (Ctrl+G) de l’éditeur VBA (Alt+F11).

?DateFinPeriode(#2013/09/20#,1) 'Mois -> 30/09/2013
?DateFinPeriode(#2013/09/20#,2) 'Bimestre -> 31/10/2013
?DateFinPeriode(#2013/09/20#,3) 'Trimestre -> 30/09/2013
?DateFinPeriode(#2013/09/20#,4) 'Quadrimestre -> 31/12/2013
?DateFinPeriode(#2013/09/20#,6) 'Semestre -> 31/12/2013
?DateFinPeriode(#2013/09/20#,12) 'Annuelle -> 31/12/2013

Vérification
Résultats dans la fenêtre ‘Exécution’

Public Function TestFinPeriode()
Dim i As Integer, j As Integer, y As Integer, s As String, c As String, r As Date, d As Date
Dim v As Variant, aDerDate(0 To 5) As Date, aCpt(0 To 5) As Integer, bErr As Boolean

'vba.Array retourne toujours un tableau de base zéro (indépendance vis à vis de Option Base) contrairement à Array()
'Mais en règle générale, on utilise Array()
v = VBA.Array(1, 2, 3, 4, 6, 12)

Randomize
y = Int(3000 * Rnd) + 100

Debug.Print "Année aléatoire : " & y
Debug.Print "Mois" & vbTab & " Mensuel(1)" & vbTab & "Bimestre(2)" & vbTab & " Trimes.(3)" & vbTab & " Quadri.(4)" & vbTab & "Semestre(6)" & vbTab & " Année(12)"

'affecte une date initiale non interférente
For j = LBound(aDerDate) To UBound(aDerDate): aDerDate(j) = #5/15/2000#: Next j

For i = 1 To 12
r = DateSerial(y, i, Int(28 * Rnd) + 1) '28 maxi pour février...
s = Format(r, "mm ") & vbTab
For j = LBound(v) To UBound(v)
d = DateFinPeriode(r, v(j))
If d <> aDerDate(j) Then
c = "*"
If Month(d) <> Month(aDerDate(j)) And Year(d) = y Then aCpt(j) = aCpt(j) + 1
Else
c = " "
End If
s = s & c & d & vbTab
aDerDate(j) = d
Next j
Debug.Print s
Next i

For i = LBound(v) To UBound(v)
If aCpt(i) <> 12 \ v(i) Then
Debug.Print "Erreur détectée pour la période n°" & (i + 1)
bErr = True
End If
Next i

If Not bErr Then Debug.Print "Aucune erreur détectée..."
End Function

Philippe

VBA : Date de début d’une période

philben — Fri, 20 Sep 2013 19:11:39 +0000

Je vous présente une fonction qui retourne, en fonction de la date passée en paramètre et la période choisie (Mois, Bimestre, Trimestre, Quadrimestre, Semestre ou Année), la première date de cette période.

La fonction

Public Function DateDebutPeriode(ByVal DateRef As Date, ByVal Periode As Integer) As Date
'Philben - v1.0 - Free to use
Select Case Periode
Case 1, 2, 3, 4, 6, 12
DateDebutPeriode = DateSerial(Year(DateRef), Int((Month(DateRef) - 1) / Periode) * Periode + 1, 1)
End Select
End Function

Paramètres
Le premier paramètre est la date de référence de la période, le deuxième indique le type de période : 1 pour mensuelle, 2 pour bimestrielle, 3 pour trimestrielle, 4 pour quadrimestrielle, 6 pour semestrielle et 12 pour annuelle.

Il y a donc dans une année, 12 périodes mensuelles, 6 bimestres, 4 trimestres, 3 quadrimestres, 2 semestres.

Exemples
Des exemples à exécuter dans fenêtre ‘Exécution’ (Ctrl+G) de l’éditeur VBA (Alt+F11).

?DateDebutPeriode(#2013/09/20#,1) 'Mois -> 01/09/2013

?DateDebutPeriode(#2013/08/20#,2) 'Bimestre -> 01/07/2013
?DateDebutPeriode(#2013/09/20#,2) 'Bimestre -> 01/09/2013

?DateDebutPeriode(#2013/09/20#,3) 'Trimestre -> 01/07/2013
?DateDebutPeriode(#2013/08/20#,4) 'Quadrimestre -> 01/05/2013
?DateDebutPeriode(#2013/09/20#,6) 'Semestre -> 01/07/2013
?DateDebutPeriode(#2013/09/20#,12) 'Annuelle -> 01/01/2013

Vérification
Cette fonction teste chaque période pour chaque mois d’une année choisie aléatoirement.
Un astérisque avant une date indique un changement de période.

Public Function TestDebutPeriode()
Dim i As Integer, j As Integer, y As Integer, s As String, c As String, r As Date, d As Date
Dim v As Variant, aDerDate(0 To 5) As Date, aCpt(0 To 5) As Integer, bErr As Boolean

v = VBA.Array(1, 2, 3, 4, 6, 12)
Randomize
y = Int(3000 * Rnd) + 100

Debug.Print "Année aléatoire : " & y
Debug.Print "Mois" & vbTab & " Mensuel(1)" & vbTab & "Bimestre(2)" & vbTab & " Trimes.(3)" & vbTab & " Quadri.(4)" & vbTab & "Semestre(6)" & vbTab & " Année(12)"

For i = 1 To 12
r = DateSerial(y, i, Int(28 * Rnd) + 1) '28 maxi pour février...
s = Format(r, "mm ") & vbTab
For j = LBound(v) To UBound(v)
d = DateDebutPeriode(r, v(j))
If d <> aDerDate(j) Then
c = "*"
If Day(d) = 1 And Year(d) = y Then aCpt(j) = aCpt(j) + 1
Else
c = " "
End If
s = s & c & d & vbTab
aDerDate(j) = d
Next j
Debug.Print s
Next i

For i = LBound(v) To UBound(v)
If aCpt(i) <> 12 \ v(i) Then
Debug.Print "Erreur détectée pour la période n°" & (i + 1)
bErr = True
End If
Next i

If Not bErr Then Debug.Print "Aucune erreur détectée..."
End Function

Philippe

VBA : Exemple comparatif des indices de similarité

philben — Sat, 07 Sep 2013 17:38:26 +0000

Après avoir vu différents algorithmes de similarité dans des billets précédents, je vous propose un petit comparatif à travers un exemple qui consiste à trouver le doublon de restaurants par leur nom, adresse, téléphone et type de cusine.

Les données
Les données sont issues d’un exemple connu de recherche de doublons et sont présentées ici dans une seule colonne où nom, adresse, téléphone et type de cuisine sont fusionnés. Le fichier de données contient 224 lignes et chaque resto possède un et un seul doublon. Cet exemple reste donc plus simple qu’un cas général de recherche de doublons…
Extrait du fichier :

Katsu 1972 Hillhurst Ave. Los Feliz 213-665-1891 Japanese
Restaurant Katsu 1972 N. Hillhurst Ave. Los Angeles 213/665-1891 Asian
Les Celebrites 155 W. 58th St. New York City 212-484-5113 French (Classic)
Les Célébrités 160 Central Park S New York 212/484-5113 French

Une difficulté s’ajoute pour le dernier restaurant car les ‘é’ de Célébrités sont convertis en HTML (& eacute;)…

Le fichier source original est ici.

Principe
Le principe est donc de rechercher pour chaque ligne, le restaurant qui a la similarité la plus forte soit 49 952 mesures (224 x 223) après conversion des chaînes en majuscule.
Pour chaque restaurant, je considère que le bon doublon a été correctement trouvé s’il arrive avec le plus fort indice par rapport aux 222 autres restaurants.
J’ai comparé les 3 algorithmes Jaro-Winkler (JW), Damerau-Levenshtein (DL) et les 6 indices Cosinus/Dice/Jaccard/… (IS), en recherchant pour chacun la meilleure configuration.

Résultats
Concernant DL, pas de problème pour trouver la meilleure configuration car il suffit de passer les 2 chaînes en argument de la fonction.
Damerau-Levenshtein a permis de détecter 185 doublons sur 224 soit 82,6% de réussite.

Concernant Jaro-Winkler, on peut jouer sur la longueur du préfixe entre 0 et 4. Les résultats obtenus sont :

Longueur préfixe Doublons détectés
0 206
1 209
2 214
3 213
4 212

Dans cet exemple, la meilleure longueur de préfixe est 2 avec 214 doublons détectés soit un taux de réussite de 95,5%, la distance de Jaro seule (0) donne le moins bon résultat.

Enfin pour l’algorithme IS, le choix du paramétrage est plus complexe car on peut choisir entre 6 indices de similarités, la longueur des Grammes (0 = mot à 5), l’inversion ou non des grammes et une distance maximum de recherche des grammes communs.
Pour la distance maxi, j’ai laissé à -1 (pas de limite de distance) car elle fournit les meilleurs résultats dans cet exemple et la recherche de grammes inversés donne ici de moins bons résultats.

J’ai donc joué sur le reste des paramètres (type d’indice et longueur des grammes) et les résultats sont synthétisés ici :

Les unigrammes (1) ont les moins bon résultats, la variabilité des résultats entre les indices diminue avec la longueur des grammes, les trigrammes et Simpson ont en moyenne les meilleurs résultats.

Pourcentage de réussite des indices en fonction de la longueur des grammes :

Finalement, l’indice de Simpson avec des bigrammes donne ici le meilleur résultat : 219 doublons détectés soit 97,8% de réussite !

Le tableau suivant indique le nombre de doublons détectés par position des résultats hormis le Top 1. Par exemple, 18 nouvelles bonnes détections faites par DL dans les Top 2 des résultats et Simpson en détecte 4 soit 223 détections cumulées (Top 1 et Top 2) sur 224 !.

Après avoir vu rapidement la capacité des indices à détecter les vrais doublons, il faut vérifier leur capacité à être discriminant entre les restaurants et compter les éventuels ex aequo.
Imaginez un algo qui retourne un indice identique pour tous les restos : Ses résultats seraient parfaits mais pour chaque restaurant on aurait 223 restaurants détectés dans le Top 1 !

Via une requête, j’ai donc calculé la position absolue du vrai doublon pour chaque algorithme et chaque ligne. Des ex aequo sont présents si la position absolue est supérieure au classement.

Indice Classement Position absolue
---------------------------------------
JW 28 29
---------------------------------------
IS 1 2
---------------------------------------
DL 2 3
DL 2 4
DL 3 6
DL 4 6
DL 4 5
DL 5 9
DL 5 6
DL 6 7
DL 7 12
DL 9 11
DL 12 20
DL 17 21
DL 24 66

JW n’est affecté qu’une fois par un ex aequo et ceci pour un classement du vrai doublon en 28ème position.
IS en a obtenu un seul sur un Top 1 et DL a eu 13 fois un ou plusieurs ex aequo.

Conclusion
Dans cet exemple, l’indice de Simpson a détecté le plus de doublons dans le Top 1 (219 sur 224) et 223 dans le Top 2 des résultats.
Si vous le souhaitez, vous pouvez ajouter vos propres résultats de vos algorithmes en commentaire du billet.

Philippe

VBA : Distance de Jaro-Winkler

philben — Sat, 31 Aug 2013 03:01:16 +0000

Cet algorithme mesure la similarité entre deux chaînes de caractères pour la recherche de doublons par exemple. Tout comme les algorithmes de Damerau-Levenshtein et les indices de similarité Cosinus, Dice, Jaccard…, la distance est normalisée entre 0 et 1. Plus la similarité est forte plus la distance tend vers 1.

La fonction VBA

Public Function JaroWinkler(ByVal s1 As String, ByVal s2 As String, _
Optional ByVal LongueurPrefixe As Byte = 3, _
Optional ByVal TypeComparaison As VbCompareMethod = vbBinaryCompare) As Single
'La distance de jaro_Winkler mesure la similarité entre deux chaines de caractères (s1 et s2)
'La distance est normalisée entre 0 et 1 (1 = similarité maximale)
'si LongueurPrefixe [0,4] = 0 => Distance de Jaro
'Référence : http://fr.wikipedia.org/wiki/Distance_de_Jaro-Winkler et références
'Remarques : Préparation parfois nécessaire des chaînes : ucase(),trim(),diacritiques
' Quelques libertés prises pour le calcul de la fenêtre (dMax) / Wikipédia
'Auteur : Philben v1.0 - Free to use
Const cMaxLongueurPrefixe As Byte = 4, cCoeffPrefixe As Single = 0.1
Dim l1 As Long, l2 As Long, dMax As Long, i As Long, j As Long, k As Long
Dim jMin As Long, jMax As Long, m As Long, t As Long, p As Long, lam1 As Long
Dim c1 As String, r As Single, aUsed() As Boolean, ac2() As String, am1() As Long

l1 = Len(s1): l2 = Len(s2)
If l1 > 0 And l2 > 0 Then
ReDim aUsed(1 To l2): ReDim ac2(1 To l2)
For i = 1 To l2: ac2(i) = Mid$(s2, i, 1): Next i

If l1 >= l2 Then
'dMax (1/2 fenêtre) calculée avec la + courte chaîne et non la + longue ! (voir blog)
dMax = (l2 + 1) \ 2 - 1 'arrondi sup. de dMax (l=1 => 0, l=2 => 0, l=3 => 1)
Else
dMax = (l1 + 1) \ 2 - 1
End If
If LongueurPrefixe > cMaxLongueurPrefixe Then LongueurPrefixe = cMaxLongueurPrefixe

jMin = 1
If dMax < l2 Then jMax = dMax Else: jMax = l2
For i = 1 To l1
c1 = Mid$(s1, i, 1)

If i > dMax + 1 Then jMin = jMin + 1
If jMax < l2 Then jMax = jMax + 1
If jMin > jMax Then Exit For 'définitivement hors fenêtre => Fin

For j = jMin To jMax
If Not aUsed(j) Then
If StrComp(c1, ac2(j), TypeComparaison) = 0 Then
m = m + 1 'Match
If i = j And i <= LongueurPrefixe And p = i - 1 Then
p = p + 1 'Préfixe commun
Else
lam1 = lam1 + 1: ReDim Preserve am1(1 To lam1): am1(lam1) = i
End If
aUsed(j) = True
Exit For
End If
End If
Next j
Next i

'Compte les tranpositions
k = p + 1
For i = 1 To lam1
For j = k To l2
If aUsed(j) Then Exit For
Next j
If StrComp(Mid$(s1, am1(i), 1), ac2(j), TypeComparaison) <> 0 Then t = t + 1
k = j + 1
Next i
t = t \ 2

If m > 0 Then
r = (m / l1 + m / l2 + (m - t) / m) / 3 'Distance de Jaro
r = r + (p * cCoeffPrefixe * (1 - r)) 'Extension de Winkler
End If
End If

JaroWinkler = r
End Function

Paramètres de la fonction
‘S1′ et ‘S2′ correspondent aux deux chaînes de caractères à étudier.
‘LongueurPrefixe’ permet de choisir la longueur du préfixe commun entre les deux chaînes. Cette longueur permet de calculer l’apport de Winkler à l’algorithme de Jaro. Cette longueur est comprise entre 0 et 4 (3 par défaut). La distance de Jaro est retournée lorsque ce paramètre est égal à 0.
‘TypeComparaison’ permet de choisir le type de comparaison entre les deux chaînes : Soit une comparaison binaire (par défaut) soit une comparaison textuelle (moins restrictive car ne tient pas compte de la casse des caractères mais généralement moins performante).
Il sera souvent nécessaire de prétraiter les chaînes par UCase()/LCase() (casse uniforme des caractères), Trim() (suppression des espaces en début et fin de chaîne) et remplacer les caractères diacritiques pour ne pas ‘parasiter’ l’algorithme (voir ici).

Tests
J’ai récolté dans une publication de W. E. Winkler (voir référence plus bas) et sur le Web des exemples pour tester les résultats de mon code. La longueur du préfixe est fixée à 4.

Public Function testJW()
Dim i As Integer, r As Single, v() As Variant

v = Array("SHACKLEFORD", "SHACKELFORD", 0.982, "DUNNINGHAM", "CUNNIGHAM", 0.896, "NICHLESON", "NICHULSON", 0.956, _
"JONES", "JOHNSON", 0.832, "MASSEY", "MASSIE", 0.933, "ABROMS", "ABRAMS", 0.922, "HARDIN", "MARTINEZ", 0#, _
"ITMAN", "SMITH", 0#, "JERALDINE", "GERALDINE", 0.926, "MARHTA", "MARTHA", 0.961, "MICHELLE", "MICHAEL", 0.921, _
"JULIES", "JULIUS", 0.933, "TANYA", "TONYA", 0.88, "DWAYNE", "DUANE", 0.84, "SEAN", "SUSAN", 0.805, _
"JON", "JOHN", 0.933, "JON", "JAN", 0#, "DIXON", "DICKSONX", 0.813, "VOYAGE", "AGENDA", 0.444, _
"TRAVEL", "TRAIN", 0.9, "ABCVWXYZ", "CABVWXYZ", 0.958)

Debug.Print "Chaîne 1", "Chaîne 2", "Attendue", "Obtenue"
Debug.Print "--------", "--------", "---------", "-------"
For i = LBound(v) To UBound(v) Step 3
r = JaroWinkler(v(i), v(i + 1), 4) 'Longueur Prefixe = 4
Debug.Print v(i), v(i + 1), v(i + 2), Round(r, 3), IIf(Abs(r - v(i + 2)) > 0.001, "*** Ecart ***", "")
Next i
End Function

Résultats et commentaires

Chaîne 1 Chaîne 2 Attendue Obtenue
-------- -------- --------- -------
SHACKLEFORD SHACKELFORD 0,982 0,982
DUNNINGHAM CUNNIGHAM 0,896 0,896
NICHLESON NICHULSON 0,956 0,956
JONES JOHNSON 0,832 0,832
MASSEY MASSIE 0,933 0,933
ABROMS ABRAMS 0,922 0,922
HARDIN MARTINEZ 0 0,722 *** Ecart ***
ITMAN SMITH 0 0,622 *** Ecart ***
JERALDINE GERALDINE 0,926 0,926
MARHTA MARTHA 0,961 0,961
MICHELLE MICHAEL 0,921 0,921
JULIES JULIUS 0,933 0,933
TANYA TONYA 0,88 0,88
DWAYNE DUANE 0,84 0,84
SEAN SUSAN 0,805 0,805
JON JOHN 0,933 0,933
JON JAN 0 0,8 *** Ecart ***
DIXON DICKSONX 0,813 0,813
VOYAGE AGENDA 0,444 0,444
TRAVEL TRAIN 0,9 0,79 *** Ecart ***
ABCVWXYZ CABVWXYZ 0,958 0,958

Les distances obtenues sont parfois différentes des distances attendues (4 écarts constatés).
Concernant les couples HARDIN/MARTINEZ, ITMAN/SMITH, JON/JAN, ils sont fournis par W. E. Winkler qui devait utiliser un algo un peu différent de celui décrit dans Wikipédia (en effet, sa fonction strcomp.c est plus complexe…)

Concernant le couple TRAVEL/TRAIN et la distance attendue de 0,9, je pense qu’il s’agit d’une coquille de l’auteur car la distance de Jaro dans la même publication était seulement de 0,7.

De plus, l’applet java de ce site donne des résultats proches ou identiques aux miens.

Remarque
L’éloignement maximal (variable dMax dans mon code) devrait être calculé à l’aide de la plus grande longueur de chaîne. J’ai préféré utiliser la plus courte pour éviter des résultats ‘étonnants’ avec certaines chaînes de caractères.
Par exemple, en allongeant la seconde chaîne ‘cba’ et en utilisant la plus grande longueur des deux chaînes de caractères, on obtient :

?JaroWinkler("abc","cba") '0,556
?JaroWinkler("abc","cbau") '0,528
?JaroWinkler("abc","cbauu") '0,756
?JaroWinkler("abc","cbauuu") '0,722

La similarité diminue avec 4 caractères (0,528) puis augmente paradoxalement avec 5 caractères (‘cbauu’ donne 0,756)!
Pourquoi ?
Dans le 1er exemple, l’éloignement maximal (variable dMax dans le code) est égal à 1 et on obtient une seule concordance (lettre ‘b’) entre les 2 chaînes.
Dans le 2ème exemple, la similarité chute légèrement car la longueur de la chaîne n°2 est de 4 au lieu de 3 et celle-ci intervient en tant que dénominateur dans le calcul de la distance de Jaro. L’éloignement maximal reste égal à 1.
Dans le 3ème exemple, l’éloignement maximal est égal à 2 car la longueur de la chaîne n°2 est de 5 caractères (arrondi supérieur de 5/2 – 1 = 2). Cet éloignement permet d’obtenir 3 correspondances (‘a’, ‘b’, ‘c’) et une transposition (‘a’ et ‘c’). Ces 3 correspondances au lieu d’une seule augmentent la similarité malgré la transposition et la longueur de la chaîne n°2.

Pour éviter ce problème, une solution consiste donc à utiliser la plus petite longueur des deux chaînes :

?JaroWinkler("abc","cba") '0,556
?JaroWinkler("abc","cbau") '0,528
?JaroWinkler("abc","cbauu") '0,511
?JaroWinkler("abc","cbauuu") '0,5

Conclusion
Algorithme rapide et efficace sur des chaînes relativement courtes.

Références
Wikipédia: Distance de Jaro-Winkler
Publication de W. E. Winkler.

Philippe

Date d’un jour de la semaine courante

philben — Thu, 08 Nov 2012 18:17:01 +0000

Episode V de la saga ‘Weekday’. Cette fois-ci, on introduit la notion de semaine puisque l’on souhaite obtenir la date d’un jour quelconque de la semaine de la date de référence. Quelle est la date du dimanche de cette semaine ? La date du mardi ?

Préambule
Je vous conseille de lire le premier billet de ‘Weekday’ pour comprendre le principe des calculs.
Voir aussi le récapitulatif des fonctions.

Les matrices
On souhaite donc passer de la matrice ‘Weekday’ à la matrice ‘Jour de la semaine courante’. Si le premier jour de semaine est un lundi (qui peut être le dimanche comme aux U.S.A.), la matrice finale est :

Weekday(Date,VbDayOfWeek) Jour de la semaine (1er jour : lundi)
VbDayOfWeek VbDayOfWeek
Jour Date L M M J V S D Jour date L M M J V S D
Lundi 1 7 6 5 4 3 2 Lundi 0 1 2 3 4 5 6
Mardi 2 1 7 6 5 4 3 Mardi -1 0 1 2 3 4 5
Mercredi 3 2 1 7 6 5 4 vers Mercredi -2 -1 0 1 2 3 4
Jeudi 4 3 2 1 7 6 5 Jeudi -3 -2 -1 0 1 2 3
Vendredi 5 4 3 2 1 7 6 Vendredi -4 -3 -2 -1 0 1 2
Samedi 6 5 4 3 2 1 7 Samedi -5 -4 -3 -2 -1 0 1
Dimanche 7 6 5 4 3 2 1 Dimanche -6 -5 -4 -3 -2 -1 0

On remarque que les valeurs sont symétriquement opposées par rapport à la diagonale. Pour pouvoir gérer tous les cas quelque soit le premier jour de semaine, le plus simple est de se servir de ce premier jour de semaine comme pivot.

La fonction VBA

Public Function DateJourSemaineEnCours(ByVal DateRef As Date, ByVal Jour As VbDayOfWeek, _
Optional ByVal PremierJourDeSemaine As VbDayOfWeek = vbMonday) As Date
DateJourSemaineEnCours = DateRef + (Jour - CInt(Weekday(DateRef, PremierJourDeSemaine)) - PremierJourDeSemaine + 1)
If Jour < PremierJourDeSemaine Then DateJourSemaineEnCours = DateJourSemaineEnCours + 7
End Function

La fonction admet trois paramètres : La date de référence et le jour de semaine recherché. Le troisième paramètre est optionnel (PremierJourDeSemaine) et contient sous forme de constante le nom du 1er jour de semaine. La valeur par défaut de ce paramètre est lundi.

Tester la fonction
La fonction suivante teste les 49 x 7 possibilités des matrices et affiche les résultats dans la fenêtre ‘Exécution’ de l’éditeur VB.

Public Function TestDateJourSemaineEnCours()
Dim s As String, d As Date, dates(1 To 7) As Date
Dim i As Integer, j As Integer, k As Integer, l As Integer, NbErr As Integer, SumErr As Integer

d = Int(Now())
Debug.Print "Test DateJourSemaineEnCours()" & vbCrLf & "----------------------"
For l = 1 To 7
d = Int(Now())
While Weekday(d) <> l: d = d + 1: Wend
For k = 0 To 6: dates(Weekday(d + k)) = d + k: Next k

Debug.Print "* Semaine du " & Format(d, "dddd dd/mm/yyyy") & " au " & Format(d + 6, "dddd dd/mm/yyyy")
For i = 1 To 7
NbErr = 0
s = vbTab & "-> Jour recherché : " & Format(d + i - 1, "ddd dd/mm/yyyy") & " : "

For j = 0 To 6
If DateJourSemaineEnCours(d + j, i, l) <> dates(i) Then NbErr = NbErr + 1
Next j
Debug.Print s & IIf(NbErr > 0, NbErr, " Aucune") & " erreur(s)"
SumErr = SumErr + NbErr
Next
Next l
Debug.Print "***" & IIf(SumErr > 0, SumErr, " Aucune") & " erreur(s) commise(s) ***"
End Function

Exemples
A coller dans la fenêtre ‘Exécution’ du VBE.

'Date du dimanche pour la date donnée et pour une semaine commençant le lundi
?DateJourSemaineEnCours(#2012/11/8#,vbSunday) '11/11/2012
'Date du lundi pour la date donnée et pour une semaine commençant le lundi
?DateJourSemaineEnCours(#2012/11/8#,vbMonday) '05/11/2012
'Date du dimanche pour la date donnée et pour une semaine commençant le dimanche
?DateJourSemaineEnCours(#2012/11/8#,vbSunday,vbSunday) '04/11/2012

@+ pour la suite des épisodes ‘Weekday’.

Philippe

Date du jour-même ou précédent

philben — Fri, 02 Nov 2012 11:53:31 +0000

Episode IV de la saga ‘Weekday’. On souhaite obtenir cette fois-ci, la date d’un jour de semaine qui précède ou NON la date de référence.

Préambule
Je vous conseille de lire le premier billet de ‘Weekday’ pour comprendre le principe des calculs.
Voir aussi le récapitulatif des fonctions.

Les matrices
On souhaite donc passer de la matrice ‘Weekday’ à la matrice ‘Jour courant ou précédent’

Weekday(Date,VbDayOfWeek) Jour courant ou précédent
VbDayOfWeek VbDayOfWeek
Jour Date L M M J V S D Jour date L M M J V S D
Lundi 1 7 6 5 4 3 2 Lundi 0 -6 -5 -4 -3 -2 -1
Mardi 2 1 7 6 5 4 3 Mardi -1 0 -6 -5 -4 -3 -2
Mercredi 3 2 1 7 6 5 4 vers Mercredi -2 -1 0 -6 -5 -4 -3
Jeudi 4 3 2 1 7 6 5 Jeudi -3 -2 -1 0 -6 -5 -4
Vendredi 5 4 3 2 1 7 6 Vendredi -4 -3 -2 -1 0 -6 -5
Samedi 6 5 4 3 2 1 7 Samedi -5 -4 -3 -2 -1 0 -6
Dimanche 7 6 5 4 3 2 1 Dimanche -6 -5 -4 -3 -2 -1 0

On remarque que toutes les valeurs de la matrice finale sont les opposés + 1 de la matrice ‘Weekday’. Par exemple, si la date de référence est un lundi, le mardi sera 1 – 7 = -6, le dimanche sera 1 – 2 = -1 et pour les valeurs de la diagonale, la formule est 1 – 1 = 0.

La fonction VBA

Public Function DateJourMemeOuPrecedent(ByVal DateRef As Date, ByVal Jour As VbDayOfWeek) As Date
DateJourMemeOuPrecedent = DateRef - CInt(Weekday(DateRef, Jour)) + 1
End Function

Tester la fonction
La fonction suivante teste les 49 possibilités de la matrice et affiche les résultats dans la fenêtre ‘Exécution’ de l’éditeur VB.

Public Function TestDateJourMemeOuPrecedent()
Dim d As Date, r As Date, dates(1 To 7) As Date
Dim i As Integer, j As Integer, k As Integer, NbErr As Integer
Dim s As String, Jours As Variant

d = Int(Now())
While Weekday(d) <> vbMonday: d = d + 1: Wend
Jours = VBA.Array("Dimanche", "Lundi ", "Mardi ", "Mercredi", "Jeudi ", "Vendredi", "Samedi ")

Debug.Print "Test DateJourMêmeOuPrecedent()" & vbCrLf & "----------------------"
For i = 1 To 7
s = vbNullString
Debug.Print "* Date de référence : " & Format(d, "dddd dd/mm/yyyy")
Debug.Print vbTab & "Jour cherché" & vbTab & vbTab & "Jour trouvé" & vbTab & vbTab & "Conforme ?" & vbCrLf & _
vbTab & "----------------------------------------------"
For k = 1 To 6: dates(Weekday(d - k)) = d - k: Next k
dates(Weekday(d)) = d

For j = 1 To 7
r = DateJourMemeOuPrecedent(d, j)
s = s & vbTab & Jours(j - 1) & vbTab & vbTab & Format(r, "ddd dd/mm/yyyy") & vbTab & vbTab
If r <> dates(j) Then
NbErr = NbErr + 1
s = s & "Erreur !" & vbCrLf
Else
s = s & "Ok" & vbCrLf
End If
Next j
Debug.Print s
d = d + 1
Next i
Debug.Print "***" & IIf(NbErr > 0, NbErr, " Aucune") & " erreur(s) commise(s) ***"
End Function

@+ pour la suite des épisodes ‘Weekday’.

Philippe

Date du jour de semaine précédent

philben — Fri, 26 Oct 2012 03:40:25 +0000

Episode III de la saga ‘Weekday’. On souhaite obtenir cette fois-ci, la date d’un jour de semaine qui précède la date de référence.

Préambule
Je vous conseille de lire le premier billet de ‘Weekday’ pour comprendre le principe des calculs.
Voir aussi le récapitulatif des fonctions.

Les matrices
On souhaite donc passer de la matrice ‘Weekday’ à la matrice ‘Jour précédent’

Weekday(Date,VbDayOfWeek) Jour précédent
VbDayOfWeek VbDayOfWeek
Jour Date L M M J V S D Jour date L M M J V S D
Lundi 1 7 6 5 4 3 2 Lundi -7 -6 -5 -4 -3 -2 -1
Mardi 2 1 7 6 5 4 3 Mardi -1 -7 -6 -5 -4 -3 -2
Mercredi 3 2 1 7 6 5 4 vers Mercredi -2 -1 -7 -6 -5 -4 -3
Jeudi 4 3 2 1 7 6 5 Jeudi -3 -2 -1 -7 -6 -5 -4
Vendredi 5 4 3 2 1 7 6 Vendredi -4 -3 -2 -1 -7 -6 -5
Samedi 6 5 4 3 2 1 7 Samedi -5 -4 -3 -2 -1 -7 -6
Dimanche 7 6 5 4 3 2 1 Dimanche -6 -5 -4 -3 -2 -1 -7

On remarque que les lignes de la matrice ‘Jour précédent’ correspondent aux lignes de la matrice ‘Weekday’ avec un décalage de 1 jour.
Par exemple, la ligne du lundi de ‘Jour précédent’ est identique en valeur absolue à celle du dimanche de ‘Weekday’, celle du mardi est liée à lundi, etc…

La solution
Il faut donc retrancher un jour à la date de référence avant de la passer à la fonction Weekday() : Weekday(DateRef - 1, Jour)

La fonction VBA

Public Function DateJourPrecedent(ByVal DateRef As Date, ByVal Jour As VbDayOfWeek) As Date
DateJourPrecedent = DateRef - Weekday(DateRef - 1, Jour)
End Function

Tester la fonction
La fonction suivante teste les 49 possibilités de la matrice et affiche les résultats dans la fenêtre ‘Exécution’ de l’éditeur VB.

Public Function TestDateJourPrecedent()
Dim d As Date, r As Date, dates(1 To 7) As Date
Dim i As Integer, j As Integer, k As Integer, NbErr As Integer
Dim s As String, Jours As Variant

d = Int(Now())
While Weekday(d) <> vbMonday: d = d + 1: Wend
Jours = VBA.Array("Dimanche", "Lundi ", "Mardi ", "Mercredi", "Jeudi ", "Vendredi", "Samedi ")

Debug.Print "Test DateJourPrecedent()" & vbCrLf & "----------------------"
For i = 1 To 7
s = vbNullString
Debug.Print "* Date de référence : " & Format(d, "dddd dd/mm/yyyy")
Debug.Print vbTab & "Jour cherché" & vbTab & vbTab & "Jour trouvé" & vbTab & vbTab & "Conforme ?" & vbCrLf & _
vbTab & "----------------------------------------------"
For k = 1 To 7: dates(Weekday(d - k)) = d - k: Next k

For j = 1 To 7
r = DateJourPrecedent(d, j)
s = s & vbTab & Jours(j - 1) & vbTab & vbTab & Format(r, "ddd dd/mm/yyyy") & vbTab & vbTab
If r <> dates(j) Then
NbErr = NbErr + 1
s = s & "Erreur !" & vbCrLf
Else
s = s & "Ok" & vbCrLf
End If
Next j
Debug.Print s
d = d + 1
Next i
Debug.Print "***" & IIf(NbErr > 0, NbErr, " Aucune") & " erreur(s) commise(s) ***"
End Function

@+ pour la suite des épisodes ‘Weekday’.

Philippe

Date du jour-même ou suivant

philben — Wed, 17 Oct 2012 20:19:34 +0000

Episode II de la saga ‘Weekday’. On souhaite obtenir cette fois-ci, soit la date de référence si elle correspond au jour de semaine recherché soit la date suivante. La date retournée est donc ici supérieure ou égale à la date de référence contrairement au premier billet de ‘Weekday’ où la date retournée était strictement supérieure à la date de référence.

Préambule
Je vous conseille de lire le premier billet ‘Weekday’ pour comprendre le principe des calculs.
Voir aussi le récapitulatif des fonctions.

Les matrices
On souhaite donc passer de la matrice ‘Weekday’ à la matrice ‘Jour courant ou suivant’

Weekday(Date,VbDayOfWeek) Jour courant ou suivant
VbDayOfWeek VbDayOfWeek
Jour Date L M M J V S D Jour date L M M J V S D
Lundi 1 7 6 5 4 3 2 Lundi 0 1 2 3 4 5 6
Mardi 2 1 7 6 5 4 3 Mardi 6 0 1 2 3 4 5
Mercredi 3 2 1 7 6 5 4 vers Mercredi 5 6 0 1 2 3 4
Jeudi 4 3 2 1 7 6 5 Jeudi 4 5 6 0 1 2 3
Vendredi 5 4 3 2 1 7 6 Vendredi 3 4 5 6 0 1 2
Samedi 6 5 4 3 2 1 7 Samedi 2 3 4 5 6 0 1
Dimanche 7 6 5 4 3 2 1 Dimanche 1 2 3 4 5 6 0

On remarque que toutes les valeurs de la diagonale de la matrice finale sont égales à zéro alors qu’elles étaient égales à 7 dans le premier billet. La matrice pivot reste donc la même sauf que le résultat de cette diagonale est égal à 7 (8 – 1) au lieu de zéro…
Il faut donc réaliser une opération supplémentaire qui transformera la valeur 7 en zéro.

La solution
Il existe plusieurs solutions mais j’ai choisi d’utiliser l’opérateur modulo (MOD). Cet opérateur retourne le reste de la division de deux nombres. Exemples : 5 MOD 4 = 1 et 3 MOD 4 = 3.
Dans notre cas, (8 – 1) MOD 7 = 0 ce qui correspond bien à la valeur attendue dans la diagonale sans modifier les autres valeurs puisqu’elles sont toutes inférieures à 7.

La fonction VBA

Public Function DateJourMemeOuSuivant(ByVal DateRef As Date, ByVal Jour As VbDayOfWeek) As Date
DateJourMemeOuSuivant = DateRef + ((8 - CInt(Weekday(DateRef, Jour))) Mod 7)
End Function

Tester la fonction
La fonction suivante teste les 49 possibilités de la matrice et affiche les résultats dans la fenêtre ‘Exécution’ de l’éditeur VB.

Public Function TestDateJourMemeOuSuivant()
Dim d As Date, r As Date, dates(1 To 7) As Date
Dim i As Integer, j As Integer, k As Integer, NbErr As Integer
Dim s As String, Jours As Variant

d = Int(Now())
While Weekday(d) <> vbMonday: d = d + 1: Wend
Jours = VBA.Array("Dimanche", "Lundi ", "Mardi ", "Mercredi", "Jeudi ", "Vendredi", "Samedi ")

Debug.Print "Test DateJourMemeOuSuivant()" & vbCrLf & "----------------------------"
For i = 1 To 7
s = vbNullString
Debug.Print "* Date de référence : " & Format(d, "dddd dd/mm/yyyy")
Debug.Print vbTab & "Jour cherché" & vbTab & vbTab & "Jour trouvé" & vbTab & vbTab & "Conforme ?" & vbCrLf & _
vbTab & "----------------------------------------------"
For k = 1 To 6: dates(Weekday(d + k)) = d + k: Next k
dates(Weekday(d)) = d

For j = 1 To 7
r = DateJourMemeOuSuivant(d, j)
s = s & vbTab & Jours(j - 1) & vbTab & vbTab & Format(r, "ddd dd/mm/yyyy") & vbTab & vbTab
If r <> dates(j) Then
NbErr = NbErr + 1
s = s & "Erreur !" & vbCrLf
Else
s = s & "Ok" & vbCrLf
End If
Next j
Debug.Print s
d = d + 1
Next i
Debug.Print "***" & IIf(NbErr > 0, NbErr, " Aucune") & " erreur(s) commise(s) ***"
End Function

@+ pour la suite des épisodes ‘Weekday’.

Philippe

Calculer la date de Pâques

philben — Sun, 14 Oct 2012 08:31:50 +0000

Je vous propose une fonction VBA qui détermine la date du Dimanche de Pâques pour toute année (de 325 à 9999) dont découlent les jours fériés mobiles en France.
Elle complète également la fonction fournie dans la FAQ Access qui n’est valide qu’entre 1982 et 2048.

La fonction VBA
L’objectif est la performance et non l’aspect didactique des calculs…

Public Function Paques(ByVal an As Integer) As Date
'Calcul de la date du dimanche de Pâques à partir de l'année 325
'Performance par million d'appel :
' - Entre 325 et 1582 et entre 1900 et 2099 => 1/4 de seconde
' - Année supérieure à 1582 hors 1900 - 2099 => 1/2 de seconde
'Philben - v1.0 - Free to use
Dim a As Integer, b As Integer, c As Integer, d As Integer, e As Integer, f As Integer
If an < 10000 Then 'Limite supérieure des dates sous Access (31 décembre 9999)
Select Case an
Case 1900 To 2099 'Algorithme de Carter
a = (204 - 11 * (an Mod 19)) Mod 30 + 22
Paques = DateSerial(an, 3, a + 6 + (a > 49) - (an + an \ 4 + a + (a > 49)) Mod 7)
Case Is > 1582 'Proposé en 1876 dans la revue Nature (dérivé de l'algorithme de Delambre)
a = an Mod 19: b = an \ 100: c = an Mod 100
d = (19 * a + b - b \ 4 - (b - (b + 8) \ 25 + 1) \ 3 + 15) Mod 30
e = (32 + 2 * (b Mod 4) + 2 * (c \ 4) - d - c Mod 4) Mod 7
f = d + e - 7 * ((a + 11 * d + 22 * e) \ 451) + 114
Paques = DateSerial(an, f \ 31, f Mod 31 + 1)
Case Is > 324 'Algorithme de Oudin pour les dates juliennes < 1583 décrit par Claus Tondering
a = (19 * (an Mod 19) + 15) Mod 30
Paques = DateSerial(an, 3, 28 + a - (an + an \ 4 + a) Mod 7)
End Select
End If
End Function

Pourquoi trois périodes de temps ?
La date de Pâques (Easter en anglais) a été fixée au concile de Nicée en 325 ce qui explique l’année de départ de la fonction. De l’an 325 à 1582, on utilise l’algorithme de Oudin adapté au calendrier julien puis l’algorithme de la revue Nature pour le calendrier grégorien actuel (réforme du 15 octobre 1582). Enfin, l’algorithme de Carter est utilisé pour la période actuelle (1900 à 2099) compte tenu de sa rapidité de calcul.

Performance
Pour un million d’appels de la fonction :

Compter 1/4 de seconde pour la période entre 325 et 1582 et entre 1900 et 2099;
Compter 1/2 seconde pour les années supérieures à 1582 (hors 1900 à 2099).

Vérification des résultats
La méthode retenue est de comparer les résultats avec d’autres algorithmes.
Concernant le calendrier julien j’ai utilisé l’algorithme de Delambre versus Oudin :

Public Function TestPaquesJulien()
Dim a As Integer, b As Integer, c As Integer, d As Integer, e As Integer, an As Integer, bErr As Boolean
Dim d1 As Date, d2 As Date

Debug.Print "Test calendrier julien..."
For an = 325 To 1582

'Delambre
a = an Mod 19
b = an Mod 7
c = an Mod 4
d = (19 * a + 15) Mod 30
e = (2 * c + 4 * b - d + 34) Mod 7
d1 = DateSerial(an, 3, 22 + d + e)

d2 = Paques(an)
If d1 <> d2 Then
Debug.Print vbTab & "-> Date différente pour l'année " & an & " entre Delambre (" & d1 & ") et la fonction Paques (" & d2 & ")"
bErr = True
Exit For
End If
Next an
Debug.Print "Fin - " & IIf(bErr, "Ecart constaté !", "Pas d'écart constaté")

End Function

Pour le calendrier grégorien, j’ai utilisé l’algorithme de Oudin versus nos deux algorithmes (Carter et Nature) :

Public Function TestPaquesGregorien()
Dim c As Integer, g As Integer, k As Integer, i As Integer, j As Integer, l As Integer, m As Integer
Dim an As Integer, bErr As Boolean, d1 As Date, d2 As Date

Debug.Print "Test calendrier grégorien..."
For an = 1583 To 9999

'Oudin - http://www.smart.net/~mmontes/oudin.html
g = an Mod 19
c = an \ 100
k = (c - 17) \ 25
i = (c - c \ 4 - (c - k) \ 3 + 19 * g + 15) Mod 30
i = i - (i \ 28) * (1 - (i \ 28) * (29 \ (i + 1)) * ((21 - g) \ 11))
j = (an + an \ 4 + i + 2 - c + c \ 4) Mod 7
l = i - j
m = 3 + (l + 40) \ 44
d1 = DateSerial(an, m, l + 28 - 31 * (m \ 4))

d2 = Paques(an)
If d1 <> d2 Then
Debug.Print vbTab & "-> Date différente pour l'année " & an & " entre Oudin (" & d1 & ") et la fonction Paques (" & d2 & ")"
bErr = True
Exit For
End If
Next an
Debug.Print "Fin - " & IIf(bErr, "Ecart constaté !", "Pas d'écart constaté")

End Function

On peut également vérifier que la date de Pâques calculée soit comprise entre le 22 mars et le 25 avril et qu’elle soit bien un dimanche. Comme la fonction VBA Weekday() n’est adaptée qu’au calendrier grégorien, il faut donc ajouter un algorithme qui détermine les jours de semaine du comput julien (années < 1583 dans notre cas).
La fonction de test et JourSemaineJulien() :

Public Function TestPaques()
'Quelque soit l'année, vérifier que la date de Pâques est bien :
' - comprise entre le 22 mars et 25 avril
' - un dimanche
Const cMinAn As Integer = 325
Const cMaxAn As Integer = 9999
Const cMaxMoisJour As Integer = 425
Const cMinMoisJour As Integer = 322
Const cMinCalendrierGregorien As Integer = 1583
Dim p As Date, i As Integer, md As Integer, j As Integer

For i = cMinAn To cMaxAn
p = Paques(i)
md = Month(p) * 100 + Day(p)
If i < cMinCalendrierGregorien Then j = JourSemaineJulien(p) Else j = Weekday(p)
If j <> vbSunday Then
Debug.Print "Erreur ! Une date de Pâques n'est pas un dimanche : ", p
Exit For
End If
If md < cMinMoisJour Then
Debug.Print "Erreur ! Une date de Pâques est inférieure au 22 mars : ", p
Exit For
ElseIf md > cMaxMoisJour Then
Debug.Print "Erreur ! Une date de Pâques est supérieure au 25 avril : ", p
Exit For
End If
Next i
If i > cMaxAn Then Debug.Print "Aucune erreur détectée entre " & cMinAn & " et " & cMaxAn
End Function

Public Function JourSemaineJulien(ByVal LaDate As Date) As VbDayOfWeek
'Formule de Zeller - http://www.vendredi13.us/ZellerMethode.html
Dim a As Integer, m As Integer, s As Integer, y As Integer, z As Integer

y = Year(LaDate): m = Month(LaDate)
If m < 3 Then m = 12 + m: y = y - 1
s = y \ 100: a = y - s * 100

'Comput julien : de 100 (1ère date Access : 1/1/100) à 1582
z = (Day(LaDate) + Int(2.6 * (m + 1)) + a + a \ 4 + 5 - s) Mod 7

'comput grégorien : > 1582
'z = (Day(LaDate) + Int(2.6 * (m + 1)) + a + a \ 4 + s \ 4 - 2 * s) Mod 7
'If z < 0 Then z = 7 + (z Mod 7) 'inutile entre 100 et 1582

If z = 0 Then z = vbSaturday 'alignement sur VbDayOfWeek

JourSemaineJulien = z
End Function

J'ai également comparé les résultats d'un échantillon d'années avec ceux de ce site web très intéressant sans constater d’erreur.

Exemples
A copier dans la fenêtre ‘Exécution’ de VBE puis mettre le focus sur la ligne à exécuter et taper sur ‘Entrée’.

'Dimanche de Pâques pour l'année en cours
?Paques(Year(Date())) 'pour 2012 -> 08/04/2012
'An 1000 - Calendrier julien
?Paques(1000) '31/03/1000
?Paques(3000) '13/04/3000

Remarque
Bien que l’année grégorienne (365.2425 jours en moyenne) soit plus courte que l’année julienne (365.25 jours en moyenne) , elle est encore trop longue par rapport à l’année tropique (365.2422 jours en moyenne). De plus, le raccourcissement de l’année tropique et l’allongement du jour au fil des millénaires nécessiteront des ajustements qui rendront caduques les algorithmes utilisés…

Références
Cette présentation en français au format PDF de P. Rocher (Observatoire de Paris) fait un point détaillé sur les dates de Pâques, les méthodes de calcul et présente l’algorithme de la revue Nature (page 15).
Le site vendredi13.us dont le design pique un peu les yeux (!) est d’une richesse exceptionnelle sur le vendredi 13 et les dates de Pâques, le tout en français ! Il expose très clairement de nombreuses méthodes de calcul du jour de Pâques dont Gauss, Delambre, Oudin, Reints, Zeller…

Philippe

Calcul direct de la date de Pâques en SQL

philben — Sat, 13 Oct 2012 19:44:07 +0000

La requête paramétrée suivante calcule directement la date du Dimanche de Pâques entre 1900 et 2099 sans faire intervenir une fonction VBA personnelle grâce à une formule dérivée de l’algorithme de Carter.
La date des 3 jours fériés mobiles français (Lundi de Pâques, Ascension et Lundi de Pentecôte) est également formulée, bien que le lundi de Pentecôte ne soit plus chômé depuis 2005 (journée de solidarité).

La requête SQL pour ACCESS

PARAMETERS Annee Short;
SELECT IIF(Annee BETWEEN 1900 AND 2099,
DateSerial(
Annee,
3,
(204 - 11 * (Annee MOD 19)) MOD 30 + 28 + (Annee MOD 19 IN (5,16)) - (Annee + Annee \ 4 + ((204 - 11 * (Annee MOD 19)) MOD 30 + 22 + (Annee MOD 19 IN (5,16)))) MOD 7
),
NULL
) AS [Dimanche de Pâques],
[Dimanche de Pâques] + 1 AS [Lundi de Pâques],
[Dimanche de Pâques] + 39 AS [Ascension],
[Dimanche de Pâques] + 50 AS [Lundi de Pentecôte]

Remarques
Si vous souhaitez extrapoler la formule à d’autres SQL, il faut savoir que sous Access :

True = -1 donc (Annee MOD 19 IN (5,16)) retourne -1 si vrai;
L’opérateur ‘\’ de Annee \ 4 retourne seulement la partie entière de la division;
Attention aussi à la priorité des opérateurs…

Il n’est pas possible non plus de copier directement la formule dans une fonction VBA car elle utilise des opérateurs spécifiques SQL (Between et In).

Exemples
Au lancement de la requête, un popup demande de saisir l’année souhaitée.

Dimanche Lundi de
de Pâques Pâques Ascension Lundi de Pentecôte
15/04/1900 16/04/1900 24/05/1900 04/06/1900
18/04/1954 19/04/1954 27/05/1954 07/06/1954
08/04/2012 09/04/2012 17/05/2012 28/05/2012
21/04/2019 22/04/2019 30/05/2019 10/06/2019
12/04/2099 13/04/2099 21/05/2099 01/06/2099

Si l’année est en dehors de la plage 1900 – 2099, NULL est renvoyé pour chaque colonne.

A noter
La formule pour le calcul des jours ouvrables de la FAQ Access n’est valable que pour la période comprise entre 1982 et 2048.

Philippe