Obtenez les heures locales de lever et de coucher du soleil en fonction de la latitude, de la longitude et de la date actuelle. Une recherche puissante sur Google m'a permis de trouver rapidement un cours Java écrit par un étranger. Les commentaires dans le code étaient clairement écrits.
Postez le code directement ici :
Copiez le code comme suit :
/************************************************ * *****************************
*
*SunriseSunset.java
*
************************************************** * *******************************
*
* Classe Java : SunriseSunset
*
*Cette classe Java fait partie d'une collection de classes développées pour le
*lecture et traitement des données océanographiques et météorologiques collectées
*depuis 1970 par bouées et stations environnementales Ceci est un ensemble de données.
*maintenu par le Centre national de données océanographiques et est public
*disponible. Ces classes Java ont été écrites pour le US Environmental.
*Laboratoire national de recherche sur l'exposition de la Protection Agency sous contrat
*N° GS-10F-0073K auprès de Neptune and Company de Los Alamos, Nouveau-Mexique.
*
*But:
*
* Cette classe Java effectue des calculs pour déterminer l'heure de
*lever et coucher du soleil en fonction de la latitude, de la longueur et de la date.
*
*Entrées :
*
* Latitude, longitude, date/heure et fuseau horaire.
*
*Sorties :
*
* Heure locale du lever et du coucher du soleil telle que calculée par le
*programme.
*Si aucun lever ou coucher de soleil ne se produit, ou si le soleil est levé toute la journée
* ou en baisse toute la journée, des valeurs booléennes appropriées sont définies.
*Un booléen est fourni pour identifier si l'heure indiquée est pendant la journée.
*
*Les valeurs ci-dessus sont accessibles par les méthodes suivantes :
*
*DategetSunrise() renvoie la date/heure du lever du soleil
*DategetSunset() renvoie la date/heure du coucher du soleil
*booleanisSunrise() renvoie vrai s'il y a eu un lever de soleil, sinon faux
*booleanisSunset() renvoie vrai s'il y a eu un coucher de soleil, sinon faux
*booleanisSunUp() renvoie vrai si le soleil est levé toute la journée, sinon faux
*booleanisSunDown() renvoie vrai si le soleil est couché toute la journée, sinon faux
*booleanisDaytime() renvoie vrai si le soleil est levé à ce moment-là
*spécifié, sinon faux
*
* Classes obligatoires de la bibliothèque Java :
*
* java.util.Date
*java.text.SimpleDateFormat
*java.text.ParseException;
* java.math.BigDecimal ;
*
* Package dont cette classe est membre :
*
*défaut
*
* Limites connues :
*
*Il est supposé que les données fournies se situent dans des plages valides
*(c'est-à-dire latitude entre -90 et +90, longitude entre 0 et 360,
*une date valide et un fuseau horaire compris entre -14 et +14.
*
*Compatibilité:
*
*Java1.1.8
*
* Références :
*
*Les algorithmes mathématiques utilisés dans ce programme sont structurés
*d'après ceux développés par Roger Sinnott dans son programme BASIC,
*SUNUP.BAS, publié dans le magazine Sky & Telescope :
*Sinnott, Roger W. "Lever et coucher du soleil : un défi"
*Sky & Telescope, août 1994 p.84-85
*
*Ce qui suit est un index croisé des variables utilisées dans SUNUP.BAS.
*Une définition unique issue de la réutilisation multiple des noms de variables dans
*SUNUP.BAS a été clarifié avec diverses définitions dans ce programme.
*
*SUNUP.BAScette classe
*
*AdfA
*A(2)dfAA1, dfAA2
*A0dfA0
*A2dfA2
*A5dfA5
*AZNon utilisé
*CdfCosLat
*C0dfC0
*DiDay
*D(2)dfDD1, dfDD2
*D0dfD0
*D1dfD1
*D2dfD2
*D5dfD5
*D7Non utilisé
*DAdfDA
*DDdfDD
*GbGrégorien, dfGG
*HdfTimeZone
*H0dfH0
*H1dfH1
*H2dfH2
*H3dfHourRise, dfHourSet
*H7Non utilisé
*JdfJ
*J3dfJ3
*K1dfK1
*LdfLL
*L0dfL0
*L2dfL2
*L5dfLon
*MiMois
*M3dfMinRise, dfMinSet
*N7Non utilisé
*PdfP
*SiSign, dfSinLat, dfSS
*TdfT
*T0dfT0
*T3non utilisé
*TTdfTT
*UdfUU
*VdfVV
*V0dfV0
*V1dfV1
*V2dfV2
*WdfWW
*Année
*ZdfZénith
*Z0dfZoneHeure
*
*
* Auteur/Entreprise :
*
*JDT : John Tauxe, Neptune et Compagnie
*JMG : Jo Marie Green
*
* Journal des modifications :
*
*date de révisiondescription du changement
*_________ _____ _____________________________________________________________
* 5 janvier 2001 0,006 JDTExposé de ssapp.java v. 0,005.
*11 janvier 2001 0,007 JDTMinor modifications apportées aux commentaires basées sur
* matériel de Sinnott, 1994.
* 7 février 2001 0,008 JDT Fuseau horaire inversé fixe. La norme est la suivante.
* Le fuseau horaire local est spécifié en heures à l'EST de
* Greenwich, pour que EST soit de -5, par exemple.
* Pour une raison quelconque, SUNUP.BAS fait cela à l'envers
* (probablement une perspective américaine) et
* SunriseSunset a adopté cette convention.
* Le signe mathématique est donc modifié.
* 7 février 2001 0,009 JDTEh bien, cela a perturbé le calcul de l'azimut...
* Suppression des calculs d'azimut.
*14 février 2001 0,010 JDTAjout de la possibilité d'accepter une heure (HH:mm) dans
* dateInput, et décidez si cette heure est le jour
* ou la nuit.
*27 février 2001 0,011 JDTAjout de méthodes d'accès au lieu d'avoir des accès publics
* variables pour obtenir des résultats.
*28 février 2001 0,012 JDTListe nettoyée des classes importées.
*28 mars 2001 1.10 JDTVersion finale accompagnant le livrable 1b.
* 4 avril 2001 1.11 JDTMoved logique prenant en charge .isDaytime dans la méthode.
* Déplacement des calculs hors du constructeur.
* 01 mai 01 1.12 JMG Ajout de la désignation « GMT » et des lignes de test.
* 16 mai 01 1.13 JDT Ajout de setLenient( false ) et setTimeZone( tz )
* à dfmtDay, dfmtMonth et dfmtYear dans
*faire des calculs.
* 27 juin 2001 1.14 JDT Suppression du recours à StationConstants (GMT).
*13 août 2001 1.20 JDTVersion finale accompagnant le livrable 1c.
* 6 septembre 2001 1.21 JDTTrévision approfondie du code et des commentaires.
*21 septembre 2001 13h30 JDTVersion finale accompagnant le livrable 2.
*17 décembre 2001 1h40 JDTVersion accompagnant le livrable final.
*
*------------------------------------------------ - -------------------------*/
//Importer les classes et packages requis
importer java.util.Date ;
importer java.text.SimpleDateFormat ;
importer java.text.ParseException ;
importer java.math.BigDecimal ;
importer java.util.TimeZone ;
/************************************************ * *****************************
*classe :classe SunriseSunset
************************************************** * *******************************
*
* Cette classe Java effectue des calculs pour déterminer l'heure de
*lever et coucher du soleil en fonction de la latitude, de la longueur et de la date.
*
*Il est supposé que les données fournies se situent dans des plages valides
*(c'est-à-dire latitude entre -90 et +90, longitude entre 0 et 360,
*une date valide et un fuseau horaire compris entre -14 et +14.
*
*------------------------------------------------ - -------------------------*/
classe publiqueSunriseSunset
{
// Déclare et initialise les variables
privé doubledfLat ; // latitude de l'utilisateur
privé doubléfLon ; // latitude de l'utilisateur
private DatedateInput ; // date/heure de l'utilisateur
privé doublédfTimeZone ; // fuseau horaire de l'utilisateur
DatedateSunrise privée ; // date et heure du lever du soleil
DatedateSunset privé ;//date et heure du coucher du soleil
private booleanbSunriseToday = false;// drapeau pour le lever du soleil à cette date
private booleanbSunsetToday = false;// indicateur du coucher du soleil à cette date
private booleanbSunUpAllDay = false ;// drapeau pour le lever du soleil toute la journée
private booleanbSunDownAllDay = false ;// drapeau pour le coucher du soleil toute la journée
private booleanbDaytime = false; // indicateur pour la journée, étant donné
// heure et min dans dateInput
private booleanbSunrise = false ; // lever du soleil pendant l'heure vérifié
private booleanbSunset = false ; // coucher de soleil pendant l'heure vérifié
private booleanbGregorian = false;// indicateur du calendrier grégorien
intiJulien privé;//Journée julien
privateintiYear;// année de la date d'intérêt
privateintiMonth ;// mois de la date d'intérêt
privateintiDay;// jour de la date d'intérêt
privateintiCount;// un simple compteur
privateintiSign;// SUNUP.BAS : S
privé doubléfHourRise, dfHourSet ;// heure de l'événement : SUNUP.BAS H3
privé doublédfMinRise, dfMinSet ;// minute de l'événement : SUNUP.BAS M3
privatedoubledfSinLat, dfCosLat ;// sin et cos de latitude
privatedoubledfZenith;// SUNUP.BAS Z : Zénith
privateSimpleDateFormat dfmtDate ;// formatage de la date seule
privateSimpleDateFormat dfmtDateTime;// formatage de la date et de l'heure
privateSimpleDateFormat dfmtYear;// formatage de l'année
privateSimpleDateFormat dfmtMonth ;// formatage du mois
privateSimpleDateFormat dfmtDay ;// formatage du jour
// De nombreuses variables dans SUNUP.BAS ont des significations non documentées,
// et donc sont traduits assez directement pour éviter toute confusion :
privédoubledfAA1 = 0, dfAA2 = 0 ;// SUNUP.BAS A(2)
privédoubledfDD1 = 0, dfDD2 = 0 ;// SUNUP.BAS D(2)
privédoubledfC0;// SUNUP.BAS C0
privédoubledfK1;// SUNUP.BAS K1
privatedoubledfP;// SUNUP.BAS P
privatedoubledfJ;// SUNUP.BAS J
privatedoubledfJ3;// SUNUP.BAS J3
privatedoubledfA;// SUNUP.BAS A
privédoubledfA0, dfA2, dfA5;// SUNUP.BAS A0, A2, A5
privatedoubledfD0, dfD1, dfD2, dfD5 ;// SUNUP.BAS D0, D1, D2, D5
privédoubledfDA, dfDD;// SUNUP.BAS DA, DD
privédoubledfH0, dfH1, dfH2 ;// SUNUP.BAS H0, H1, H2
privatedoubledfL0, dfL2;// SUNUP.BAS L0, L2
privédoubledfT, dfT0, dfTT;// SUNUP.BAS T, T0, TT
privatedoubledfV0, dfV1, dfV2;// SUNUP.BAS V0, V1, V2
Private TimeZone tz = TimeZone.getTimeZone( "GMT" );
/************************************************ * *****************************
*méthode : lever du soleil et coucher du soleil
************************************************** * *******************************
*
*Constructeur pour la classe SunriseSunset.
*
*------------------------------------------------ - -------------------------*/
LeverCoucher de soleil(
double dfLatIn,//latitude
double dfLonIn,// longitude
Date dateEntréeIn,// date
double dfTimeZoneIn//fuseau horaire
)
{
// Copie les valeurs fournies comme arguments vers les variables locales.
dfLat = dfLatIn;
dfLon = dfLonIn;
dateInput = dateInputIn;
dfTimeZone = dfTimeZoneIn;
// Appelez la méthode pour effectuer les calculs.
doCalculs();
} // constructeur de fin de classe
/************************************************ * *****************************
*méthode : doCalculs
************************************************** * *******************************
*
*Méthode pour effectuer les calculs effectués dans SUNUP.BAS.
*
*------------------------------------------------ - -------------------------*/
vide privé doCalculations()
{
essayer
{
// Répartir le jour, le mois et l'année à partir de la date fournie.
// (Ceci est nécessaire pour les algorithmes mathématiques.)
dfmtYear = new SimpleDateFormat( "aaaa" );
dfmtYear.setLenient( false );
dfmtYear.setTimeZone(tz);
dfmtMonth = new SimpleDateFormat( "M" );
dfmtMonth.setLenient( false );
dfmtMonth.setTimeZone(tz);
dfmtDay = new SimpleDateFormat( "d" );
dfmtDay.setLenient( false );
dfmtDay.setTimeZone(tz);
iYear = Integer.parseInt( dfmtYear.format( dateInput ) );
iMonth = Integer.parseInt( dfmtMonth.format( dateInput ) );
iDay = Integer.parseInt( dfmtDay.format( dateInput ) );
// Convertit les heures du fuseau horaire en jours décimaux (ligne 50 de SUNUP.BAS)
dfTimeZone = dfTimeZone / 24,0 ;
// REMARQUE : (7 février 2001) Voici une partie non standard de SUNUP.BAS :
// Il (et cet algorithme) suppose que le fuseau horaire est
// Ouest positif, au lieu de l'ouest négatif standard.
// Les classes appelant SunriseSunset supposeront que
// les fuseaux horaires sont spécifiés en ouest négatif, donc ici le
// le signe est modifié pour que l'algorithme SUNUP fonctionne :
dfTimeZone = -dfTimeZone ;
// Convertir la longitude en fraction (ligne 50 de SUNUP.BAS)
dfLon = dfLon / 360,0 ;
// Convertit la date du calendrier en date julienne :
// Vérifier si c'est après 1583 : calendrier grégorien
// Une fois déclaré, bGregorian est initialisé à false.
// ** Pensez à créer une classe distincte de cette fonction **.
if( iYear >= 1583 ) bGregorian = true;
// SUNUP.BAS 1210
dfJ = -Math.floor( 7.0// SUNUP a utilisé INT, pas floor
* (Math.étage(
(iMois+9.0)
/12,0
) + iAnnée
) / 4,0
)
// ajoute SUNUP.BAS 1240 et 1250 pour G = 0
+ Math.floor (iMois * 275,0 / 9,0)
+ iDay
+1721027.0
+ iAnnée * 367,0 ;
si(bgrégorien)
{
// SUNUP.BAS 1230
si ( ( iMois - 9,0 ) < 0,0 ) iSign = -1;
sinon iSign = 1 ;
dfA = Math.abs (iMois - 9.0 );
// SUNUP.BAS 1240 et 1250
dfJ3 = -Math.étage(
(
Math.étage(
Math.floor (iAnnée
+ (double)iSigne
* Math.floor( dfA / 7.0 )
)
/100,0
) + 1,0
) * 0,75
);
// corrige dfJ comme dans SUNUP.BAS 1240 et 1250 pour G = 1
dfJ = dfJ + dfJ3 + 2,0 ;
}
// SUNUP.BAS 1290
iJulien = (int)dfJ - 1;
// SUNUP.BAS 60 et 70 (voir aussi ligne 1290)
dfT = (double)iJulien - 2451545,0 + 0,5 ;
dfTT = dfT / 36525.0 + 1.0 ; // siècles depuis 1900
// Calcule l'heure sidérale locale à 0h en fuseau horaire
// SUNUP.BAS 410 à 460
dfT0 = ( dfT * 8640184,813 / 36525,0
+24110.5
+dfTimeZone*86636.6
+dfLon*86400.0
)
/86400.0 ;
dfT0 = dfT0 - Math.floor( dfT0 ); // REMARQUE : SUNUP.BAS utilise INT()
dfT0 = dfT0 * 2,0 * Math.PI ;
// SUNUP.BAS 90
dfT = dfT + dfTimeZone ;
// SUNUP.BAS 110 : Obtenir la position du Soleil
for( iCount=0; iCount<=1; iCount++ )// Boucle seulement deux fois
{
// Calculer l'ascension droite et la déclinaison du Soleil
// au début et à la fin de chaque journée.
// SUNUP.BAS 910 - 1160 : Arguments fondamentaux
// d'après van Flandern et Pulkkinen, 1979
// déclare des doubles temporaires locaux pour les calculs
doublédfGG;// SUNUP.BAS G
doublédfLL;// SUNUP.BAS L
doublédfSS;// SUNUP.BAS S
doubléfUU;// SUNUP.BAS U
doublédfVV;// SUNUP.BAS V
doubléfWW;// SUNUP.BAS W
dfLL = 0,779072 + 0,00273790931 * dfT ;
dfLL = dfLL - Math.floor( dfLL );
dfLL = dfLL * 2,0 * Math.PI ;
dfGG = 0,993126 + 0,0027377785 * dfT ;
dfGG = dfGG - Math.floor( dfGG );
dfGG = dfGG * 2,0 * Math.PI ;
dfVV = 0,39785 * Math.sin( dfLL )
- 0,01000 * Math.sin( dfLL - dfGG )
+ 0,00333 * Math.sin( dfLL + dfGG )
- 0,00021 * Math.sin( dfLL ) * dfTT ;
dfUU=1
- 0,03349 * Math.cos(dfGG)
- 0,00014 * Math.cos( dfLL * 2.0 )
+ 0,00008 * Math.cos( dfLL );
dfWW = - 0,00010
- 0,04129 * Math.sin( dfLL * 2.0 )
+ 0,03211 * Math.sin( dfGG )
- 0,00104 * Math.sin( 2,0 * dfLL - dfGG )
- 0,00035 * Math.sin( 2,0 * dfLL + dfGG )
- 0,00008 * Math.sin( dfGG ) * dfTT ;
// Calcule le RA et le Dec du Soleil ; SUNUP.BAS 1120 - 1140
dfSS = dfWW / Math.sqrt( dfUU - dfVV * dfVV );
dfA5 = dfLL
+ Math.atan( dfSS / Math.sqrt( 1.0 - dfSS * dfSS ));
dfSS = dfVV / Math.sqrt( dfUU );
dfD5 = Math.atan( dfSS / Math.sqrt( 1 - dfSS * dfSS ));
// Définir les valeurs et incrémenter t
si ( iCount == 0 )// SUNUP.BAS 125
{
dfAA1 = dfA5 ;
dfDD1 = dfD5 ;
}
sinon// SUNUP.BAS 145
{
dfAA2 = dfA5 ;
dfDD2 = dfD5 ;
}
dfT = dfT + 1,0 ; // SUNUP.BAS 130
}// fin de la boucle Obtenir la position du soleil
si ( dfAA2 < dfAA1 ) dfAA2 = dfAA2 + 2,0 * Math.PI ;
// SUNUP.BAS 150
dfZenith = Math.PI * 90,833 / 180,0 ;// SUNUP.BAS 160
dfSinLat = Math.sin( dfLat * Math.PI / 180.0 );// SUNUP.BAS 170
dfCosLat = Math.cos( dfLat * Math.PI / 180.0 );// SUNUP.BAS 170
dfA0 = dfAA1;// SUNUP.BAS 190
dfD0 = dfDD1;// SUNUP.BAS 190
dfDA = dfAA2 - dfAA1; // SUNUP.BAS 200
dfDD = dfDD2 - dfDD1; // SUNUP.BAS 200
dfK1 = 15,0 * 1,0027379 * Math.PI / 180,0;// SUNUP.BAS 330
// Initialise les heures de lever et de coucher du soleil et d'autres variables
// hr et min sont réglés sur des temps impossibles pour rendre les erreurs évidentes
dfHourRise = 99,0 ;
dfMinRise = 99,0 ;
dfHourSet = 99,0 ;
dfMinSet = 99,0 ;
dfV0 = 0.0;// initialisation impliquée par l'absence dans SUNUP.BAS
dfV2 = 0.0;// initialisation impliquée par l'absence dans SUNUP.BAS
// Testez chaque heure pour voir si le Soleil traverse l'horizon
// et dans quelle direction il se dirige.
pour( iCount=0; iCount<24; iCount++ )// SUNUP.BAS 210
{
doubletempA;// SUNUP.BAS A
doubletempB;// SUNUP.BAS B
doubletempD;// SUNUP.BAS D
doubletempE;// SUNUP.BAS E
dfC0 = (double)iCount ;
dfP = ( dfC0 + 1.0 ) / 24.0;// SUNUP.BAS 220
dfA2 = dfAA1 + dfP * dfDA ; // SUNUP.BAS 230
dfD2 = dfDD1 + dfP * dfDD; // SUNUP.BAS 230
dfL0 = dfT0 + dfC0 * dfK1;// SUNUP.BAS 500
dfL2 = dfL0 + dfK1; // SUNUP.BAS 500
dfH0 = dfL0 - dfA0; // SUNUP.BAS 510
dfH2 = dfL2 - dfA2; // SUNUP.BAS 510
// angle horaire à la demi-heure
dfH1 = ( dfH2 + dfH0 ) / 2.0;// SUNUP.BAS 520
// déclinaison à la demi-heure
dfD1 = ( dfD2 + dfD0 ) / 2.0;// SUNUP.BAS 530
// Fixe la valeur de dfV0 uniquement s'il s'agit de la première heure,
// sinon, il sera défini sur le dernier dfV2 (SUNUP.BAS 250)
si ( iCount == 0 )// SUNUP.BAS 550
{
dfV0 = dfSinLat * Math.sin( dfD0 )
+ dfCosLat * Math.cos( dfD0 ) * Math.cos( dfH0 )
- Math.cos( dfZenith );// SUNUP.BAS 560
}
autre
dfV0 = dfV2;// C'est-à-dire dfV2 de l'heure précédente.
dfV2 = dfSinLat * Math.sin( dfD2 )
+ dfCosLat * Math.cos( dfD2 ) * Math.cos( dfH2 )
- Math.cos( dfZenith );// SUNUP.BAS 570
// si dfV0 et dfV2 ont le même signe, alors passez à l'heure suivante
si (
( dfV0 >= 0.0 && dfV2 >= 0.0 )// les deux sont positifs
||// ou
( dfV0 < 0.0 && dfV2 < 0.0 ) // les deux sont négatifs
)
{
// Arrêter l'itération et passer au test l'heure suivante
dfA0 = dfA2;// SUNUP.BAS 250
dfD0 = dfD2;// SUNUP.BAS 250
continuer ;// SUNUP.BAS 610
}
dfV1 = dfSinLat * Math.sin( dfD1 )
+ dfCosLat * Math.cos( dfD1 ) * Math.cos( dfH1 )
- Math.cos( dfZenith );// SUNUP.BAS 590
tempA = 2,0 * dfV2 - 4,0 * dfV1 + 2,0 * dfV0 ;
// SUNUP.BAS 600
tempB = 4,0 * dfV1 - 3,0 * dfV0 - dfV2 ; // SUNUP.BAS 600 ;
tempD = tempB * tempB - 4.0 * tempA * dfV0;// SUNUP.BAS 610
si (tempD < 0,0)
{
// Arrêter l'itération et passer au test l'heure suivante
dfA0 = dfA2;// SUNUP.BAS 250
dfD0 = dfD2;// SUNUP.BAS 250
continuer ;// SUNUP.BAS 610
}
tempD = Math.sqrt( tempD );// SUNUP.BAS 620
// Détermine l'occurrence du lever ou du coucher du soleil.
// Les drapeaux pour identifier l'événement au cours de cette journée sont
// bSunriseToday et bSunsetToday, et sont initialisés false.
// Ceux-ci sont définis sur vrai uniquement si le lever ou le coucher du soleil se produit
// à tout moment de la boucle horaire. Ne jamais définir sur false.
// Indicateurs pour identifier l'occurrence pendant cette heure :
bSunrise = false ; // réinitialisé avant le test
bSunset = false ; // réinitialisé avant le test
si ( dfV0 < 0.0 && dfV2 > 0.0 )// le lever du soleil a lieu cette heure
{
bSunrise = vrai ; // SUNUP.BAS 640
bSunriseToday = true ; // le lever du soleil s'est produit aujourd'hui
}
si ( dfV0 > 0.0 && dfV2 < 0.0 )// le coucher du soleil a lieu cette heure
{
bSunset = vrai ; // SUNUP.BAS 660
bSunsetToday = true ;// le coucher du soleil s'est produit aujourd'hui
}
tempE = ( tempD - tempB ) / ( 2.0 * tempA );
si ( tempE > 1,0 || tempE < 0,0 )// SUNUP.BAS 670, 680
tempE = ( -tempD - tempB ) / ( 2.0 * tempA );
// Définir les valeurs de l'heure et des minutes du coucher ou du lever du soleil
// seulement si le lever/coucher a eu lieu à cette heure.
si (bSunrise)
{
dfHourRise = Math.floor( dfC0 + tempE + 1.0/120.0 );
dfMinRise = Math.floor(
(dfC0 + tempE + 1,0/120,0
- dfHourRise
)
* 60,0
);
}
si (bCoucher du soleil)
{
dfHourSet = Math.floor( dfC0 + tempE + 1.0/120.0 );
dfMinSet = Math.sol(
(dfC0 + tempE + 1,0/120,0
- dfHourSet
)
* 60,0
);
}
// Modifier les paramètres des variables pour la boucle suivante
dfA0 = dfA2;// SUNUP.BAS 250
dfD0 = dfD2;// SUNUP.BAS 250
}//test de fin de boucle chaque heure pour un événement
// Après avoir vérifié toutes les heures, positionner les drapeaux si aucune montée ou mise
// bSunUpAllDay et bSundownAllDay sont initialisés à false
si ( !bSunriseToday && !bSunsetToday )
{
si (dfV2 < 0,0)
bSunDownAllDay = vrai ;
autre
bSunUpAllDay = vrai ;
}
// Charger dateSunrise avec les données
dfmtDateTime = new SimpleDateFormat( "d M aaaa HH:mm z" );
si (bSunriseAujourd'hui)
{
dateSunrise = dfmtDateTime.parse (iDay
+ " " + iMois
+ " " + iAnnée
+ " " + (int)dfHourRise
+ ":" + (int)dfMinRise
+ "GMT" );
}
// Charger dateSunset avec les données
si (bSunsetToday)
{
dateSunset = dfmtDateTime.parse (iDay
+ " " + iMois
+ " " + iAnnée
+ " " + (int)dfHourSet
+ ":" + (int)dfMinSet
+ "GMT" );
}
} // fin de l'essai
// Capture des erreurs
attraper (ParseException e)
{
System.out.println( "/nCannot analyser la date" );
System.out.println(e);
Système.exit(1);
} // fin de la capture
}
/************************************************ * *****************************
*méthode :getSunrise()
************************************************** * *******************************
*
* Obtient la date et l'heure du lever du soleil, renvoie null.
*
*Membre de la classe SunriseSunset
*
*------------------------------------------------ - -------------------------------- */
Date publique getSunrise()
{
si (bSunriseAujourd'hui)
retour (dateSunrise);
autre
revenir (nul);
}
/************************************************ * *****************************
*méthode:getSunset()
************************************************** * *******************************
*
* Obtient la date et l'heure du coucher du soleil, renvoie null.
*
*Membre de la classe SunriseSunset
*
*------------------------------------------------ - -------------------------------- */
Date publiquegetSunset()
{
si (bSunsetToday)
retour (dateSunset);
autre
revenir (nul);
}
/************************************************ * *****************************
*méthode :isSunrise()
************************************************** * *******************************
*
* Renvoie un booléen identifiant s'il y a eu un lever de soleil.
*
*Membre de la classe SunriseSunset
*
*------------------------------------------------ - -------------------------------- */
public booléen isSunrise()
{
return( bSunriseToday );
}
/************************************************ * *****************************
*méthode:isSunset()
************************************************** * *******************************
*
* Renvoie un booléen identifiant s'il y a eu un coucher de soleil.
*
*Membre de la classe SunriseSunset
*
*------------------------------------------------ - -------------------------------- */
public booléen isSunset()
{
return( bSunsetToday );
}
/************************************************ * *****************************
*méthode :isSunUp()
************************************************** * *******************************
*
* Renvoie un booléen identifiant si le soleil est levé toute la journée.
*
*Membre de la classe SunriseSunset
*
*------------------------------------------------ - -------------------------------- */
public booléen isSunUp()
{
return( bSunUpAllDay );
}
/************************************************ * *****************************
*méthode :isSunDown()
************************************************** * *******************************
*
* Renvoie un booléen identifiant si le soleil est couché toute la journée.
*
*Membre de la classe SunriseSunset
*
*------------------------------------------------ - -------------------------------- */
public booléen isSunDown()
{
return(bSunDownAllDay);
}
/************************************************ * *****************************
*méthode :isDaytime()
************************************************** * *******************************
*
* Renvoie un booléen identifiant s'il fait jour à l'heure contenue dans
*l'objet Date transmis à SunriseSunset lors de la construction.
*
*Membre de la classe SunriseSunset
*
*------------------------------------------------ - -------------------------------- */
public booléen isDaytime()
{
// Détermine s'il fait jour (au lever du soleil ou plus tard)
//ou la nuit (au coucher du soleil ou plus tard) à l'endroit d'intérêt
//mais exprimé dans le fuseau horaire demandé.
if ( bSunriseToday && bSunsetToday ) // lever et coucher du soleil
{
if ( dateSunrise.before( dateSunset ) )// lever du soleil < coucher du soleil
{
si (
(
dateInput.after(dateSunrise)
dateInput.equals (dateSunrise)
)
&&
dateInput.before(dateSunset)
)
bJour = vrai ;
autre
bJour = faux ;
}
sinon // le lever du soleil vient après le coucher du soleil (dans des fuseaux horaires opposés)
{
si (
(
dateInput.after(dateSunrise)
dateInput.equals (dateSunrise)
)
||// utiliser OR plutôt que AND
dateInput.before(dateSunset)
)
bJour = vrai ;
autre
bJour = faux ;
}
}
sinon if ( bSunUpAllDay ) // le soleil est levé toute la journée
bJour = vrai ;
sinon si ( bSunDownAllDay )// le soleil est couché toute la journée
bJour = faux ;
sinon if ( bSunriseToday ) // lever du soleil mais pas de coucher du soleil
{
si ( dateInput.before( dateSunrise ) )
bJour = faux ;
autre
bJour = vrai ;
}
else if ( bSunsetToday ) // coucher de soleil mais pas de lever de soleil
{
si ( dateInput.before( dateSunset ) )
bJour = vrai ;
autre
bJour = faux ;
}
else bDaytime = false; // cela ne devrait jamais s'exécuter
return(bJour);
}
} // fin du cours
/*------------------------------------------------ --------------------------
*fin du cours
*------------------------------------------------ - -------------------------*/