Java获取当地的日出日落时间代码分享

/******************************************************************************
*
*       sunrisesunset.java
*
*******************************************************************************
*
* java class: sunrisesunset
*
* this java class is part of a collection of classes developed for the
* reading and processing of oceanographic and meterological data collected
* since 1970 by environmental buoys and stations.  this dataset is
* maintained by the national oceanographic data center and is publicly
* available.  these java classes were written for the us environmental
* protection agency's national exposure research laboratory under contract
* no. gs-10f-0073k with neptune and company of los alamos, new mexico.
*
* purpose:
*
*  this java class performs calculations to determine the time of
* sunrise and sunset given lat, long, and date.
*
* inputs:
*
*  latitude, longitude, date/time, and time zone.
*
* outputs:
*
*  local time of sunrise and sunset as calculated by the
*   program.
* if no sunrise or no sunset occurs, or if the sun is up all day
*   or down all day, appropriate boolean values are set.
* a boolean is provided to identify if the time provided is during the day.
*
* the above values are accessed by the following methods:
*
*  date getsunrise() returns date/time of sunrise
*  date getsunset()  returns date/time of sunset
*  boolean issunrise()  returns true if there was a sunrise, else false
*  boolean issunset()  returns true if there was a sunset, else false
*  boolean issunup()  returns true if sun is up all day, else false
*  boolean issundown()  returns true if sun is down all day, else false
*  boolean isdaytime()  returns true if sun is up at the time
*         specified, else false
*
* required classes from the java library:
*
*  java.util.date
*  java.text.simpledateformat
*  java.text.parseexception;
*  java.math.bigdecimal;
*
* package of which this class is a member:
*
* default
*
* known limitations:
*
* it is assumed that the data provided are within valie ranges
* (i.e. latitude between -90 and +90, longitude between 0 and 360,
* a valid date, and time zone between -14 and +14.
*
* compatibility:
*
* java 1.1.8
*
* references:
* 
* the mathematical algorithms used in this program are patterned
* after those debveloped by roger sinnott in his basic program,
* sunup.bas, published in sky & telescope magazine:
* sinnott, roger w. "sunrise and sunset: a challenge"
* sky & telescope, august, 1994 p.84-85
*
* the following is a cross-index of variables used in sunup.bas.
* a single definition from multiple reuse of variable names in
* sunup.bas was clarified with various definitions in this program.
*
* sunup.bas this class
*
* a   dfa
* a(2)  dfaa1, dfaa2
* a0   dfa0
* a2   dfa2
* a5   dfa5
* az   not used
* c   dfcoslat
* c0   dfc0
* d   iday
* d(2)  dfdd1, dfdd2
* d0   dfd0
* d1   dfd1
* d2   dfd2
* d5   dfd5
* d7   not used
* da   dfda
* dd   dfdd
* g   bgregorian, dfgg
* h   dftimezone
* h0   dfh0
* h1   dfh1
* h2   dfh2
* h3   dfhourrise, dfhourset
* h7   not used
* j   dfj
* j3   dfj3
* k1   dfk1
* l   dfll
* l0   dfl0
* l2   dfl2
* l5   dflon
* m   imonth
* m3   dfminrise, dfminset
* n7   not used
* p   dfp
* s   isign, dfsinlat, dfss
* t   dft
* t0   dft0
* t3   not used
* tt   dftt
* u   dfuu
* v   dfvv
* v0   dfv0
* v1   dfv1
* v2   dfv2
* w   dfww
* y   iyear
* z   dfzenith
* z0   dftimezone
* 
* 
* author/company:
*
*  jdt: john tauxe, neptune and company
* jmg: jo marie green
*
* change log:
* 
* date       ver    by description of change
* _________  _____  ___ ______________________________________________
*  5 jan 01  0.006  jdt excised from ssapp.java v. 0.005.
* 11 jan 01  0.007  jdt minor modifications to comments based on
*         material from sinnott, 1994.
*  7 feb 01  0.008  jdt fixed backwards time zone.  the standard is that
*         local time zone is specified in hours east of
*         greenwich, so that est would be -5, for example.
*         for some reason, sunup.bas does this backwards
*         (probably an americocentric perspective) and
*         sunrisesunset adopted that convention.  oops.
*         so the sign in the math is changed.
*  7 feb 01  0.009  jdt well, that threw off the azimuth calculation...
*         removed the azimuth calculations.
* 14 feb 01  0.010  jdt added ability to accept a time (hh:mm) in
*         dateinput, and decide if that time is daytime
*         or nighttime.
* 27 feb 01  0.011  jdt added accessor methods in place of having public
*         variables to get results.
* 28 feb 01  0.012  jdt cleaned up list of imported classes.
* 28 mar 01  1.10   jdt final version accompanying deliverable 1b.
*    4 apr 01  1.11   jdt moved logic supporting .isdaytime into method.
*         moved calculations out of constructor.
*   01 may 01  1.12   jmg   added 'gmt' designation and testing lines.
*   16 may 01  1.13   jdt   added setlenient( false ) and settimezone( tz )
*                           to dfmtday, dfmtmonth, and dfmtyear in
*       docalculations.
*   27 jun 01  1.14   jdt removed reliance on stationconstants (gmt).
* 13 aug 01  1.20   jdt final version accompanying deliverable 1c.
*  6 sep 01  1.21   jdt thorough code and comment review.
* 21 sep 01  1.30   jdt final version accompanying deliverable 2.
* 17 dec 01  1.40   jdt version accompanying final deliverable.
*    
*----------------------------------------------------------------------------*/

// import required classes and packages
import java.util.date;
import java.text.simpledateformat;
import java.text.parseexception;
import java.math.bigdecimal;
import java.util.timezone;

/******************************************************************************
* class:     sunrisesunset class
*******************************************************************************
*
*  this java class performs calculations to determine the time of
* sunrise and sunset given lat, long, and date.
*
* it is assumed that the data provided are within valie ranges
* (i.e. latitude between -90 and +90, longitude between 0 and 360,
* a valid date, and time zone between -14 and +14.
* 
*----------------------------------------------------------------------------*/
public class sunrisesunset
{

 // declare and initialize variables
 private double dflat;     // latitude from user
 private double dflon;     // latitude from user
 private date dateinput;    // date/time from user
 private double dftimezone;    // time zone from user

 private date datesunrise;   // date and time of sunrise
 private date datesunset;    // date and time of sunset
 private boolean bsunrisetoday  = false; // flag for sunrise on this date
 private boolean bsunsettoday   = false; // flag for sunset on this date
 private boolean bsunupallday   = false; // flag for sun up all day
 private boolean bsundownallday = false; // flag for sun down all day
 private boolean bdaytime    = false; // flag for daytime, given
           // hour and min in dateinput
 private boolean bsunrise = false;  // sunrise during hour checked
 private boolean bsunset  = false;  // sunset during hour checked
 private boolean bgregorian = false;  // flag for gregorian calendar
 private int  ijulian;    // julian day
 private int  iyear;     // year of date of interest
 private int  imonth;     // month of date of interest
 private int  iday;     // day of date of interest
 private int  icount;     // a simple counter
 private int  isign;     // sunup.bas: s
 private double dfhourrise, dfhourset; // hour of event: sunup.bas h3
 private double dfminrise, dfminset; // minute of event: sunup.bas m3
 private double dfsinlat, dfcoslat;  // sin and cos of latitude
 private double dfzenith;    // sunup.bas z: zenith
 private simpledateformat dfmtdate;  // formatting for date alone
 private simpledateformat dfmtdatetime; // formatting for date and time
 private simpledateformat dfmtyear;  // formatting for year
 private simpledateformat dfmtmonth;  // formatting for month
 private simpledateformat dfmtday;  // formatting for day
 // many variables in sunup.bas have undocumented meanings,
 // and so are translated rather directly to avoid confusion:
 private double dfaa1 = 0, dfaa2 = 0; // sunup.bas a(2)
 private double dfdd1 = 0, dfdd2 = 0; // sunup.bas d(2)
 private double dfc0;     // sunup.bas c0
 private double dfk1;     // sunup.bas k1
 private double dfp;     // sunup.bas p
 private double dfj;     // sunup.bas j
 private double dfj3;     // sunup.bas j3
 private double dfa;     // sunup.bas a
 private double dfa0, dfa2, dfa5;  // sunup.bas a0, a2, a5
 private double dfd0, dfd1, dfd2, dfd5; // sunup.bas d0, d1, d2, d5
 private double dfda, dfdd;    // sunup.bas da, dd
 private double dfh0, dfh1, dfh2;  // sunup.bas h0, h1, h2
 private double dfl0, dfl2;    // sunup.bas l0, l2
 private double dft, dft0, dftt;  // sunup.bas t, t0, tt
 private double dfv0, dfv1, dfv2;  // sunup.bas v0, v1, v2

 private timezone tz = timezone.gettimezone( "gmt" );

 
/******************************************************************************
* method:     sunrisesunset
*******************************************************************************
*
* constructor for sunrisesunset class.
*
*----------------------------------------------------------------------------*/
 sunrisesunset(
      double dflatin,    // latitude
      double dflonin,    // longitude
      date  dateinputin,   // date
      double dftimezonein   // time zone
      )
 {
  // copy values supplied as agruments to local variables.
  dflat   = dflatin;
  dflon   = dflonin;
  dateinput  = dateinputin;
  dftimezone  = dftimezonein;

  // call the method to do the calculations.
  docalculations();

 } // end of class constructor

/******************************************************************************
* method:     docalculations
*******************************************************************************
*
* method for performing the calculations done in sunup.bas.
*
*----------------------------------------------------------------------------*/
 private void docalculations()
 {
  try
  {
   // break out day, month, and year from date provided.
   // (this is necesary for the math algorithms.)

   dfmtyear  = new simpledateformat( "yyyy" );
   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 ) );

   // convert time zone hours to decimal days (sunup.bas line 50)
   dftimezone = dftimezone / 24.0;

   // note: (7 feb 2001) here is a non-standard part of sunup.bas:
   // it (and this algorithm) assumes that the time zone is
   // positive west, instead of the standard negative west.
   // classes calling sunrisesunset will be assuming that
   // times zones are specified in negative west, so here the
   // sign is changed so that the sunup algorithm works:
   dftimezone = -dftimezone;

   // convert longitude to fraction (sunup.bas line 50)
   dflon = dflon / 360.0;

   // convert calendar date to julian date:
   // check to see if it's later than 1583: gregorian calendar
   // when declared, bgregorian is initialized to false.
   // ** consider making a separate class of this function. **
   if( iyear >= 1583 ) bgregorian = true;
   // sunup.bas 1210
   dfj = -math.floor( 7.0  // sunup used int, not floor
        * ( math.floor(
              ( imonth + 9.0 )
              / 12.0
             ) + iyear
           ) / 4.0
        )
    // add sunup.bas 1240 and 1250 for g = 0
    + math.floor( imonth * 275.0 / 9.0 )
    + iday
    + 1721027.0
    + iyear * 367.0;

   if ( bgregorian )
   {
    // sunup.bas 1230
    if ( ( imonth - 9.0 ) < 0.0 ) isign = -1;
    else isign = 1;
    dfa = math.abs( imonth - 9.0 );
    // sunup.bas 1240 and 1250
    dfj3 = -math.floor(
          (
       math.floor(
         math.floor( iyear
          + (double)isign
            * math.floor( dfa / 7.0 )
            )
            / 100.0
           ) + 1.0
          ) * 0.75
         );
    // correct dfj as in sunup.bas 1240 and 1250 for g = 1
    dfj = dfj + dfj3 + 2.0;
   }
   // sunup.bas 1290
   ijulian = (int)dfj - 1;

   // sunup.bas 60 and 70 (see also line 1290)
   dft = (double)ijulian - 2451545.0 + 0.5;
   dftt = dft / 36525.0 + 1.0;    // centuries since 1900

   // calculate local sidereal time at 0h in zone time
   // sunup.bas 410 through 460
   dft0 = ( dft * 8640184.813 / 36525.0
     + 24110.5
     + dftimezone * 86636.6
     + dflon * 86400.0
      )
      / 86400.0;
   dft0 = dft0 - math.floor( dft0 ); // note: sunup.bas uses int()
   dft0 = dft0 * 2.0 * math.pi;
   // sunup.bas 90
   dft = dft + dftimezone;

   // sunup.bas 110: get sun's position
   for( icount=0; icount<=1; icount++ ) // loop thru only twice
   {
    // calculate sun's right ascension and declination
    //   at the start and end of each day.
    // sunup.bas 910 - 1160: fundamental arguments
    //   from van flandern and pulkkinen, 1979

    // declare local temporary doubles for calculations
    double dfgg;      // sunup.bas g
    double dfll;      // sunup.bas l
    double dfss;      // sunup.bas s
    double dfuu;      // sunup.bas u
    double dfvv;      // sunup.bas v
    double dfww;      // 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;

    // compute sun's ra and dec; 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 ));     

    // set values and increment t
    if ( icount == 0 )  // sunup.bas 125
    {
     dfaa1 = dfa5;
     dfdd1 = dfd5;
    }
    else     // sunup.bas 145
    {
     dfaa2 = dfa5;
     dfdd2 = dfd5;
    }
    dft = dft + 1.0;  // sunup.bas 130
   } // end of get sun's position for loop

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

   // initialize sunrise and sunset times, and other variables
   // hr and min are set to impossible times to make errors obvious
   dfhourrise = 99.0;
   dfminrise  = 99.0;
   dfhourset  = 99.0;
   dfminset   = 99.0;
   dfv0 = 0.0;  // initialization implied by absence in sunup.bas
   dfv2 = 0.0;  // initialization implied by absence in sunup.bas

   // test each hour to see if the sun crosses the horizon
   //   and which way it is heading.
   for( icount=0; icount<24; icount++ )   // sunup.bas 210
   {
    double tempa;        // sunup.bas a
    double tempb;        // sunup.bas b
    double tempd;        // sunup.bas d
    double tempe;        // 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
    // hour angle at half hour
    dfh1 = ( dfh2 + dfh0 ) / 2.0;    // sunup.bas 520
    // declination at half hour
    dfd1 = ( dfd2 + dfd0 ) / 2.0;    // sunup.bas 530

    // set value of dfv0 only if this is the first hour,
    // otherwise, it will get set to the last dfv2 (sunup.bas 250)
    if ( icount == 0 )       // sunup.bas 550
    { 
     dfv0 = dfsinlat * math.sin( dfd0 )
       + dfcoslat * math.cos( dfd0 ) * math.cos( dfh0 )
       - math.cos( dfzenith );   // sunup.bas 560
    }
    else
     dfv0 = dfv2; // that is, dfv2 from the previous hour.

    dfv2 = dfsinlat * math.sin( dfd2 )
       + dfcoslat * math.cos( dfd2 ) * math.cos( dfh2 )
       - math.cos( dfzenith );   // sunup.bas 570

    // if dfv0 and dfv2 have the same sign, then proceed to next hr
    if (
      ( dfv0 >= 0.0 && dfv2 >= 0.0 )  // both are positive
      ||        // or
      ( dfv0 < 0.0 && dfv2 < 0.0 )   // both are negative
       )
    {
     // break iteration and proceed to test next hour
     dfa0 = dfa2;       // sunup.bas 250
     dfd0 = dfd2;       // sunup.bas 250
     continue;        // 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

    if ( tempd < 0.0 )
    {
     // break iteration and proceed to test next hour
     dfa0 = dfa2;       // sunup.bas 250
     dfd0 = dfd2;       // sunup.bas 250
     continue;        // sunup.bas 610
    }

    tempd = math.sqrt( tempd );     // sunup.bas 620

    // determine occurence of sunrise or sunset.

    // flags to identify occurrence during this day are
    // bsunrisetoday and bsunsettoday, and are initialized false.
    // these are set true only if sunrise or sunset occurs
    // at any point in the hourly loop. never set to false.

    // flags to identify occurrence during this hour:
    bsunrise = false;    // reset before test
    bsunset  = false;    // reset before test

    if ( dfv0 < 0.0 && dfv2 > 0.0 ) // sunrise occurs this hour
    {
     bsunrise = true;   // sunup.bas 640
     bsunrisetoday = true;  // sunrise occurred today
    }

    if ( dfv0 > 0.0 && dfv2 < 0.0 ) // sunset occurs this hour
    {
     bsunset = true;    // sunup.bas 660
     bsunsettoday = true;  // sunset occurred today
    }

    tempe = ( tempd - tempb ) / ( 2.0 * tempa );
    if ( tempe > 1.0 || tempe < 0.0 ) // sunup.bas 670, 680
     tempe = ( -tempd - tempb ) / ( 2.0 * tempa );     

    // set values of hour and minute of sunset or sunrise
    // only if sunrise/set occurred this hour.
    if ( bsunrise )
    {
     dfhourrise = math.floor( dfc0 + tempe + 1.0/120.0 );
     dfminrise  = math.floor(
            ( dfc0 + tempe + 1.0/120.0
               - dfhourrise
            )
            * 60.0
           );
    }

    if ( bsunset )
    {
     dfhourset  = math.floor( dfc0 + tempe + 1.0/120.0 );
     dfminset   = math.floor(
            ( dfc0 + tempe + 1.0/120.0
               - dfhourset
            )
            * 60.0
           );
    }

    // change settings of variables for next loop
    dfa0 = dfa2;        // sunup.bas 250
    dfd0 = dfd2;        // sunup.bas 250

   } // end of loop testing each hour for an event 

   // after having checked all hours, set flags if no rise or set
   // bsunupallday and bsundownallday are initialized as false
   if ( !bsunrisetoday && !bsunsettoday )
   {
    if ( dfv2 < 0.0 )
     bsundownallday = true;
    else
     bsunupallday = true;
   }

   // load datesunrise with data
   dfmtdatetime = new simpledateformat( "d m yyyy hh:mm z" );
   if( bsunrisetoday )
   {
    datesunrise = dfmtdatetime.parse( iday
          + " " + imonth
          + " " + iyear
          + " " + (int)dfhourrise
          + ":" + (int)dfminrise
          + " gmt" );
   }

   // load datesunset with data
   if( bsunsettoday )
   {
    datesunset = dfmtdatetime.parse( iday
          + " " + imonth
          + " " + iyear
          + " " + (int)dfhourset
          + ":" + (int)dfminset
          + " gmt" );
   }
  } // end of try

  // catch errors
  catch( parseexception e )
  {
   system.out.println( "\ncannot parse date" );
   system.out.println( e );
   system.exit( 1 );
  } // end of catch

 }

 
/******************************************************************************
* method:     getsunrise()
*******************************************************************************
*
*   gets the date and time of sunrise.  if there is no sunrise, returns null.
*    
* member of sunrisesunset class
*    
* -------------------------------------------------------------------------- */
 public date getsunrise()
 {
  if ( bsunrisetoday )
   return( datesunrise );
  else
   return( null );
 }

/******************************************************************************
* method:     getsunset()
*******************************************************************************
*
*   gets the date and time of sunset.  if there is no sunset, returns null.
*    
* member of sunrisesunset class
*    
* -------------------------------------------------------------------------- */
 public date getsunset()
 {
  if ( bsunsettoday )
   return( datesunset );
  else
   return( null );
 }

/******************************************************************************
* method:     issunrise()
*******************************************************************************
*
*   returns a boolean identifying if there was a sunrise.
*    
* member of sunrisesunset class
*    
* -------------------------------------------------------------------------- */
 public boolean issunrise()
 {
  return( bsunrisetoday );
 }

/******************************************************************************
* method:     issunset()
*******************************************************************************
*
*   returns a boolean identifying if there was a sunset.
*    
* member of sunrisesunset class
*    
* -------------------------------------------------------------------------- */
 public boolean issunset()
 {
  return( bsunsettoday );
 }

/******************************************************************************
* method:     issunup()
*******************************************************************************
*
*   returns a boolean identifying if the sun is up all day.
*    
* member of sunrisesunset class
*    
* -------------------------------------------------------------------------- */
 public boolean issunup()
 {
  return( bsunupallday );
 }

/******************************************************************************
* method:     issundown()
*******************************************************************************
*
*   returns a boolean identifying if the sun is down all day.
*    
* member of sunrisesunset class
*    
* -------------------------------------------------------------------------- */
 public boolean issundown()
 {
  return( bsundownallday );
 }

/******************************************************************************
* method:     isdaytime()
*******************************************************************************
*
*   returns a boolean identifying if it is daytime at the hour contained in
* the date object passed to sunrisesunset on construction.
*    
* member of sunrisesunset class
*    
* -------------------------------------------------------------------------- */
 public boolean isdaytime()
 {
  // determine if it is daytime (at sunrise or later)
  // or nighttime (at sunset or later) at the location of interest
  // but expressed in the time zone requested.
  if ( bsunrisetoday && bsunsettoday )  // sunrise and sunset
  {
   if ( datesunrise.before( datesunset ) ) // sunrise < sunset
   {
    if (
      ( 
      dateinput.after( datesunrise )

      dateinput.equals( datesunrise )
      )
      &&
      dateinput.before( datesunset )
       )
     bdaytime = true;
    else
    bdaytime = false;
    }
   else  // sunrise comes after sunset (in opposite time zones)
   {
    if (
      ( 
      dateinput.after( datesunrise )

      dateinput.equals( datesunrise )
      )
      ||   // use or rather than and
      dateinput.before( datesunset )
       )
     bdaytime = true;
    else
    bdaytime = false;
    }
  }
  else if ( bsunupallday )     // sun is up all day
   bdaytime = true;
  else if ( bsundownallday )    // sun is down all day
   bdaytime = false;
  else if ( bsunrisetoday )     // sunrise but no sunset
  {
   if ( dateinput.before( datesunrise ) )
    bdaytime = false;
   else
    bdaytime = true;
  }
  else if ( bsunsettoday )     // sunset but no sunrise
  {
   if ( dateinput.before( datesunset ) )
    bdaytime = true;
   else
    bdaytime = false;
  }
  else bdaytime = false;     // this should never execute

  return( bdaytime );
 }

} // end of class

/*-----------------------------------------------------------------------------
*       end of class
*----------------------------------------------------------------------------*/