[c@`s dZddlmZmZmZmZddlZddlZddlmZddl m Z ddl Z ddl mZmZddl mZdd lmZdd lmZdd lmZdd lmZdd lmZmZddlmZddl m!Z!ddl"m#Z#ddlm$Z$ddl%m&Z&m'Z'm(Z(m)Z)m*Z*m+Z+ddl%m,Z,dddddddgZ-ddddd d!d"fZ.id dfddf6d fddf6d"fdd!f6d fddf6dd fddf6dfdd f6dd dd"fdd!f6dd dfdd"f6d fddf6d dd"fdd!f6d dfdd"f6d dd"fdd!f6d dfdd"f6dd"fd d!f6dfd d"f6Z/dd dfZ0ddfZ1d!fZ2e3d#e0e1e2fDZ4e4j5Z6ie7d df6e7dd f6ej8 dd f6ej8d$ej8d df6ej8 ddf6ej8d$ej8ddf6ej9 ddf6ej9d$ej9ddf6Z:iiiej;d%6d!d fd&6d'6iej<d%6d!d fd&6d(6iej=d%6d!fd&6d)6d*6iiej>d%6d!d fd&6d+6iej?d%6d!d fd&6d,6iej@d%6d!fd&6d-6iejAd%6d!fd&6d.6d/6ZBd0efd1YZCd2eCfd3YZDd4efd5YZEd6eEfd7YZFd8eGfd9YZHeId:ZJd;eKfd<YZLdS(=u The astropy.time package provides functionality for manipulating times and dates. Specific emphasis is placed on supporting time scales (e.g. UTC, TAI, UT1) and time representations (e.g. JD, MJD, ISO 8601) that are used in astronomy. i(tabsolute_importtdivisiontprint_functiontunicode_literalsN(tdatetime(t defaultdicti(tunitst constants(t_erfa(tUnitConversionError(t lazyproperty(tShapedLikeNDArray(toverride__dir__(t MixinInfotdata_info_factory(t broadcast_to(tsix(tzipi(tday_frac(t TIME_FORMATStTIME_DELTA_FORMATStTimeJDt TimeUniquetTimeAstropyTimet TimeDatetime(t TimeFromEpochuTimeu TimeDeltau TIME_SCALESuTIME_DELTA_SCALESuScaleValueErroruOperandTypeErroruTimeInfoutaiutcbutcgutdbuttuut1uutccc`s(|]}|D]}||fVq qdS(N((t.0tscalestscale((s0lib/python2.7/site-packages/astropy/time/core.pys >sg?ufunctionuscalesuIAU2006uIAU2000uIAU1982umeanuIAU2006AuIAU2000AuIAU2000BuIAU1994uapparenttTimeInfoc B`seZdZedgZejdhBZeZdZ e d Z e d Z e d ZeedejdgejD]Zeee^q}ZdZdZRS(u Container for meta information like name, description, format. This is required when the object is used as a mixin column within a table, but can be used as a general way to store meta information. uunituserialize_methoduformatuscaleu precisionu in_subfmtu out_subfmtulocationu_delta_ut1_utcu _delta_tdb_ttcC`sQ|j|j}|dkr%d}n!|dkr:d}n td||jS( Nuformatted_valueuvalueujd1_jd2ujd1ujd2u7serialize method must be 'formatted_value' or 'jd1_jd2'(uvalue(ujd1ujd2(tserialize_methodt_serialize_contextt ValueErrort_represent_as_dict_extra_attrs(tselftmethodtout((s0lib/python2.7/site-packages/astropy/time/core.pyt_represent_as_dict_attrsqs     cC`sOtt|j||rKidd6dd6dd6dd6dd6|_ndS(Nujd1_jd2ufitsuformatted_valueuecsvuhdf5uyaml(tsuperR t__init__tNoneR(R"tbound((s0lib/python2.7/site-packages/astropy/time/core.pyR'}s cC`sdS(N(R((R"((s0lib/python2.7/site-packages/astropy/time/core.pytunitstnamestfuncscC`sd|krZd|krZ|jd}d|d<|jd|d<|jd|ddCe d2Z?dCdCd3Z@d4ZAee@eAZBdCdCd5ZCd6ZDeeCeDZEd7ZFd8ZGd9ZHd:ZIdCd;ZJd<ZKd=ZLd>ZMd?ZNd@ZOdAZPdCdBZQeRjSjeQ_RS(Dub Represent and manipulate times and dates for astronomy. A `Time` object is initialized with one or more times in the ``val`` argument. The input times in ``val`` must conform to the specified ``format`` and must correspond to the specified time ``scale``. The optional ``val2`` time input should be supplied only for numeric input formats (e.g. JD) where very high precision (better than 64-bit precision) is required. The allowed values for ``format`` can be listed with:: >>> list(Time.FORMATS) ['jd', 'mjd', 'decimalyear', 'unix', 'cxcsec', 'gps', 'plot_date', 'datetime', 'iso', 'isot', 'yday', 'fits', 'byear', 'jyear', 'byear_str', 'jyear_str'] Parameters ---------- val : sequence, str, number, or `~astropy.time.Time` object Value(s) to initialize the time or times. val2 : sequence, str, or number; optional Value(s) to initialize the time or times. format : str, optional Format of input value(s) scale : str, optional Time scale of input value(s), must be one of the following: ('tai', 'tcb', 'tcg', 'tdb', 'tt', 'ut1', 'utc') precision : int, optional Digits of precision in string representation of time in_subfmt : str, optional Subformat for inputting string times out_subfmt : str, optional Subformat for outputting string times location : `~astropy.coordinates.EarthLocation` or tuple, optional If given as an tuple, it should be able to initialize an an EarthLocation instance, i.e., either contain 3 items with units of length for geocentric coordinates, or contain a longitude, latitude, and an optional height for geodetic coordinates. Can be a single location, or one for each input time. copy : bool, optional Make a copy of the input values i Nc C`sFt||r*|jd|d| } ntt|j|} | S(NR/tcopy(t isinstancet replicateR&RHt__new__( tclstvaltval2R/Rt precisiont in_subfmtt out_subfmttlocationRIR"((s0lib/python2.7/site-packages/astropy/time/core.pyRLscC`s |jfS(N(t_time(R"((s0lib/python2.7/site-packages/astropy/time/core.pyt__getnewargs__sc C`s|dk rIddlm} t|| r7||_qR| ||_n d|_t||jr|dk r||j_n|dk r||j_n|dk r||j_ n|dk r|j |qn"|j ||||| ||||jdk r|jj dkr|jj |j kry"t|j|j dt|_Wqtk rtdj|jj |j qXndS(Ni(t EarthLocationitsubokuThe location with shape {0} cannot be broadcast against time with shape {1}. Typically, either give a single location or one for each time.(R(t coordinatesRVRJRSt __class__RTRPRQRRt _set_scalet_init_from_valstsizetshapeRR=t ExceptionR R/( R"RNROR/RRPRQRRRSRIRV((s0lib/python2.7/site-packages/astropy/time/core.pyR's2        !  c C`s1|dkrd}n|dkr*d}n|dkr?d}nt||}|dk rt||}ytj||Wqtk rtdqXn|dk rt|tjo|j|j kst dj |t |j qn|j ||||||||_|jj|_dS(u Set the internal _format, scale, and _time attrs from user inputs. This handles coercion into the correct shapes and some basic input validation. iu*uNInput val and val2 have inconsistent shape; they cannot be broadcast together.u,Scale {0!r} is not in the allowed scales {1}N(R(t _make_arrayREt broadcastR RJRt string_typestlowertSCALEStScaleValueErrorR/tsortedt _get_time_fmtRTtnamet_format( R"RNROR/RRIRPRQRR((s0lib/python2.7/site-packages/astropy/time/core.pyR[+s,          c C`s|d kr|jjd krg|jjD]'\}} t| tr.|| f^q.} djg| D]\}} |^qh} | jdt fnt |t j o|j |jks|d krtdq$tdj|t|jn%||j|fg} dj|} xs| D]V\}} y| ||||||SWq+tk rjq+ttfk rq+Xq+Wtd j| d S( uM Given the supplied val, val2, format and scale try to instantiate the corresponding TimeFormat class to convert the input values into the internal jd1 and jd2. If format is `None` and the input is a string-type or object array then guess available formats and stop when one matches. uSuUuOu;any of the formats where the format keyword is optional {0}u astropy_timeu5No time format was given, and the input is not uniqueu2Format {0!r} is not one of the allowed formats {1}uthe format class {0}uInput values did not match {0}N(uSuUuO(R(tdtypetkindtFORMATStitemst issubclassRR/tappendRRJRRaRbR ReR t TypeError( R"RNROR/RRPRQRRRgRMtformatsterr_msgt FormatClass((s0lib/python2.7/site-packages/astropy/time/core.pyRfQs. !"   cC`s%tj}|d|ddddS(u( Creates a new object corresponding to the instant in time this method is called. .. note:: "Now" is determined using the `~datetime.datetime.utcnow` function, so its accuracy and precision is determined by that function. Generally that means it is set by the accuracy of your system clock. Returns ------- nowtime A new `Time` object (or a subclass of `Time` if this is called from such a subclass) at the current time. RNR/udatetimeRuutc(Rtutcnow(RMtdtnow((s0lib/python2.7/site-packages/astropy/time/core.pytnow|s cC`s|jS(u? Get or set time format. The format defines the way times are represented when accessed via the ``.value`` attribute. By default it is the same as the format used for initializing the `Time` instance, but it can be set to any other value that could be used for initialization. These can be listed with:: >>> list(Time.FORMATS) ['jd', 'mjd', 'decimalyear', 'unix', 'cxcsec', 'gps', 'plot_date', 'datetime', 'iso', 'isot', 'yday', 'fits', 'byear', 'jyear', 'byear_str', 'jyear_str'] (Rh(R"((s0lib/python2.7/site-packages/astropy/time/core.pyR/sc C`s||jkr0tdjt|jn|j|}t|drg|jD]}|d^qV}|j|krd|_qn||jj|jj |jj |j d|j d|jdt |_||_dS( uSet time formatuformat must be one of {0}usubfmtsiu*RQRRtfrom_jdN(RkR R/tlistthasattrtsubfmtsRRRTtjd1tjd2t_scaleRPRQR=Rh(R"R/t format_clstsubfmtt subfmt_names((s0lib/python2.7/site-packages/astropy/time/core.pyR/s      cC`s.dj|jj|j|jt||jS(Nu0<{0} object: scale='{1}' format='{2}' value={3}>(R/RYR7RRD(R"((s0lib/python2.7/site-packages/astropy/time/core.pyt__repr__scC`stt||jS(N(tstrRDR/(R"((s0lib/python2.7/site-packages/astropy/time/core.pyt__str__scC`s |jjS(u Time scale(RTR(R"((s0lib/python2.7/site-packages/astropy/time/core.pyRsc C`s||jkrdS||jkrFtdj|t|jn|j|f}tt|}tj|d}|d ||d}||krtt|}n|j j |j j }}xt |d |dD]\}} ||g} xm|| f| |ffD]S} dj| } yt || } Wntk rMqX| j| ||PqWt t|| }|| \}}qW|j|j||||j|j|jdt|_ dS(u This is the key routine that actually does time scale conversions. This is not public and not connected to the read-only scale property. Nu,Scale {0!r} is not in the allowed scales {1}iiu_get_delta_{0}_{1}Rv((RRcR R/Rettuplet MULTI_HOPStgettreversedRTRzR{RRDtAttributeErrorRnterfaRkRPRQRRR=(R"Rtxformt xform_sorttmultitxformsRzR{tsys1tsys2targstsys12t dt_methodtget_dtt conv_func((s0lib/python2.7/site-packages/astropy/time/core.pyRZs6  $  cC`s |jjS(u| Decimal precision when outputting seconds as floating point (int value between 0 and 9 inclusive). (RTRP(R"((s0lib/python2.7/site-packages/astropy/time/core.pyRPscC`sMt|t s(|dks(|dkr7tdn||j_|`dS(Nii u2precision attribute must be an int between 0 and 9(RJtintR RTRPtcache(R"RN((s0lib/python2.7/site-packages/astropy/time/core.pyRPs( cC`s |jjS(ud Unix wildcard pattern to select subformats for parsing string input times. (RTRQ(R"((s0lib/python2.7/site-packages/astropy/time/core.pyRQ scC`s7t|tjs!tdn||j_|`dS(Nu$in_subfmt attribute must be a string(RJRRaR RTRQR(R"RN((s0lib/python2.7/site-packages/astropy/time/core.pyRQs cC`s |jjS(uR Unix wildcard pattern to select subformats for outputting times. (RTRR(R"((s0lib/python2.7/site-packages/astropy/time/core.pyRRscC`s7t|tjs!tdn||j_|`dS(Nu%out_subfmt attribute must be a string(RJRRaR RTRRR(R"RN((s0lib/python2.7/site-packages/astropy/time/core.pyRRs cC`s |jjjS(uThe shape of the time instances. Like `~numpy.ndarray.shape`, can be set to a new shape by assigning a tuple. Note that if different instances share some but not all underlying data, setting the shape of one instance can make the other instance unusable. Hence, it is strongly recommended to get new, reshaped instances with the ``reshape`` method. Raises ------ AttributeError If the shape of the ``jd1``, ``jd2``, ``location``, ``delta_ut1_utc``, or ``delta_tdb_tt`` attributes cannot be changed without the arrays being copied. For these cases, use the `Time.reshape` method (which copies any arrays that cannot be reshaped in-place). (RTRzR](R"((s0lib/python2.7/site-packages/astropy/time/core.pyR]&scC`sg}|j}xdD]}t||d}|dk r|jdkry ||_Wn.tk rx|D]}||_qmWqX|j|qqWdS(Nujd1ujd2u_delta_ut1_utcu _delta_tdb_ttulocationi(ujd1ujd2u_delta_ut1_utcu _delta_tdb_ttulocation(R]RDR(R\RRn(R"R]treshapedtoldshapetattrRNRO((s0lib/python2.7/site-packages/astropy/time/core.pyR];s      cC`s|jjjr|S|jS(N(RTRzR]titem(R"tvalue((s0lib/python2.7/site-packages/astropy/time/core.pyt_shaped_like_inputOscC`s|j|jjS(uU First of the two doubles that internally store time value(s) in JD. (RRTRz(R"((s0lib/python2.7/site-packages/astropy/time/core.pyRzRscC`s|j|jjS(uV Second of the two doubles that internally store time value(s) in JD. (RRTR{(R"((s0lib/python2.7/site-packages/astropy/time/core.pyR{YscC`st||jS(uTime value(s) in current format(RDR/(R"((s0lib/python2.7/site-packages/astropy/time/core.pyR`su barycentriccC`s|jdkr!tdn|d krW|jd krKtdn|j}nddlm}m}m}m}m } m } |j |stdny|j d|} Wnt k rtd nX| j|h|jdkr| j|d|jj} n0| j| d|} | j|jj} Wd QX|jj|j|j}tj| d | j} tj|d |j}|| jd d tj}t|ddS(uLight travel time correction to the barycentre or heliocentre. The frame transformations used to calculate the location of the solar system barycentre and the heliocentre rely on the erfa routine epv00, which is consistent with the JPL DE405 ephemeris to an accuracy of 11.2 km, corresponding to a light travel time of 4 microseconds. The routine assumes the source(s) are at large distance, i.e., neglects finite-distance effects. Parameters ---------- skycoord : `~astropy.coordinates.SkyCoord` The sky location to calculate the correction for. kind : str, optional ``'barycentric'`` (default) or ``'heliocentric'`` location : `~astropy.coordinates.EarthLocation`, optional The location of the observatory to calculate the correction for. If no location is given, the ``location`` attribute of the Time object is used ephemeris : str, optional Solar system ephemeris to use (e.g., 'builtin', 'jpl'). By default, use the one set with ``astropy.coordinates.solar_system_ephemeris.set``. For more information, see `~astropy.coordinates.solar_system_ephemeris`. Returns ------- time_offset : `~astropy.time.TimeDelta` The time offset between the barycentre or Heliocentre and Earth, in TDB seconds. Should be added to the original time to get the time in the Solar system barycentre or the Heliocentre. Also, the time conversion to BJD will then include the relativistic correction as well. u barycentricu heliocentricu?'kind' parameter must be one of 'heliocentric' or 'barycentric'u\An EarthLocation needs to be set or passed in to calculate bary- or heliocentric correctionsi(tUnitSphericalRepresentationtCartesianRepresentationtHCRStICRStGCRStsolar_system_ephemerisu/Given skycoord is not transformable to the ICRStobstimeu9Supplied location does not have a valid `get_itrs` methodNitaxisiRutdb(u barycentricu heliocentric(RbR R(RSRXRRRRRRtis_transformable_totget_itrsR^R:t transform_tot cartesiantxyzticrst represent_asREtrollaxistndimtsumtconsttct TimeDelta(R"tskycoordRjRSt ephemerisRRRRRRtitrstcpostgcrs_cootsposttcor_val((s0lib/python2.7/site-packages/astropy/time/core.pytlight_travel_timeis0#  . ! cC`syddlm}|jtjkrUtdjdjttjnt|j}|d krt|jd}n<|j |krtdj||t|jn|d kr|j d krtdn|j j }nM|dkr-|d t jd d t j}n||t jd d t j}|j||j }|||t jS( uCalculate sidereal time. Parameters --------------- kind : str ``'mean'`` or ``'apparent'``, i.e., accounting for precession only, or also for nutation. longitude : `~astropy.units.Quantity`, `str`, or `None`; optional The longitude on the Earth at which to compute the sidereal time. Can be given as a `~astropy.units.Quantity` with angular units (or an `~astropy.coordinates.Angle` or `~astropy.coordinates.Longitude`), or as a name of an observatory (currently, only ``'greenwich'`` is supported, equivalent to 0 deg). If `None` (default), the ``lon`` attribute of the Time object is used. model : str or `None`; optional Precession (and nutation) model to use. The available ones are: - {0}: {1} - {2}: {3} If `None` (default), the last (most recent) one from the appropriate list above is used. Returns ------- sidereal time : `~astropy.coordinates.Longitude` Sidereal time as a quantity with units of hourangle i(t Longitudeu'The kind of sidereal time has to be {0}u or iuIModel {0} not implemented for {1} sidereal time; available models are {2}uFNo longitude is given but the location for the Time object is not set.u greenwichgt wrap_anglegf@N(RXRRbtSIDEREAL_TIME_MODELStkeysR R/tjoinReR(tupperRStlontutdegreet_erfa_sidereal_timet hourangle(R"Rjt longitudetmodelRtavailable_modelstgst((s0lib/python2.7/site-packages/astropy/time/core.pyt sidereal_times, $ !  uapparentumeancC`sddlm}|d}g|dD].}dD]!}tt||j|^q/q%}||}||tjjtjS(u@Calculate a sidereal time using a IAU precession/nutation model.i(Rufunctionuscalesujd1ujd2(ujd1ujd2(RXRRDRTRtradianttoR(R"RRt erfa_functionRtjd_partterfa_parametersR((s0lib/python2.7/site-packages/astropy/time/core.pyRs . cC`s|jdd|S(u Return a fully independent copy the Time object, optionally changing the format. If ``format`` is supplied then the time format of the returned Time object will be set accordingly, otherwise it will be unchanged from the original. In this method a full copy of the internal time arrays will be made. The internal time arrays are normally not changeable by the user so in most cases the ``replicate()`` method should be used. Parameters ---------- format : str, optional Time format of the copy. Returns ------- tm : Time object Copy of this object ucopyR/(t_apply(R"R/((s0lib/python2.7/site-packages/astropy/time/core.pyRI scC`s|j|rdndd|S(u  Return a replica of the Time object, optionally changing the format. If ``format`` is supplied then the time format of the returned Time object will be set accordingly, otherwise it will be unchanged from the original. If ``copy`` is set to `True` then a full copy of the internal time arrays will be made. By default the replica will use a reference to the original arrays when possible to save memory. The internal time arrays are normally not changeable by the user so in most cases it should not be necessary to set ``copy`` to `True`. The convenience method copy() is available in which ``copy`` is `True` by default. Parameters ---------- format : str, optional Time format of the replica. copy : bool, optional Return a true copy instead of using references where possible. Returns ------- tm : Time object Replica of this object ucopyu replicateR/(R(R"R/RI((s0lib/python2.7/site-packages/astropy/time/core.pyRK%sc `sLjdd}|dkr*|j}ntrNfd}n*dkrcd}ntj}|jj|jj}}|r||}||}nt t |j j |j }t |||j|j|j|jdt|_xdD]} yt|| } Wntk r6qnX|rt| d d d krd|| } qd ks|dkrtj| } qnt|| | qWd|jkr|j|_n||jkrtdjt|jn|j|} | |jj|jj|jj|j|j|jdt|_||_|S(u-Create a new time object, possibly applying a method to the arrays. Parameters ---------- method : str or callable If string, can be 'replicate' or the name of a relevant `~numpy.ndarray` method. In the former case, a new time instance with unchanged internal data is created, while in the latter the method is applied to the internal ``jd1`` and ``jd2`` arrays, as well as to possible ``location``, ``_delta_ut1_utc``, and ``_delta_tdb_tt`` arrays. If a callable, it is directly applied to the above arrays. Examples: 'copy', '__getitem__', 'reshape', `~numpy.broadcast_to`. args : tuple Any positional arguments for ``method``. kwargs : dict Any keyword arguments for ``method``. If the ``format`` keyword argument is present, this will be used as the Time format of the replica. Examples -------- Some ways this is used internally:: copy : ``_apply('copy')`` replicate : ``_apply('replicate')`` reshape : ``_apply('reshape', new_shape)`` index or slice : ``_apply('__getitem__', item)`` broadcast : ``_apply(np.broadcast, shape=new_shape)`` uformatc`s|S(N((tarray(RtkwargsR#(s0lib/python2.7/site-packages/astropy/time/core.pythsu replicateRvu_delta_ut1_utcu _delta_tdb_ttulocationu precisionu in_subfmtu out_subfmtusizeiucopyuflattenuinfouformat must be one of {0}N(u_delta_ut1_utcu _delta_tdb_ttulocationu precisionu in_subfmtu out_subfmt(R-R(R/tcallabletoperatort methodcallerRTRzR{R&RHRYRLRRRPRQRRR=RDRRItsetattrt__dict__tinfoRkR RwR|Rh( R"R#RRt new_formatt apply_methodRzR{ttmRRNt NewFormat((RRR#s0lib/python2.7/site-packages/astropy/time/core.pyRDsN            cC`s |jS(u Overrides the default behavior of the `copy.copy` function in the python stdlib to behave like `Time.copy`. Does *not* make a copy of the JD arrays - only copies by reference. (RK(R"((s0lib/python2.7/site-packages/astropy/time/core.pyt__copy__scC`s |jS(u Overrides the default behavior of the `copy.deepcopy` function in the python stdlib to behave like `Time.copy`. Does make a copy of the JD arrays. (RI(R"tmemo((s0lib/python2.7/site-packages/astropy/time/core.pyt __deepcopy__scC`s|dkrtj||jS|j}|dkrA||}n|rn|j|jkrntj||}ngt|jD]\}}||kr|ndtj|jd|s||kr|n|d|fd|||s||krdnd^q~S(uTurn argmin, argmax output into an advanced index. Argmin, argmax output contains indices along a given axis in an array shaped like the other dimensions. To use this to get values at the correct location, a list is constructed in which the other axes are indexed sequentially. For ``keepdims`` is ``True``, the net result is the same as constructing an index grid with ``np.ogrid`` and then replacing the ``axis`` item with ``indices`` with its shaped expanded at ``axis``. For ``keepdims`` is ``False``, the result is the same but with the ``axis`` dimension removed from all list entries. For ``axis`` is ``None``, this calls :func:`~numpy.unravel_index`. Parameters ---------- indices : array Output of argmin or argmax. axis : int or None axis along which argmin or argmax was used. keepdims : bool Whether to construct indices that keep or remove the axis along which argmin or argmax was used. Default: ``False``. Returns ------- advanced_index : list of arrays Suitable for use as an advanced index. iiiN(i(i( R(REt unravel_indexR]Rt expand_dimst enumeratetarangetreshape(R"tindicesRtkeepdimsRtits((s0lib/python2.7/site-packages/astropy/time/core.pyt_advanced_indexs    cC`sI|j|j}|j|dt}|j||j}|j||S(u)Return indices of the minimum values along the given axis. This is similar to :meth:`~numpy.ndarray.argmin`, but adapted to ensure that the full precision given by the two doubles ``jd1`` and ``jd2`` is used. See :func:`~numpy.argmin` for detailed documentation. R(RzR{tminR=targmin(R"RR$tjdtapproxtdt((s0lib/python2.7/site-packages/astropy/time/core.pyRs cC`sI|j|j}|j|dt}|j||j}|j||S(u)Return indices of the maximum values along the given axis. This is similar to :meth:`~numpy.ndarray.argmax`, but adapted to ensure that the full precision given by the two doubles ``jd1`` and ``jd2`` is used. See :func:`~numpy.argmax` for detailed documentation. R(RzR{tmaxR=targmax(R"RR$RRR((s0lib/python2.7/site-packages/astropy/time/core.pyRsicC`sp|j}||j|ddj}|dkrPtj|j|jfStjd||fd|SdS(uwReturns the indices that would sort the time array. This is similar to :meth:`~numpy.ndarray.argsort`, but adapted to ensure that the full precision given by the two doubles ``jd1`` and ``jd2`` is used, and that corresponding attributes are copied. Internally, it uses :func:`~numpy.lexsort`, and hence no sort method can be chosen. R/ujdRRN(RRYR(REtlexsorttravel(R"Rt jd_approxt jd_remainder((s0lib/python2.7/site-packages/astropy/time/core.pytargsorts   cC`s;|dk rtdn||j|j|||S(uMinimum along a given axis. This is similar to :meth:`~numpy.ndarray.min`, but adapted to ensure that the full precision given by the two doubles ``jd1`` and ``jd2`` is used, and that corresponding attributes are copied. Note that the ``out`` argument is present only for compatibility with ``np.min``; since `Time` instances are immutable, it is not possible to have an actual ``out`` to store the result in. uUSince `Time` instances are immutable, ``out`` cannot be set to anything but ``None``.N(R(R RR(R"RR$R((s0lib/python2.7/site-packages/astropy/time/core.pyRs cC`s;|dk rtdn||j|j|||S(uMaximum along a given axis. This is similar to :meth:`~numpy.ndarray.max`, but adapted to ensure that the full precision given by the two doubles ``jd1`` and ``jd2`` is used, and that corresponding attributes are copied. Note that the ``out`` argument is present only for compatibility with ``np.max``; since `Time` instances are immutable, it is not possible to have an actual ``out`` to store the result in. uUSince `Time` instances are immutable, ``out`` cannot be set to anything but ``None``.N(R(R RR(R"RR$R((s0lib/python2.7/site-packages/astropy/time/core.pyR!s cC`sA|dk rtdn|j|d||j|d|S(uPeak to peak (maximum - minimum) along a given axis. This is similar to :meth:`~numpy.ndarray.ptp`, but adapted to ensure that the full precision given by the two doubles ``jd1`` and ``jd2`` is used. Note that the ``out`` argument is present only for compatibility with `~numpy.ptp`; since `Time` instances are immutable, it is not possible to have an actual ``out`` to store the result in. uUSince `Time` instances are immutable, ``out`` cannot be set to anything but ``None``.RN(R(R RR(R"RR$R((s0lib/python2.7/site-packages/astropy/time/core.pytptp1s cC`s#||j|j||dtS(u"Return a copy sorted along the specified axis. This is similar to :meth:`~numpy.ndarray.sort`, but internally uses indexing with :func:`~numpy.lexsort` to ensure that the full precision given by the two doubles ``jd1`` and ``jd2`` is kept, and that corresponding attributes are properly sorted and copied as well. Parameters ---------- axis : int or None Axis to be sorted. If ``None``, the flattened array is sorted. By default, sort over the last axis. R(RRR=(R"R((s0lib/python2.7/site-packages/astropy/time/core.pytsortBscC`s ttS(uA Return the cache associated with this instance. (Rtdict(R"((s0lib/python2.7/site-packages/astropy/time/core.pyRSscC`sd||jkr}|jdk r}|jd}||kru||jkrO|}n|j}|j||||>> from astropy.utils.iers import TIME_BEFORE_IERS_RANGE >>> t = Time(['1961-01-01', '2000-01-01'], scale='utc') >>> delta, status = t.get_delta_ut1_utc(return_status=True) >>> status == TIME_BEFORE_IERS_RANGE array([ True, False]...) i(tIERSt return_statusN(R(t utils.iersRtopentut1_utctutc(R"t iers_tableRR((s0lib/python2.7/site-packages/astropy/time/core.pytget_delta_ut1_utcs) c C`st|dsddlm}|j}|dkr\|j}|j|j}}d}n |j}|j ||}|dkrt j |||\}} |j || }n|j |n|j S(u Get ERFA DUT arg = UT1 - UTC. This getter takes optional jd1 and jd2 args because it gets called that way when converting time scales. If delta_ut1_utc is not yet set, this will interpolate them from the the IERS table. u_delta_ut1_utci(t IERS_Autouutcuut1N(RxRR RR(RRzR{RRRtut1utct_set_delta_ut1_utcR2( R"RzR{R Rtself_utcRtdeltatjd1_utctjd2_utc((s0lib/python2.7/site-packages/astropy/time/core.pyt_get_delta_ut1_utcs       cC`sIt|dr'|jtjj}n|j|}||_|`dS(Nuto(RxRRtsecondRRR2R(R"RN((s0lib/python2.7/site-packages/astropy/time/core.pyR s  c C`s`t|dsY|dks'|dkr`|jd krEtdq`|jj}|jj}ntj||\}}tj ||\}}t |d|d}|j dkrddl m }|jd d d }n |j }|j}tj|j|j} |j} tj||||jtj| jtj| jtj|_n|jS( Nu _delta_tdb_ttuttutdbuOAccessing the delta_tdb_tt attribute is only possible for TT or TDB time scalesg?ii(RVg(uttutdb(RxR(RR RTRzR{RttttaittaiutcRRSRXRVt from_geodeticRREthypottxtytztdtdbRRRtkmR3( R"RzR{tnjd1tnjd2tutRVRSRtrxyR((s0lib/python2.7/site-packages/astropy/time/core.pyt_get_delta_tdb_tts(    *cC`sIt|dr'|jtjj}n|j|}||_|`dS(Nuto(RxRRRRRR3R(R"RN((s0lib/python2.7/site-packages/astropy/time/core.pyt_set_delta_tdb_tt s  cC`st|tsHyt|}WqHtk rDt||dqHXnt|t}|r|j}|j|jkr|j|jdfkrt ||j}qn%|j |jdk r|jndxdD]%}t ||rt ||qqWno|jt kr|jn |jj}t|j|jddd|j}|j|jkrrt ||j}n|jj|jj}|jj|jj}t||\|j_|j_|r|j |jn|S( Nu-utaiu_delta_ut1_utcu _delta_tdb_ttR/ujdR(u_delta_ut1_utcu _delta_tdb_tt(RJRHRR^tOperandTypeErrorRKRRcR(RDRZRxtdelattrtTIME_DELTA_SCALESRTttaiRzR{R(R"tothertother_is_deltaR$Rt self_timeRzR{((s0lib/python2.7/site-packages/astropy/time/core.pyt__sub__,s8     !cC`spt|tsHyt|}WqHtk rDt||dqHXnt|tslt||dn|j}|j|jkr|j|jdfkrt ||j}qn%|j |jdk r|jndx-dD]%}t ||rt ||qqW|j j|j j}|j j|j j}t||\|j _|j _|j |j|S(Nu+utaiu_delta_ut1_utcu _delta_tdb_tt(u_delta_ut1_utcu _delta_tdb_tt(RJRHRR^R!RKRRcR(RDRZRxR"RTRzR{R(R"R%R$RRzR{((s0lib/python2.7/site-packages/astropy/time/core.pyt__add__\s(  % !cC`s |j|S(N(R)(R"R%((s0lib/python2.7/site-packages/astropy/time/core.pyt__radd__scC`s|j|}| S(N(R((R"R%R$((s0lib/python2.7/site-packages/astropy/time/core.pyt__rsub__scC`s |j|jk rWy|j|d|j}WqWtk rSt|||qWXn|jdk rx|j|jks|jdk r|j|jkrtdj|j|jn|jdk r|jdk rt||j}n|j |j |j |j S(uwIf other is of same class as self, return difference in self.scale. Otherwise, raise OperandTypeError. Ru>Cannot compare TimeDelta instances with scales '{0}' and '{1}'N( RYRR^R!R(RcRoR/RDRzR{(R"R%top((s0lib/python2.7/site-packages/astropy/time/core.pyt_time_differences !! cC`s|j|ddkS(Nug(R-(R"R%((s0lib/python2.7/site-packages/astropy/time/core.pyt__gt__scC`s|j|ddkS(Nu>=g(R-(R"R%((s0lib/python2.7/site-packages/astropy/time/core.pyt__ge__scC`s+|jdd}|j|jj|S(NR/udatetime(RKRRTR(R"ttimezoneR((s0lib/python2.7/site-packages/astropy/time/core.pyt to_datetimesN(TR7R8R9RRcRRkt__array_priority__R(t_astropy_column_attrsR@RLRUR'R[Rft classmethodRuRRR?R/tsetterRRRRZRPRQRRR]RRzR{RRRRJRRaReRRRRIRKRRRRRRRRRRRR RRR RRRRR R4RR R5R(R)R*R+R-R.R/R1R2R3R4R6RR(((s0lib/python2.7/site-packages/astropy/time/core.pyRHs+     (% +    1  R> "   _  +   ( 0# &  0 '        RcB`seZdZeZeZeZddde dZ dZ dZ dZdZdZdZdZd Zd Zd Zd Zd ZdZRS(u Represent the time difference between two times. A TimeDelta object is initialized with one or more times in the ``val`` argument. The input times in ``val`` must conform to the specified ``format``. The optional ``val2`` time input should be supplied only for numeric input formats (e.g. JD) where very high precision (better than 64-bit precision) is required. The allowed values for ``format`` can be listed with:: >>> list(TimeDelta.FORMATS) ['sec', 'jd'] Note that for time differences, the scale can be among three groups: geocentric ('tai', 'tt', 'tcg'), barycentric ('tcb', 'tdb'), and rotational ('ut1'). Within each of these, the scales for time differences are the same. Conversion between geocentric and barycentric is possible, as there is only a scale factor change, but one cannot convert to or from 'ut1', as this requires knowledge of the actual times, not just their difference. For a similar reason, 'utc' is not a valid scale for a time difference: a UTC day is not always 86400 seconds. Parameters ---------- val : sequence, ndarray, number, `~astropy.units.Quantity` or `~astropy.time.TimeDelta` object Value(s) to initialize the time difference(s). Any quantities will be converted appropriately (with care taken to avoid rounding errors for regular time units). val2 : sequence, ndarray, number, or `~astropy.units.Quantity`; optional Additional values, as needed to preserve precision. format : str, optional Format of input value(s) scale : str, optional Time scale of input value(s), must be one of the following values: ('tdb', 'tt', 'ut1', 'tcg', 'tcb', 'tai'). If not given (or ``None``), the scale is arbitrary; when added or subtracted from a ``Time`` instance, it will be used without conversion. copy : bool, optional Make a copy of the input values cC`s|t|tr.|dk rx|j|qxnJ|dkrCd}n|j||||||dk rxt||_ndS(Nujd(RJRR(RZR[tTIME_DELTA_TYPESRc(R"RNROR/RRI((s0lib/python2.7/site-packages/astropy/time/core.pyR's    cO`s+tt|j||}|j|_|S(N(R&RRKRc(R"RRR$((s0lib/python2.7/site-packages/astropy/time/core.pyRKs c C`s||jkrdS||jkrFtdj|t|jnt|j|f}|dkrt||j_ns|jj|jj }}t ||d|\}}|j |j||||||j |j |jdt|_dS(u This is the key routine that actually does time scale conversions. This is not public and not connected to the read-only scale property. Nu,Scale {0!r} is not in the allowed scales {1}tfactorRv(RRcR R/Ret SCALE_OFFSETSR(RTRzR{RRkRPRQRRR=(R"Rt scale_offsetRzR{toffset1toffset2((s0lib/python2.7/site-packages/astropy/time/core.pyRZ s    cC`sut|tr.t|tsd|j|Sn6yt|}Wn#tk rct||dnX|jdk r|j|jks|jdk r|j|jkrt dj |j|jn|jdk s|jdkr|j }|jdk r$t ||j}q$n |j }|j j|j j}|j j|j j}t||\|j _|j _|S(Nu+u:Cannot add TimeDelta instances with scales '{0}' and '{1}'(RJRHRR)R^R!RR(RcRoR/RKRDRTRzR{R(R"R%R$RzR{((s0lib/python2.7/site-packages/astropy/time/core.pyR)&s( !!   !cC`s}t|tr6t|tslt||dqln6yt|}Wn#tk rkt||dnX|jdk r|j|jks|jdk r|j|jkrtdj |j|jn|jdk s|jdkr |j }|jdk r,t ||j}q,n |j }|j j |j j }|j j|j j}t||\|j _ |j _|S(Nu-u?Cannot subtract TimeDelta instances with scales '{0}' and '{1}'(RJRHRR!R^RR(RcRoR/RKRDRTRzR{R(R"R%R$RzR{((s0lib/python2.7/site-packages/astropy/time/core.pyR(Fs( !!   !cC`s6|j}|jj |j_|jj |j_|S(u!Negation of a `TimeDelta` object.(RIRTRzR{(R"tnew((s0lib/python2.7/site-packages/astropy/time/core.pyt__neg__fs cC`sq|jj|jj}}||dk}|j}tj|| ||j_tj|| ||j_|S(u'Absolute value of a `TimeDelta` object.i(RTRzR{RIREtwhere(R"RzR{tnegativeRA((s0lib/python2.7/site-packages/astropy/time/core.pyt__abs__ms  cC`st|tr$t||dny|jd}Wntk rJnXyCt|j|jd|\}}t||ddd|j }WnEtk r}y|jt j |SWqtk r|qXnX|j dkr|j d|j }n|S(u8Multiplication of `TimeDelta` objects by numbers/arrays.u*iR<R/ujdR(RJRHR!RR^RRzR{RRRtdayR/RK(R"R%RzR{R$terr((s0lib/python2.7/site-packages/astropy/time/core.pyt__mul__vs" !" cC`s |j|S(u:Multiplication of numbers/arrays with `TimeDelta` objects.(RH(R"R%((s0lib/python2.7/site-packages/astropy/time/core.pyt__rmul__scC`s |j|S(u2Division of `TimeDelta` objects by numbers/arrays.(t __truediv__(R"R%((s0lib/python2.7/site-packages/astropy/time/core.pyt__div__scC`s |j|S(u2Division by `TimeDelta` objects of numbers/arrays.(t __rtruediv__(R"R%((s0lib/python2.7/site-packages/astropy/time/core.pyt__rdiv__scC`sy|jd}Wntk r&nXyCt|j|jd|\}}t||ddd|j}WnEtk r}y|jtj|SWqtk r|qXnX|j dkr|j d|j }n|S(u2Division of `TimeDelta` objects by numbers/arrays.itdivisorR/ujdR( RR^RRzR{RRRRFR/RK(R"R%RzR{R$RG((s0lib/python2.7/site-packages/astropy/time/core.pyRJs !" cC`s||jtjS(u2Division by `TimeDelta` objects of numbers/arrays.(RRRF(R"R%((s0lib/python2.7/site-packages/astropy/time/core.pyRLscO`s/tj|jj|jjtjj||S(N(RtQuantityRTRzR{RFR(R"RR((s0lib/python2.7/site-packages/astropy/time/core.pyRsN(R7R8R9R#RcRRkRGRR(R@R'RKRZR)R(RBRERHRIRKRMRJRLR(((s0lib/python2.7/site-packages/astropy/time/core.pyRs$)          RdcB`seZRS((R7R8(((s0lib/python2.7/site-packages/astropy/time/core.pyRdscC`s^tj|d|dt}|jtjkp<|jjdksZtj|dtj}n|S(u Take ``val`` and convert/reshape to an array. If ``copy`` is `True` then copy input values. Returns ------- val : ndarray Array version of ``val``. RIRWuOSUaRi(RERR=Ritfloat64Rjt asanyarray(RNRI((s0lib/python2.7/site-packages/astropy/time/core.pyR_s $R!cB`seZddZRS(cC`sV|dkrdn dj|}tt|jdj||jj|jjdS(Nuu for {0}u/Unsupported operand type(s){0}: '{1}' and '{2}'(R(R/R&R!R'RYR7(R"tlefttrightR,t op_string((s0lib/python2.7/site-packages/astropy/time/core.pyR's ! N(R7R8R(R'(((s0lib/python2.7/site-packages/astropy/time/core.pyR!s(MR9t __future__RRRRRIRRt collectionsRtnumpyREtRRRRRRR tutils.decoratorsR tutilsR tutils.compat.miscR tutils.data_infoR Rtutils.compat.numpyRtexternRtextern.six.movesRRRpRRRRRRRt__all__RRtGEOCENTRIC_SCALEStBARYCENTRIC_SCALEStROTATIONAL_SCALESRR;RR#R(tELGtELBR=tgmst06tgmst00tgmst82tgst06atgst00atgst00btgst94RRRGRHRR^RdR@R_RoR!(((s0lib/python2.7/site-packages/astropy/time/core.pyts"   .      "Q