lib/libcalendar/calendar.c

   1 /*-
   2  * Copyright (c) 1997 Wolfgang Helbig
   3  * All rights reserved.
   4  *
   5  * Redistribution and use in source and binary forms, with or without
   6  * modification, are permitted provided that the following conditions
   7  * are met:
   8  * 1. Redistributions of source code must retain the above copyright
   9  *    notice, this list of conditions and the following disclaimer.
  10  * 2. Redistributions in binary form must reproduce the above copyright
  11  *    notice, this list of conditions and the following disclaimer in the
  12  *    documentation and/or other materials provided with the distribution.
  13  *
  14  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  15  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  16  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  17  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
  18  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  19  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  20  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  21  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  22  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  23  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  24  * SUCH DAMAGE.
  25  *
  26  * $FreeBSD: src/lib/libcalendar/calendar.c,v 1.3 1999/08/28 00:04:03 peter Exp $
  27  * $DragonFly: src/lib/libcalendar/calendar.c,v 1.2 2003/06/17 04:26:48 dillon Exp $
  28  */
  29
  30 #include "calendar.h"
  31
  32 #ifndef NULL
  33 #define NULL 0
  34 #endif
  35
  36 /*
  37  * For each month tabulate the number of days elapsed in a year before the
  38  * month. This assumes the internal date representation, where a year
  39  * starts on March 1st. So we don't need a special table for leap years.
  40  * But we do need a special table for the year 1582, since 10 days are
  41  * deleted in October. This is month1s for the switch from Julian to
  42  * Gregorian calendar.
  43  */
  44 static int const month1[] =
  45     {0, 31, 61, 92, 122, 153, 184, 214, 245, 275, 306, 337};
  46    /*  M   A   M   J    J    A    S    O    N    D    J */
  47 static int const month1s[]=
  48     {0, 31, 61, 92, 122, 153, 184, 214, 235, 265, 296, 327};
  49
  50 typedef struct date date;
  51
  52 /* The last day of Julian calendar, in internal and ndays representation */
  53 static int nswitch;     /* The last day of Julian calendar */
  54 static date jiswitch = {1582, 7, 3};
  55
  56 static date     *date2idt(date *idt, date *dt);
  57 static date     *idt2date(date *dt, date *idt);
  58 static int       ndaysji(date *idt);
  59 static int       ndaysgi(date *idt);
  60 static int       firstweek(int year);
  61
  62 /*
  63  * Compute the Julian date from the number of days elapsed since
  64  * March 1st of year zero.
  65  */
  66 date *
  67 jdate(int ndays, date *dt)
  68 {
  69         date    idt;            /* Internal date representation */
  70         int     r;              /* hold the rest of days */
  71
  72         /*
  73          * Compute the year by starting with an approximation not smaller
  74          * than the answer and using linear search for the greatest
  75          * year which does not begin after ndays.
  76          */
  77         idt.y = ndays / 365;
  78         idt.m = 0;
  79         idt.d = 0;
  80         while ((r = ndaysji(&idt)) > ndays)
  81                 idt.y--;
  82
  83         /*
  84          * Set r to the days left in the year and compute the month by
  85          * linear search as the largest month that does not begin after r
  86          * days.
  87          */
  88         r = ndays - r;
  89         for (idt.m = 11; month1[idt.m] > r; idt.m--)
  90                 ;
  91
  92         /* Compute the days left in the month */
  93         idt.d = r - month1[idt.m];
  94
  95         /* return external representation of the date */
  96         return (idt2date(dt, &idt));
  97 }
  98
  99 /*
 100  * Return the number of days since March 1st of the year zero.
 101  * The date is given according to Julian calendar.
 102  */
 103 int
 104 ndaysj(date *dt)
 105 {
 106         date    idt;            /* Internal date representation */
 107
 108         if (date2idt(&idt, dt) == NULL)
 109                 return (-1);
 110         else
 111                 return (ndaysji(&idt));
 112 }
 113
 114 /*
 115  * Same as above, where the Julian date is given in internal notation.
 116  * This formula shows the beauty of this notation.
 117  */
 118 static int
 119 ndaysji(date * idt)
 120 {
 121
 122         return (idt->d + month1[idt->m] + idt->y * 365 + idt->y / 4);
 123 }
 124
 125 /*
 126  * Compute the date according to the Gregorian calendar from the number of
 127  * days since March 1st, year zero. The date computed will be Julian if it
 128  * is older than 1582-10-05. This is the reverse of the function ndaysg().
 129  */
 130 date   *
 131 gdate(int ndays, date *dt)
 132 {
 133         int const *montht;      /* month-table */
 134         date    idt;            /* for internal date representation */
 135         int     r;              /* holds the rest of days */
 136
 137         /*
 138          * Compute the year by starting with an approximation not smaller
 139          * than the answer and search linearly for the greatest year not
 140          * starting after ndays.
 141          */
 142         idt.y = ndays / 365;
 143         idt.m = 0;
 144         idt.d = 0;
 145         while ((r = ndaysgi(&idt)) > ndays)
 146                 idt.y--;
 147
 148         /*
 149          * Set ndays to the number of days left and compute by linear
 150          * search the greatest month which does not start after ndays. We
 151          * use the table month1 which provides for each month the number
 152          * of days that elapsed in the year before that month. Here the
 153          * year 1582 is special, as 10 days are left out in October to
 154          * resynchronize the calendar with the earth's orbit. October 4th
 155          * 1582 is followed by October 15th 1582. We use the "switch"
 156          * table month1s for this year.
 157          */
 158         ndays = ndays - r;
 159         if (idt.y == 1582)
 160                 montht = month1s;
 161         else
 162                 montht = month1;
 163
 164         for (idt.m = 11; montht[idt.m] > ndays; idt.m--)
 165                 ;
 166
 167         idt.d = ndays - montht[idt.m]; /* the rest is the day in month */
 168
 169         /* Advance ten days deleted from October if after switch in Oct 1582 */
 170         if (idt.y == jiswitch.y && idt.m == jiswitch.m && jiswitch.d < idt.d)
 171                 idt.d += 10;
 172
 173         /* return external representation of found date */
 174         return (idt2date(dt, &idt));
 175 }
 176
 177 /*
 178  * Return the number of days since March 1st of the year zero. The date is
 179  * assumed Gregorian if younger than 1582-10-04 and Julian otherwise. This
 180  * is the reverse of gdate.
 181  */
 182 int
 183 ndaysg(date *dt)
 184 {
 185         date    idt;            /* Internal date representation */
 186
 187         if (date2idt(&idt, dt) == NULL)
 188                 return (-1);
 189         return (ndaysgi(&idt));
 190 }
 191
 192 /*
 193  * Same as above, but with the Gregorian date given in internal
 194  * representation.
 195  */
 196 static int
 197 ndaysgi(date *idt)
 198 {
 199         int     nd;             /* Number of days--return value */
 200
 201         /* Cache nswitch if not already done */
 202         if (nswitch == 0)
 203                 nswitch = ndaysji(&jiswitch);
 204
 205         /*
 206          * Assume Julian calendar and adapt to Gregorian if necessary, i. e.
 207          * younger than nswitch. Gregori deleted
 208          * the ten days from Oct 5th to Oct 14th 1582.
 209          * Thereafter years which are multiples of 100 and not multiples
 210          * of 400 were not leap years anymore.
 211          * This makes the average length of a year
 212          * 365d +.25d - .01d + .0025d = 365.2425d. But the tropical
 213          * year measures 365.2422d. So in 10000/3 years we are
 214          * again one day ahead of the earth. Sigh :-)
 215          * (d is the average length of a day and tropical year is the
 216          * time from one spring point to the next.)
 217          */
 218         if ((nd = ndaysji(idt)) == -1)
 219                 return (-1);
 220         if (idt->y >= 1600)
 221                 nd = (nd - 10 - (idt->y - 1600) / 100 + (idt->y - 1600) / 400);
 222         else if (nd > nswitch)
 223                 nd -= 10;
 224         return (nd);
 225 }
 226
 227 /*
 228  * Compute the week number from the number of days since March 1st year 0.
 229  * The weeks are numbered per year starting with 1. If the first
 230  * week of a year includes at least four days of that year it is week 1,
 231  * otherwise it gets the number of the last week of the previous year.
 232  * The variable y will be filled with the year that contains the greater
 233  * part of the week.
 234  */
 235 int
 236 week(int nd, int *y)
 237 {
 238         date    dt;
 239         int     fw;             /* 1st day of week 1 of previous, this and
 240                                  * next year */
 241         gdate(nd, &dt);
 242         for (*y = dt.y + 1; nd < (fw = firstweek(*y)); (*y)--)
 243                 ;
 244         return ((nd - fw) / 7 + 1);
 245 }
 246
 247 /* return the first day of week 1 of year y */
 248 static int
 249 firstweek(int y)
 250 {
 251         date idt;
 252         int nd, wd;
 253
 254         idt.y = y - 1;   /* internal representation of y-1-1 */
 255         idt.m = 10;
 256         idt.d = 0;
 257
 258         nd = ndaysgi(&idt);
 259         /*
 260          * If more than 3 days of this week are in the preceding year, the
 261          * next week is week 1 (and the next monday is the answer),
 262          * otherwise this week is week 1 and the last monday is the
 263          * answer.
 264          */
 265         if ((wd = weekday(nd)) > 3)
 266                 return (nd - wd + 7);
 267         else
 268                 return (nd - wd);
 269 }
 270
 271 /* return the weekday (Mo = 0 .. Su = 6) */
 272 int
 273 weekday(int nd)
 274 {
 275         date dmondaygi = {1997, 8, 16}; /* Internal repr. of 1997-11-17 */
 276         static int nmonday;             /* ... which is a monday        */
 277
 278         /* Cache the daynumber of one monday */
 279         if (nmonday == 0)
 280                 nmonday = ndaysgi(&dmondaygi);
 281
 282         /* return (nd - nmonday) modulo 7 which is the weekday */
 283         nd = (nd - nmonday) % 7;
 284         if (nd < 0)
 285                 return (nd + 7);
 286         else
 287                 return (nd);
 288 }
 289
 290 /*
 291  * Convert a date to internal date representation: The year starts on
 292  * March 1st, month and day numbering start at zero. E. g. March 1st of
 293  * year zero is written as y=0, m=0, d=0.
 294  */
 295 static date *
 296 date2idt(date *idt, date *dt)
 297 {
 298
 299         idt->d = dt->d - 1;
 300         if (dt->m > 2) {
 301                 idt->m = dt->m - 3;
 302                 idt->y = dt->y;
 303         } else {
 304                 idt->m = dt->m + 9;
 305                 idt->y = dt->y - 1;
 306         }
 307         if (idt->m < 0 || idt->m > 11 || idt->y < 0)
 308                 return (NULL);
 309         else
 310                 return idt;
 311 }
 312
 313 /* Reverse of date2idt */
 314 static date *
 315 idt2date(date *dt, date *idt)
 316 {
 317
 318         dt->d = idt->d + 1;
 319         if (idt->m < 10) {
 320                 dt->m = idt->m + 3;
 321                 dt->y = idt->y;
 322         } else {
 323                 dt->m = idt->m - 9;
 324                 dt->y = idt->y + 1;
 325         }
 326         if (dt->m < 1)
 327                 return (NULL);
 328         else
 329                 return (dt);
 330 }