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 } 331