icuSources/i18n/gregoimp.cpp

   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
  25 int32_t ClockMath::floorDivide(int32_t numerator, int32_t denominator) {
  26     return (numerator >= 0) ?
  27         numerator / denominator : ((numerator + 1) / denominator) - 1;
  28 }
  29
  30 int64_t ClockMath::floorDivide(int64_t numerator, int64_t denominator) {
  31     return (numerator >= 0) ?
  32         numerator / denominator : ((numerator + 1) / denominator) - 1;
  33 }
  34
  35 int32_t ClockMath::floorDivide(double numerator, int32_t denominator,
  36                           int32_t& remainder) {
  37     double quotient;
  38     quotient = uprv_floor(numerator / denominator);
  39     remainder = (int32_t) (numerator - (quotient * denominator));
  40     return (int32_t) quotient;
  41 }
  42
  43 double ClockMath::floorDivide(double dividend, double divisor,
  44                          double& remainder) {
  45     // Only designed to work for positive divisors
  46     U_ASSERT(divisor > 0);
  47     double quotient = floorDivide(dividend, divisor);
  48     remainder = dividend - (quotient * divisor);
  49     // N.B. For certain large dividends, on certain platforms, there
  50     // is a bug such that the quotient is off by one.  If you doubt
  51     // this to be true, set a breakpoint below and run cintltst.
  52     if (remainder < 0 || remainder >= divisor) {
  53         // E.g. 6.7317038241449352e+022 / 86400000.0 is wrong on my
  54         // machine (too high by one).  4.1792057231752762e+024 /
  55         // 86400000.0 is wrong the other way (too low).
  56         double q = quotient;
  57         quotient += (remainder < 0) ? -1 : +1;
  58         if (q == quotient) {
  59             // For quotients > ~2^53, we won't be able to add or
  60             // subtract one, since the LSB of the mantissa will be >
  61             // 2^0; that is, the exponent (base 2) will be larger than
  62             // the length, in bits, of the mantissa.  In that case, we
  63             // can't give a correct answer, so we set the remainder to
  64             // zero.  This has the desired effect of making extreme
  65             // values give back an approximate answer rather than
  66             // crashing.  For example, UDate values above a ~10^25
  67             // might all have a time of midnight.
  68             remainder = 0;
  69         } else {
  70             remainder = dividend - (quotient * divisor);
  71         }
  72     }
  73     U_ASSERT(0 <= remainder && remainder < divisor);
  74     return quotient;
  75 }
  76
  77 const int32_t JULIAN_1_CE    = 1721426; // January 1, 1 CE Gregorian
  78 const int32_t JULIAN_1970_CE = 2440588; // January 1, 1970 CE Gregorian
  79
  80 const int16_t Grego::DAYS_BEFORE[24] =
  81     {0,31,59,90,120,151,181,212,243,273,304,334,
  82      0,31,60,91,121,152,182,213,244,274,305,335};
  83
  84 const int8_t Grego::MONTH_LENGTH[24] =
  85     {31,28,31,30,31,30,31,31,30,31,30,31,
  86      31,29,31,30,31,30,31,31,30,31,30,31};
  87
  88 double Grego::fieldsToDay(int32_t year, int32_t month, int32_t dom) {
  89
  90     int32_t y = year - 1;
  91
  92     double julian = 365 * y + ClockMath::floorDivide(y, 4) + (JULIAN_1_CE - 3) + // Julian cal
  93         ClockMath::floorDivide(y, 400) - ClockMath::floorDivide(y, 100) + 2 + // => Gregorian cal
  94         DAYS_BEFORE[month + (isLeapYear(year) ? 12 : 0)] + dom; // => month/dom
  95
  96     return julian - JULIAN_1970_CE; // JD => epoch day
  97 }
  98
  99 void Grego::dayToFields(double day, int32_t& year, int32_t& month,
 100                         int32_t& dom, int32_t& dow, int32_t& doy) {
 101
 102     // Convert from 1970 CE epoch to 1 CE epoch (Gregorian calendar)
 103     day += JULIAN_1970_CE - JULIAN_1_CE;
 104
 105     // Convert from the day number to the multiple radix
 106     // representation.  We use 400-year, 100-year, and 4-year cycles.
 107     // For example, the 4-year cycle has 4 years + 1 leap day; giving
 108     // 1461 == 365*4 + 1 days.
 109     int32_t n400 = ClockMath::floorDivide(day, 146097, doy); // 400-year cycle length
 110     int32_t n100 = ClockMath::floorDivide(doy, 36524, doy); // 100-year cycle length
 111     int32_t n4   = ClockMath::floorDivide(doy, 1461, doy); // 4-year cycle length
 112     int32_t n1   = ClockMath::floorDivide(doy, 365, doy);
 113     year = 400*n400 + 100*n100 + 4*n4 + n1;
 114     if (n100 == 4 || n1 == 4) {
 115         doy = 365; // Dec 31 at end of 4- or 400-year cycle
 116     } else {
 117         ++year;
 118     }
 119
 120     UBool isLeap = isLeapYear(year);
 121
 122     // Gregorian day zero is a Monday.
 123     dow = (int32_t) uprv_fmod(day + 1, 7);
 124     dow += (dow < 0) ? (UCAL_SUNDAY + 7) : UCAL_SUNDAY;
 125
 126     // Common Julian/Gregorian calculation
 127     int32_t correction = 0;
 128     int32_t march1 = isLeap ? 60 : 59; // zero-based DOY for March 1
 129     if (doy >= march1) {
 130         correction = isLeap ? 1 : 2;
 131     }
 132     month = (12 * (doy + correction) + 6) / 367; // zero-based month
 133     dom = doy - DAYS_BEFORE[month + (isLeap ? 12 : 0)] + 1; // one-based DOM
 134     doy++; // one-based doy
 135 }
 136
 137 void Grego::timeToFields(UDate time, int32_t& year, int32_t& month,
 138                         int32_t& dom, int32_t& dow, int32_t& doy, int32_t& mid) {
 139     double millisInDay;
 140     double day = ClockMath::floorDivide((double)time, (double)U_MILLIS_PER_DAY, millisInDay);
 141     mid = (int32_t)millisInDay;
 142     dayToFields(day, year, month, dom, dow, doy);
 143 }
 144
 145 int32_t Grego::dayOfWeek(double day) {
 146     int32_t dow;
 147     ClockMath::floorDivide(day + UCAL_THURSDAY, 7, dow);
 148     return (dow == 0) ? UCAL_SATURDAY : dow;
 149 }
 150
 151 int32_t Grego::dayOfWeekInMonth(int32_t year, int32_t month, int32_t dom) {
 152     int32_t weekInMonth = (dom + 6)/7;
 153     if (weekInMonth == 4) {
 154         if (dom + 7 > monthLength(year, month)) {
 155             weekInMonth = -1;
 156         }
 157     } else if (weekInMonth == 5) {
 158         weekInMonth = -1;
 159     }
 160     return weekInMonth;
 161 }
 162
 163 U_NAMESPACE_END
 164
 165 #endif
 166 //eof