3c: Urbit Time

    ++yall

    Time since beginning of time

    Produce the date tuple of [y=@ud m=@ud d=@ud] of the year, month, and day from a number of days from the beginning of the Gregorian calendar.

    Accepts

    day is a an unsigned decimal.

    Produces

    A cell of unsigned decimals.

    Source

        ++  yall
          |=  day=@ud
          ^-  [y=@ud m=@ud d=@ud]
          =+  [era=0 cet=0 lep=*?]
          =>  .(era (div day era:yo), day (mod day era:yo))
          =>  ^+  .
              ?:  (lth day +(cet:yo))
                .(lep &, cet 0)
              =>  .(lep |, cet 1, day (sub day +(cet:yo)))
              .(cet (add cet (div day cet:yo)), day (mod day cet:yo))
          =+  yer=(add (mul 400 era) (mul 100 cet))
          |-  ^-  [y=@ud m=@ud d=@ud]
          =+  dis=?:(lep 366 365)
          ?.  (lth day dis)
            =+  ner=+(yer)
            $(yer ner, day (sub day dis), lep =(0 (end 0 2 ner)))
          |-  ^-  [y=@ud m=@ud d=@ud]
          =+  [mot=0 cah=?:(lep moy:yo moh:yo)]
          |-  ^-  [y=@ud m=@ud d=@ud]
          =+  zis=(snag mot cah)
          ?:  (lth day zis)
            [yer +(mot) +(day)]
          $(mot +(mot), day (sub day zis))
    

    Examples

        > (yall 198)
        [y=0 m=7 d=17]
    
        > (yall 90.398)
        [y=247 m=7 d=3]
    
        > (yall 0)
        [y=0 m=1 d=1]
    

    ++yawn

    Days since beginning of time

    Inverse of yall, computes number of days A.D. from y/m/d date as the tuple [yer=@ud mot=@ud day=@ud].

    Accepts

    yer is an unsigned decimal.

    mon is an unsigned decimal.

    day is an unsigned decimal.

    Produces

    An unsigned decimal.

    Source

        ++  yawn
          |=  [yer=@ud mot=@ud day=@ud]
          ^-  @ud
          =>  .(mot (dec mot), day (dec day))
          =>  ^+  .
              %=    .
                  day
                =+  cah=?:((yelp yer) moy:yo moh:yo)
                |-  ^-  @ud
                ?:  =(0 mot)
                  day
                $(mot (dec mot), cah (slag 1 cah), day (add day (snag 0 cah)))
              ==
          |-  ^-  @ud
          ?.  =(0 (mod yer 4))
            =+  ney=(dec yer)
            $(yer ney, day (add day ?:((yelp ney) 366 365)))
          ?.  =(0 (mod yer 100))
            =+  nef=(sub yer 4)
            $(yer nef, day (add day ?:((yelp nef) 1.461 1.460)))
          ?.  =(0 (mod yer 400))
            =+  nec=(sub yer 100)
            $(yer nec, day (add day ?:((yelp nec) 36.525 36.524)))
          (add day (mul (div yer 400) (add 1 (mul 4 36.524))))
    

    Examples

        > (yawn 2.018 7 4)
        737.244
    
        > (yawn 1.776 7 4)
        648.856
    
        > (yawn 1.990 10 11)
        727.116
    

    ++year

    Date to @d

    Accept a parsed date of form [[a=? y=@ud] m=@ud t=tarp] and produce its @d representation.

    Accepts

    det is a date

    Produces

    A @d.

    Source

        ++  year
          |=  det=date
          ^-  @da
          =+  ^=  yer
              ?:  a.det
                (add 292.277.024.400 y.det)
              (sub 292.277.024.400 (dec y.det))
          =+  day=(yawn yer m.det d.t.det)
          (yule day h.t.det m.t.det s.t.det f.t.det)
    

    Examples

        > (year [[a=%.y y=2.014] m=8 t=[d=4 h=20 m=4 s=57 f=~[0xd940]]])
        0x8000000d227df4e9d940000000000000
    

    ++yell

    Tarp from atomic date

    Produce a parsed daily time format from, @d, an atomic date.

    Accepts

    now is a @d.

    Produces

    A tarp.

    Source

        ++  yell
          |=  now=@d
          ^-  tarp
          =+  sec=(rsh 6 1 now)
          =+  ^=  fan
              =+  [muc=4 raw=(end 6 1 now)]
              |-  ^-  (list @ux)
              ?:  |(=(0 raw) =(0 muc))
                ~
              =>  .(muc (dec muc))
              [(cut 4 [muc 1] raw) $(raw (end 4 muc raw))]
          =+  day=(div sec day:yo)
          =>  .(sec (mod sec day:yo))
          =+  hor=(div sec hor:yo)
          =>  .(sec (mod sec hor:yo))
          =+  mit=(div sec mit:yo)
          =>  .(sec (mod sec mit:yo))
          [day hor mit sec fan]
    

    Examples

        > (yell ~2014.3.20..05.42.53..7456)
        [d=106.751.991.820.094 h=5 m=42 s=53 f=~[0x7456]]
    
        > (yell ~2014.6.9..19.09.40..8b66)
        [d=106.751.991.820.175 h=19 m=9 s=40 f=~[0x8b66]]
    
        > (yell ~1776.7.4)
        [d=106.751.991.733.273 h=0 m=0 s=0 f=~]
    

    ++yelp

    Leap-week?

    Determines whether a year contains an ISO 8601 leap-week. Produces a flag.

    Accepts

    yer is an unsigned decimal.

    Produces

    A flag.

    Source

        ++  yelp
          |=  yer=@ud  ^-  ?
          &(=(0 (mod yer 4)) |(!=(0 (mod yer 100)) =(0 (mod yer 400))))
    

    Examples

        > (yelp 2.014)
        %.n
    
        > (yelp 2.008)
        %.y
    
        > (yelp 0)
        %.y
    
        > (yelp 14.011)
        %.n
    

    ++yore

    Date from atomic date

    Produces a date from a @d.

    Accepts

    now is a time atom, @d.

    Produces

    A date.

    Source

        ++  yore
          |=  now=@da
          ^-  date
          =+  rip=(yell now)
          =+  ger=(yall d.rip)
          :-  ?:  (gth y.ger 292.277.024.400)
                [a=& y=(sub y.ger 292.277.024.400)]
              [a=| y=+((sub 292.277.024.400 y.ger))]
          [m.ger d.ger h.rip m.rip s.rip f.rip]
    

    Examples

        > (yore ~2014.6.6..21.09.15..0a16)
        [[a=%.y y=2.014] m=6 t=[d=6 h=21 m=9 s=15 f=~[0xa16]]]
    

    ++yule

    Daily time to time atom

    Accepts a tarp, a parsed daily time, and produces a time atom, @d.

    Accepts

    rip is a tarp.

    Produces

    A time atom, @d.

    Source

        ++  yule                                                ::  time atom
          |=  rip=tarp
          ^-  @d
          =+  ^=  sec  ;:  add
                         (mul d.rip day:yo)
                         (mul h.rip hor:yo)
                         (mul m.rip mit:yo)
                         s.rip
                       ==
          =+  ^=  fac  =+  muc=4
                       |-  ^-  @
                       ?~  f.rip
                         0
                       =>  .(muc (dec muc))
                       (add (lsh 4 muc i.f.rip) $(f.rip t.f.rip))
          (con (lsh 6 1 sec) fac)
        ::
    

    Examples

        > =murica (yell ~1776.7.4)
    
        > murica
        [d=106.751.991.733.273 h=0 m=0 s=0 f=~]
    
        > (yule murica)
        0x8000000b62aaf5800000000000000000
    
        > `@da`(yule murica)
        ~1776.7.4
    
        > `@da`(yule (yell ~2014.3.20..05.42.53..7456))
        ~2014.3.20..05.42.53..7456
    
        > `tarp`[31 12 30 0 ~]
        [d=31 h=12 m=30 s=0 f=~]
    
        > `@dr`(yule `tarp`[31 12 30 0 ~])
        ~d31.h12.m30
    

    ++yo

    Time constants core

    Core whose arms contain constants for interacting with earth time.

    Source

        ++  yo
    

    ++cet:yo

    Days in a century

    Derived by multiplying the number of days in a year (365) by the number of years in a century (100), then adding the number days from leap-years in a century (24).

    Produces

    An atom.

    Source

          |%  ++  cet  36.524
    

    Examples

        > cet:yo
        36.524
    
        > (add 365 cet:yo)
        36.889
    
        > (sub (add 24 (mul 100 365)) cet:yo)
        0
    

    ++day:yo

    Seconds in day

    The number of seconds in a day.

    Produces

    An atom.

    Source

              ++  day  86.400
    

    Examples

        > day:yo
        86.400
    
        > (add 60 day:yo)
        86.460
    

    ++era:yo

    Leap-year period

    The number of days in a 400-year period, arrived at by multiplying cet by four and adding one. This is done because every 400 years, there is a leap-year where there would otherwise not be.

    Produces

    An atom.

    Source

              ++  era  146.097
    

    Examples

        > era:yo
        146.097
    
        > (sub era:yo (mul 4 cet:yo))
        1
    

    Discussion

    A year is a leap-year if:

    • it's divisible by 4;
    • unless it's divisible by 100;
    • or if it's divisible by 400.

    ++hor:yo

    Seconds in hour

    The number of seconds in an hour. Derived by multiplying the number of seconds in a minute by the minutes in an hour.

    Produces

    An atom.

    Source

              ++  hor  3.600
    

    Examples

        > hor:yo
        3.600
    
        > (div hor:yo 60)
        60
    

    ++jes:yo

    Maximum 64-bit timestamp

    This is the number of days (starting from 1970) that can be represented in a 64-bit timestamp. Derived by multiplying era:yo by 730,692,561.

    Produces

    An atom.

    Source

              ++  jes  106.751.991.084.417
    

    Examples

        > jes:yo
        106.751.991.084.417
    

    Discussion

    The date is December 4, 292,277,026,596.


    ++mit:yo

    Seconds in minute

    The number of seconds in a minute.

    Produces

    An atom.

    Source

              ++  mit  60
    

    Examples

        > mit:yo
        60
    

    ++moh:yo

    Days in month

    The days in each month of the Gregorian common year. A list of unsigned decimal atoms (Either 28, 30, or 31) denoting the number of days in the month at the year at that index.

    Produces

    A list of @ud

    Source

              ++  moh  `(list @ud)`[31 28 31 30 31 30 31 31 30 31 30 31 ~]
    

    Examples

        > moh:yo
        ~[31 28 31 30 31 30 31 31 30 31 30 31]
    
        > (snag 4 moh:yo)
        31
    

    ++moy:yo

    Days in months of leap-year

    The days in each month of the Gregorian leap-year. A list of unsigned decimal atoms (Either 29, 30, or 31) denoting the number of days in the month at the leap-year at that index.

    Produces

    A list of @ud.

    Source

              ++  moy  `(list @ud)`[31 29 31 30 31 30 31 31 30 31 30 31 ~]
    

    Examples

        > moy:yo
        ~[31 29 31 30 31 30 31 31 30 31 30 31]
    
        > (snag 1 moy:yo)
        29
    

    ++qad:yo

    Seconds in 4 years

    The number of seconds in four years. Derived by adding one second to the number of seconds in four years.

    Produces

    An atom.

    Source

              ++  qad  126.144.001
    

    Examples

        > qad:yo
        126.144.001
    

    ++yer:yo

    Seconds in year

    The number of seconds in a year. Derived by multiplying the number of seconds in a day by 365.

    Produces

    An atom.

    Source

              ++  yer  31.536.000
    

    Examples

        > yer:yo
        31.536.000