parameters: (n)
return_statement: return year, month, n+1
docstring: ordinal -> (year, month, day), considering 01-Jan-0001 as day 1.
docstring_summary: ordinal -> (year, month, day), considering 01-Jan-0001 as day 1.
docstring_tokens: ordinal - > ( year month day ) considering 01 - Jan - 0001 as day 1 .
function: def _ord2ymd(n):
      "ordinal -> (year, month, day), considering 01-Jan-0001 as day 1."
  
      # n is a 1-based index, starting at 1-Jan-1.  The pattern of leap years
      # repeats exactly every 400 years.  The basic strategy is to find the
      # closest 400-year boundary at or before n, then work with the offset
      # from that boundary to n.  Life is much clearer if we subtract 1 from
      # n first -- then the values of n at 400-year boundaries are exactly
      # those divisible by _DI400Y:
      #
      #     D  M   Y            n              n-1
      #     -- --- ----        ----------     ----------------
      #     31 Dec -400        -_DI400Y       -_DI400Y -1
      #      1 Jan -399         -_DI400Y +1   -_DI400Y      400-year boundary
      #     ...
      #     30 Dec  000        -1             -2
      #     31 Dec  000         0             -1
      #      1 Jan  001         1              0            400-year boundary
      #      2 Jan  001         2              1
      #      3 Jan  001         3              2
      #     ...
      #     31 Dec  400         _DI400Y        _DI400Y -1
      #      1 Jan  401         _DI400Y +1     _DI400Y      400-year boundary
      n -= 1
      n400, n = divmod(n, _DI400Y)
      year = n400 * 400 + 1   # ..., -399, 1, 401, ...
  
      # Now n is the (non-negative) offset, in days, from January 1 of year, to
      # the desired date.  Now compute how many 100-year cycles precede n.
      # Note that it's possible for n100 to equal 4!  In that case 4 full
      # 100-year cycles precede the desired day, which implies the desired
      # day is December 31 at the end of a 400-year cycle.
      n100, n = divmod(n, _DI100Y)
  
      # Now compute how many 4-year cycles precede it.
      n4, n = divmod(n, _DI4Y)
  
      # And now how many single years.  Again n1 can be 4, and again meaning
      # that the desired day is December 31 at the end of the 4-year cycle.
      n1, n = divmod(n, 365)
  
      year += n100 * 100 + n4 * 4 + n1
      if n1 == 4 or n100 == 4:
          assert n == 0
          return year-1, 12, 31
  
      # Now the year is correct, and n is the offset from January 1.  We find
      # the month via an estimate that's either exact or one too large.
      leapyear = n1 == 3 and (n4 != 24 or n100 == 3)
      assert leapyear == _is_leap(year)
      month = (n + 50) >> 5
      preceding = _DAYS_BEFORE_MONTH[month] + (month > 2 and leapyear)
      if preceding > n:  # estimate is too large
          month -= 1
          preceding -= _DAYS_IN_MONTH[month] + (month == 2 and leapyear)
      n -= preceding
      assert 0 <= n < _days_in_month(year, month)
  
      # Now the year and month are correct, and n is the offset from the
      # start of that month:  we're done!
      return year, month, n+1
function_tokens: def _ord2ymd ( n ) : # n is a 1-based index, starting at 1-Jan-1.  The pattern of leap years # repeats exactly every 400 years.  The basic strategy is to find the # closest 400-year boundary at or before n, then work with the offset # from that boundary to n.  Life is much clearer if we subtract 1 from # n first -- then the values of n at 400-year boundaries are exactly # those divisible by _DI400Y: # #     D  M   Y            n              n-1 #     -- --- ----        ----------     ---------------- #     31 Dec -400        -_DI400Y       -_DI400Y -1 #      1 Jan -399         -_DI400Y +1   -_DI400Y      400-year boundary #     ... #     30 Dec  000        -1             -2 #     31 Dec  000         0             -1 #      1 Jan  001         1              0            400-year boundary #      2 Jan  001         2              1 #      3 Jan  001         3              2 #     ... #     31 Dec  400         _DI400Y        _DI400Y -1 #      1 Jan  401         _DI400Y +1     _DI400Y      400-year boundary n -= 1 n400 , n = divmod ( n , _DI400Y ) year = n400 * 400 + 1 # ..., -399, 1, 401, ... # Now n is the (non-negative) offset, in days, from January 1 of year, to # the desired date.  Now compute how many 100-year cycles precede n. # Note that it's possible for n100 to equal 4!  In that case 4 full # 100-year cycles precede the desired day, which implies the desired # day is December 31 at the end of a 400-year cycle. n100 , n = divmod ( n , _DI100Y ) # Now compute how many 4-year cycles precede it. n4 , n = divmod ( n , _DI4Y ) # And now how many single years.  Again n1 can be 4, and again meaning # that the desired day is December 31 at the end of the 4-year cycle. n1 , n = divmod ( n , 365 ) year += n100 * 100 + n4 * 4 + n1 if n1 == 4 or n100 == 4 : assert n == 0 return year - 1 , 12 , 31 # Now the year is correct, and n is the offset from January 1.  We find # the month via an estimate that's either exact or one too large. leapyear = n1 == 3 and ( n4 != 24 or n100 == 3 ) assert leapyear == _is_leap ( year ) month = ( n + 50 ) >> 5 preceding = _DAYS_BEFORE_MONTH [ month ] + ( month > 2 and leapyear ) if preceding > n : # estimate is too large month -= 1 preceding -= _DAYS_IN_MONTH [ month ] + ( month == 2 and leapyear ) n -= preceding assert 0 <= n < _days_in_month ( year , month ) # Now the year and month are correct, and n is the offset from the # start of that month:  we're done! return year , month , n + 1