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#ifndef GREGOIMP_H
15#define GREGOIMP_H
16#include "unicode/utypes.h"
17#if !UCONFIG_NO_FORMATTING
18
19#include "unicode/ures.h"
20#include "unicode/locid.h"
21#include "putilimp.h"
22
23U_NAMESPACE_BEGIN
24
25/**
26 * A utility class providing mathematical functions used by time zone
27 * and calendar code. Do not instantiate. Formerly just named 'Math'.
28 * @internal
29 */
30class ClockMath {
31 public:
32 /**
33 * Divide two integers, returning the floor of the quotient.
34 * Unlike the built-in division, this is mathematically
35 * well-behaved. E.g., <code>-1/4</code> => 0 but
36 * <code>floorDivide(-1,4)</code> => -1.
37 * @param numerator the numerator
38 * @param denominator a divisor which must be != 0
39 * @return the floor of the quotient
40 */
41 static int32_t floorDivide(int32_t numerator, int32_t denominator);
42
43 /**
44 * Divide two integers, returning the floor of the quotient.
45 * Unlike the built-in division, this is mathematically
46 * well-behaved. E.g., <code>-1/4</code> => 0 but
47 * <code>floorDivide(-1,4)</code> => -1.
48 * @param numerator the numerator
49 * @param denominator a divisor which must be != 0
50 * @return the floor of the quotient
51 */
52 static int64_t floorDivide(int64_t numerator, int64_t denominator);
53
54 /**
55 * Divide two numbers, returning the floor of the quotient.
56 * Unlike the built-in division, this is mathematically
57 * well-behaved. E.g., <code>-1/4</code> => 0 but
58 * <code>floorDivide(-1,4)</code> => -1.
59 * @param numerator the numerator
60 * @param denominator a divisor which must be != 0
61 * @return the floor of the quotient
62 */
63 static inline double floorDivide(double numerator, double denominator);
64
65 /**
66 * Divide two numbers, returning the floor of the quotient and
67 * the modulus remainder. Unlike the built-in division, this is
68 * mathematically well-behaved. E.g., <code>-1/4</code> => 0 and
69 * <code>-1%4</code> => -1, but <code>floorDivide(-1,4)</code> =>
70 * -1 with <code>remainder</code> => 3. NOTE: If numerator is
71 * too large, the returned quotient may overflow.
72 * @param numerator the numerator
73 * @param denominator a divisor which must be != 0
74 * @param remainder output parameter to receive the
75 * remainder. Unlike <code>numerator % denominator</code>, this
76 * will always be non-negative, in the half-open range <code>[0,
77 * |denominator|)</code>.
78 * @return the floor of the quotient
79 */
80 static int32_t floorDivide(double numerator, int32_t denominator,
81 int32_t& remainder);
82
83 /**
84 * For a positive divisor, return the quotient and remainder
85 * such that dividend = quotient*divisor + remainder and
86 * 0 <= remainder < divisor.
87 *
88 * Works around edge-case bugs. Handles pathological input
89 * (divident >> divisor) reasonably.
90 *
91 * Calling with a divisor <= 0 is disallowed.
92 */
93 static double floorDivide(double dividend, double divisor,
94 double& remainder);
95};
96
97// Useful millisecond constants
98#define kOneDay (1.0 * U_MILLIS_PER_DAY) // 86,400,000
99#define kOneHour (60*60*1000)
100#define kOneMinute 60000
101#define kOneSecond 1000
102#define kOneMillisecond 1
103#define kOneWeek (7.0 * kOneDay) // 604,800,000
104
105// Epoch constants
106#define kJan1_1JulianDay 1721426 // January 1, year 1 (Gregorian)
107
108#define kEpochStartAsJulianDay 2440588 // January 1, 1970 (Gregorian)
109
110#define kEpochYear 1970
111
112
113#define kEarliestViableMillis -185331720384000000.0 // minimum representable by julian day -1e17
114
115#define kLatestViableMillis 185753453990400000.0 // max representable by julian day +1e17
116
117/**
118 * The minimum supported Julian day. This value is equivalent to
119 * MIN_MILLIS.
120 */
121#define MIN_JULIAN (-0x7F000000)
122
123/**
124 * The minimum supported epoch milliseconds. This value is equivalent
125 * to MIN_JULIAN.
126 */
127#define MIN_MILLIS ((MIN_JULIAN - kEpochStartAsJulianDay) * kOneDay)
128
129/**
130 * The maximum supported Julian day. This value is equivalent to
131 * MAX_MILLIS.
132 */
133#define MAX_JULIAN (+0x7F000000)
134
135/**
136 * The maximum supported epoch milliseconds. This value is equivalent
137 * to MAX_JULIAN.
138 */
139#define MAX_MILLIS ((MAX_JULIAN - kEpochStartAsJulianDay) * kOneDay)
140
141/**
142 * A utility class providing proleptic Gregorian calendar functions
143 * used by time zone and calendar code. Do not instantiate.
144 *
145 * Note: Unlike GregorianCalendar, all computations performed by this
146 * class occur in the pure proleptic GregorianCalendar.
147 */
148class Grego {
149 public:
150 /**
151 * Return TRUE if the given year is a leap year.
152 * @param year Gregorian year, with 0 == 1 BCE, -1 == 2 BCE, etc.
153 * @return TRUE if the year is a leap year
154 */
155 static inline UBool isLeapYear(int32_t year);
156
157 /**
158 * Return the number of days in the given month.
159 * @param year Gregorian year, with 0 == 1 BCE, -1 == 2 BCE, etc.
160 * @param month 0-based month, with 0==Jan
161 * @return the number of days in the given month
162 */
163 static inline int8_t monthLength(int32_t year, int32_t month);
164
165 /**
166 * Return the length of a previous month of the Gregorian calendar.
167 * @param y the extended year
168 * @param m the 0-based month number
169 * @return the number of days in the month previous to the given month
170 */
171 static inline int8_t previousMonthLength(int y, int m);
172
173 /**
174 * Convert a year, month, and day-of-month, given in the proleptic
175 * Gregorian calendar, to 1970 epoch days.
176 * @param year Gregorian year, with 0 == 1 BCE, -1 == 2 BCE, etc.
177 * @param month 0-based month, with 0==Jan
178 * @param dom 1-based day of month
179 * @return the day number, with day 0 == Jan 1 1970
180 */
181 static double fieldsToDay(int32_t year, int32_t month, int32_t dom);
182
183 /**
184 * Convert a 1970-epoch day number to proleptic Gregorian year,
185 * month, day-of-month, and day-of-week.
186 * @param day 1970-epoch day (integral value)
187 * @param year output parameter to receive year
188 * @param month output parameter to receive month (0-based, 0==Jan)
189 * @param dom output parameter to receive day-of-month (1-based)
190 * @param dow output parameter to receive day-of-week (1-based, 1==Sun)
191 * @param doy output parameter to receive day-of-year (1-based)
192 */
193 static void dayToFields(double day, int32_t& year, int32_t& month,
194 int32_t& dom, int32_t& dow, int32_t& doy);
195
196 /**
197 * Convert a 1970-epoch day number to proleptic Gregorian year,
198 * month, day-of-month, and day-of-week.
199 * @param day 1970-epoch day (integral value)
200 * @param year output parameter to receive year
201 * @param month output parameter to receive month (0-based, 0==Jan)
202 * @param dom output parameter to receive day-of-month (1-based)
203 * @param dow output parameter to receive day-of-week (1-based, 1==Sun)
204 */
205 static inline void dayToFields(double day, int32_t& year, int32_t& month,
206 int32_t& dom, int32_t& dow);
207
208 /**
209 * Convert a 1970-epoch milliseconds to proleptic Gregorian year,
210 * month, day-of-month, and day-of-week, day of year and millis-in-day.
211 * @param time 1970-epoch milliseconds
212 * @param year output parameter to receive year
213 * @param month output parameter to receive month (0-based, 0==Jan)
214 * @param dom output parameter to receive day-of-month (1-based)
215 * @param dow output parameter to receive day-of-week (1-based, 1==Sun)
216 * @param doy output parameter to receive day-of-year (1-based)
217 * @param mid output parameter to recieve millis-in-day
218 */
219 static void timeToFields(UDate time, int32_t& year, int32_t& month,
220 int32_t& dom, int32_t& dow, int32_t& doy, int32_t& mid);
221
222 /**
223 * Return the day of week on the 1970-epoch day
224 * @param day the 1970-epoch day (integral value)
225 * @return the day of week
226 */
227 static int32_t dayOfWeek(double day);
228
229 /**
230 * Returns the ordinal number for the specified day of week within the month.
231 * The valid return value is 1, 2, 3, 4 or -1.
232 * @param year Gregorian year, with 0 == 1 BCE, -1 == 2 BCE, etc.
233 * @param month 0-based month, with 0==Jan
234 * @param dom 1-based day of month
235 * @return The ordinal number for the specified day of week within the month
236 */
237 static int32_t dayOfWeekInMonth(int32_t year, int32_t month, int32_t dom);
238
239 /**
240 * Converts Julian day to time as milliseconds.
241 * @param julian the given Julian day number.
242 * @return time as milliseconds.
243 * @internal
244 */
245 static inline double julianDayToMillis(int32_t julian);
246
247 /**
248 * Converts time as milliseconds to Julian day.
249 * @param millis the given milliseconds.
250 * @return the Julian day number.
251 * @internal
252 */
253 static inline int32_t millisToJulianDay(double millis);
254
255 /**
256 * Calculates the Gregorian day shift value for an extended year.
257 * @param eyear Extended year
258 * @returns number of days to ADD to Julian in order to convert from J->G
259 */
260 static inline int32_t gregorianShift(int32_t eyear);
261
262 private:
263 static const int16_t DAYS_BEFORE[24];
264 static const int8_t MONTH_LENGTH[24];
265};
266
267inline double ClockMath::floorDivide(double numerator, double denominator) {
268 return uprv_floor(numerator / denominator);
269}
270
271inline UBool Grego::isLeapYear(int32_t year) {
272 // year&0x3 == year%4
273 return ((year&0x3) == 0) && ((year%100 != 0) || (year%400 == 0));
274}
275
276inline int8_t
277Grego::monthLength(int32_t year, int32_t month) {
278 return MONTH_LENGTH[month + (isLeapYear(year) ? 12 : 0)];
279}
280
281inline int8_t
282Grego::previousMonthLength(int y, int m) {
283 return (m > 0) ? monthLength(y, m-1) : 31;
284}
285
286inline void Grego::dayToFields(double day, int32_t& year, int32_t& month,
287 int32_t& dom, int32_t& dow) {
288 int32_t doy_unused;
289 dayToFields(day,year,month,dom,dow,doy_unused);
290}
291
292inline double Grego::julianDayToMillis(int32_t julian)
293{
294 return (julian - kEpochStartAsJulianDay) * kOneDay;
295}
296
297inline int32_t Grego::millisToJulianDay(double millis) {
298 return (int32_t) (kEpochStartAsJulianDay + ClockMath::floorDivide(millis, (double)kOneDay));
299}
300
301inline int32_t Grego::gregorianShift(int32_t eyear) {
302 int64_t y = (int64_t)eyear-1;
303 int32_t gregShift = static_cast<int32_t>(ClockMath::floorDivide(y, (int64_t)400) - ClockMath::floorDivide(y, (int64_t)100) + 2);
304 return gregShift;
305}
306
307U_NAMESPACE_END
308
309#endif // !UCONFIG_NO_FORMATTING
310#endif // GREGOIMP_H
311
312//eof
313