1 // © 2016 and later: Unicode, Inc. and others.
2 // License & terms of use: http://www.unicode.org/copyright.html
3 /*
4 **********************************************************************
5 * Copyright (c) 2003-2008, International Business Machines
6 * Corporation and others. All Rights Reserved.
7 **********************************************************************
8 * Author: Alan Liu
9 * Created: September 2 2003
10 * Since: ICU 2.8
11 **********************************************************************
12 */
13
14 #include "gregoimp.h"
15
16 #if !UCONFIG_NO_FORMATTING
17
18 #include "unicode/ucal.h"
19 #include "uresimp.h"
20 #include "cstring.h"
21 #include "uassert.h"
22
23 U_NAMESPACE_BEGIN
24
floorDivide(int32_t numerator,int32_t denominator)25 int32_t ClockMath::floorDivide(int32_t numerator, int32_t denominator) {
26 return (numerator >= 0) ?
27 numerator / denominator : ((numerator + 1) / denominator) - 1;
28 }
29
floorDivide(int64_t numerator,int64_t denominator)30 int64_t ClockMath::floorDivide(int64_t numerator, int64_t denominator) {
31 return (numerator >= 0) ?
32 numerator / denominator : ((numerator + 1) / denominator) - 1;
33 }
34
floorDivide(double numerator,int32_t denominator,int32_t * remainder)35 int32_t ClockMath::floorDivide(double numerator, int32_t denominator,
36 int32_t* remainder) {
37 // For an integer n and representable ⌊x/n⌋, ⌊RN(x/n)⌋=⌊x/n⌋, where RN is
38 // rounding to nearest.
39 double quotient = uprv_floor(numerator / denominator);
40 // For doubles x and n, where n is an integer and ⌊x+n⌋ < 2³¹, the
41 // expression `(int32_t) (x + n)` evaluated with rounding to nearest
42 // differs from ⌊x+n⌋ if 0 < ⌈x⌉−x ≪ x+n, as `x + n` is rounded up to
43 // n+⌈x⌉ = ⌊x+n⌋ + 1. Rewriting it as ⌊x⌋+n makes the addition exact.
44 *remainder = (int32_t) (uprv_floor(numerator) - (quotient * denominator));
45 return (int32_t) quotient;
46 }
47
floorDivide(double dividend,double divisor,double * remainder)48 double ClockMath::floorDivide(double dividend, double divisor,
49 double* remainder) {
50 // Only designed to work for positive divisors
51 U_ASSERT(divisor > 0);
52 double quotient = floorDivide(dividend, divisor);
53 *remainder = dividend - (quotient * divisor);
54 // N.B. For certain large dividends, on certain platforms, there
55 // is a bug such that the quotient is off by one. If you doubt
56 // this to be true, set a breakpoint below and run cintltst.
57 if (*remainder < 0 || *remainder >= divisor) {
58 // E.g. 6.7317038241449352e+022 / 86400000.0 is wrong on my
59 // machine (too high by one). 4.1792057231752762e+024 /
60 // 86400000.0 is wrong the other way (too low).
61 double q = quotient;
62 quotient += (*remainder < 0) ? -1 : +1;
63 if (q == quotient) {
64 // For quotients > ~2^53, we won't be able to add or
65 // subtract one, since the LSB of the mantissa will be >
66 // 2^0; that is, the exponent (base 2) will be larger than
67 // the length, in bits, of the mantissa. In that case, we
68 // can't give a correct answer, so we set the remainder to
69 // zero. This has the desired effect of making extreme
70 // values give back an approximate answer rather than
71 // crashing. For example, UDate values above a ~10^25
72 // might all have a time of midnight.
73 *remainder = 0;
74 } else {
75 *remainder = dividend - (quotient * divisor);
76 }
77 }
78 U_ASSERT(0 <= *remainder && *remainder < divisor);
79 return quotient;
80 }
81
82 const int32_t JULIAN_1_CE = 1721426; // January 1, 1 CE Gregorian
83 const int32_t JULIAN_1970_CE = 2440588; // January 1, 1970 CE Gregorian
84
85 const int16_t Grego::DAYS_BEFORE[24] =
86 {0,31,59,90,120,151,181,212,243,273,304,334,
87 0,31,60,91,121,152,182,213,244,274,305,335};
88
89 const int8_t Grego::MONTH_LENGTH[24] =
90 {31,28,31,30,31,30,31,31,30,31,30,31,
91 31,29,31,30,31,30,31,31,30,31,30,31};
92
fieldsToDay(int32_t year,int32_t month,int32_t dom)93 double Grego::fieldsToDay(int32_t year, int32_t month, int32_t dom) {
94
95 int32_t y = year - 1;
96
97 double julian = 365 * y + ClockMath::floorDivide(y, 4) + (JULIAN_1_CE - 3) + // Julian cal
98 ClockMath::floorDivide(y, 400) - ClockMath::floorDivide(y, 100) + 2 + // => Gregorian cal
99 DAYS_BEFORE[month + (isLeapYear(year) ? 12 : 0)] + dom; // => month/dom
100
101 return julian - JULIAN_1970_CE; // JD => epoch day
102 }
103
dayToFields(double day,int32_t & year,int32_t & month,int32_t & dom,int32_t & dow,int32_t & doy)104 void Grego::dayToFields(double day, int32_t& year, int32_t& month,
105 int32_t& dom, int32_t& dow, int32_t& doy) {
106
107 // Convert from 1970 CE epoch to 1 CE epoch (Gregorian calendar)
108 day += JULIAN_1970_CE - JULIAN_1_CE;
109
110 // Convert from the day number to the multiple radix
111 // representation. We use 400-year, 100-year, and 4-year cycles.
112 // For example, the 4-year cycle has 4 years + 1 leap day; giving
113 // 1461 == 365*4 + 1 days.
114 int32_t n400 = ClockMath::floorDivide(day, 146097, &doy); // 400-year cycle length
115 int32_t n100 = ClockMath::floorDivide(doy, 36524, &doy); // 100-year cycle length
116 int32_t n4 = ClockMath::floorDivide(doy, 1461, &doy); // 4-year cycle length
117 int32_t n1 = ClockMath::floorDivide(doy, 365, &doy);
118 year = 400*n400 + 100*n100 + 4*n4 + n1;
119 if (n100 == 4 || n1 == 4) {
120 doy = 365; // Dec 31 at end of 4- or 400-year cycle
121 } else {
122 ++year;
123 }
124
125 UBool isLeap = isLeapYear(year);
126
127 // Gregorian day zero is a Monday.
128 dow = (int32_t) uprv_fmod(day + 1, 7);
129 dow += (dow < 0) ? (UCAL_SUNDAY + 7) : UCAL_SUNDAY;
130
131 // Common Julian/Gregorian calculation
132 int32_t correction = 0;
133 int32_t march1 = isLeap ? 60 : 59; // zero-based DOY for March 1
134 if (doy >= march1) {
135 correction = isLeap ? 1 : 2;
136 }
137 month = (12 * (doy + correction) + 6) / 367; // zero-based month
138 dom = doy - DAYS_BEFORE[month + (isLeap ? 12 : 0)] + 1; // one-based DOM
139 doy++; // one-based doy
140 }
141
timeToFields(UDate time,int32_t & year,int32_t & month,int32_t & dom,int32_t & dow,int32_t & doy,int32_t & mid)142 void Grego::timeToFields(UDate time, int32_t& year, int32_t& month,
143 int32_t& dom, int32_t& dow, int32_t& doy, int32_t& mid) {
144 double millisInDay;
145 double day = ClockMath::floorDivide((double)time, (double)U_MILLIS_PER_DAY, &millisInDay);
146 mid = (int32_t)millisInDay;
147 dayToFields(day, year, month, dom, dow, doy);
148 }
149
dayOfWeek(double day)150 int32_t Grego::dayOfWeek(double day) {
151 int32_t dow;
152 ClockMath::floorDivide(day + int{UCAL_THURSDAY}, 7, &dow);
153 return (dow == 0) ? UCAL_SATURDAY : dow;
154 }
155
dayOfWeekInMonth(int32_t year,int32_t month,int32_t dom)156 int32_t Grego::dayOfWeekInMonth(int32_t year, int32_t month, int32_t dom) {
157 int32_t weekInMonth = (dom + 6)/7;
158 if (weekInMonth == 4) {
159 if (dom + 7 > monthLength(year, month)) {
160 weekInMonth = -1;
161 }
162 } else if (weekInMonth == 5) {
163 weekInMonth = -1;
164 }
165 return weekInMonth;
166 }
167
168 U_NAMESPACE_END
169
170 #endif
171 //eof
172