B
    AfxaQ'                @  sF  d Z ddlmZ ddlZddlZddlZddlZddlZddlZddl	Z	ddl
Z
ddlZddlZddlZddlmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZ ddlmZm Z m!Z!m"Z" ddl#m$Z$m%Z%m&Z&m'Z'm(Z(m)Z)m*Z*m+Z+m,Z,m-Z-m.Z.m/Z/m0Z0 ddl1m2Z2 dd	l3m4Z4m5Z5m6Z6m7Z7 dd
l8m9Z9m:Z:m;Z;m<Z<m=Z= ddl>m?Z?m@Z@mAZAmBZBmCZCmDZDmEZEmFZF ddlGmHZHmIZImJZJmKZKmLZLmMZMmNZN erddlOmPZPmQZQ ddlRmSZS ddlTmJZU e$rddlVZ-G dd deWZXdd ZYdd ZZdd Z[dd Z\dd Z]ej^dd Z_edZ`G dd  d eHeIee" ZaeaZbd!d"d#d$d%ZcdS )&z
    pint.quantity
    ~~~~~~~~~~~~~

    :copyright: 2016 by Pint Authors, see AUTHORS for more details.
    :license: BSD, see LICENSE for more details.
    )annotationsN)TYPE_CHECKINGAnyCallableDictGenericIterableIteratorListOptionalSequenceTupleTypeTypeVarUnionoverload   )SShapeUnitLike_MagnitudeType)	HAS_NUMPY_to_magnitudebabel_parsecompute
dask_arrayeqis_duck_array_typeis_upcast_typendarraynppersist	visualizezero_or_nan)UnitDefinition)DimensionalityErrorOffsetUnitCalculusErrorPintTypeErrorUnitStrippedWarning)_pretty_fmt_exponentextract_custom_flagsndarray_to_latexremove_custom_flagssiunitx_format_unit)HANDLED_UFUNCScopy_units_output_ufuncsget_op_output_unit'matching_input_copy_units_output_ufuncs&matching_input_set_units_output_ufuncs
numpy_wrapop_units_output_ufuncsset_units_ufuncs)PrettyIPythonSharedRegistryObjectUnitsContainerinfer_base_unititerableloggerto_units_container)ContextUnit)BaseRegistry)r8   c               @  s   e Zd Zdd ZdS )
_Exceptionc             C  s
   || _ d S )N)internal)selfrA    rC   ,lib/python3.7/site-packages/pint/quantity.py__init__d   s    z_Exception.__init__N)__name__
__module____qualname__rE   rC   rC   rC   rD   r@   c   s   r@   c               s    fdd}|S )Nc               sB    | f||}y|j jr"| S |S W n tk
r<   |S X d S )N)	_REGISTRYauto_reduce_dimensionsto_reduced_unitsAttributeError)rB   argskwargsresult)frC   rD   wrappedi   s    z"reduce_dimensions.<locals>.wrappedrC   )rP   rQ   rC   )rP   rD   reduce_dimensionsh   s    
rR   c               s    fdd}|S )Nc               s>    | f||}y|j jr"|  W n tk
r8   Y nX |S )N)rI   rJ   ito_reduced_unitsrL   )rB   rM   rN   rO   )rP   rC   rD   rQ   w   s    z#ireduce_dimensions.<locals>.wrappedrC   )rP   rQ   rC   )rP   rD   ireduce_dimensionsv   s    	rT   c               s    fdd}|S )Nc               sL   |d }t t|rtS t|tr<|r<t|d t| r<tS  | f||S )Nr   )r   typeNotImplemented
isinstancelist)rB   rM   rN   other)rP   rC   rD   rQ      s     z"check_implemented.<locals>.wrappedrC   )rP   rQ   rC   )rP   rD   check_implemented   s    
rZ   c               s&   t  trtt d   fdd}|S )Nc               s
    | _ | S )N)__wrapped__)func)
numpy_funcrC   rD   wrapper   s    zmethod_wraps.<locals>.wrapper)rW   strgetattrr    )r]   r^   rC   )r]   rD   method_wraps   s    
ra   c               s   t   fdd}|S )Nc               s@   t | jtjr | f||S d jtj| jj}t|d S )Nz4Method {} only implemented for objects of {}, not {})rW   
_magnituder   ArrayformatrF   	__class__rL   )rB   rM   rN   msg)rP   rC   rD   r^      s
    z!check_dask_array.<locals>.wrapper)	functoolswraps)rP   r^   rC   )rP   rD   check_dask_array   s    
ri   c           	   o  s6   t  }zt j| | t  V  W dt jf | X dS )zNumpy printoptions context manager released with version 1.15.0
    https://docs.scipy.org/doc/numpy/reference/generated/numpy.printoptions.html
    N)r    Zget_printoptionsZset_printoptions)rM   rN   optsrC   rC   rD   printoptions   s
    rk   	Magnitudec                  s  e Zd ZU dZdZded< ded< eddd	d
ZeddddZeddddZ	ddddZ
ed;ddddddZed<ddddddZed=ddddddZed>ddddddZd?ddZed d! Zd"d#d$d%d&Zd'dd(d)Zd'dd*d+Zddd,d-Zd.dd/d0Zddd1d2Zd3dd4d5Zed6Zddd7d8d9Z fd:d;Zd@dd<dd=d>d?Zeddd@dAZedddBdCZdddDdEZedFddGdHZedFddIdJZedddKdLZ edddMdNZ!dZ"dOedP< edQddRdSZ#dTddUdVdWZ$e%dAdXddYdZd[Z&e%dBd\dd]d^d_Z'e%d`da Z(dbddcddZ)dedf Z*d<dgd<ddhdidjZ+dkdl Z,dmdn Z-dCdoddpdqZ.dDd'ddrdsZ/doddtduZ0d'ddvdwZ1doddxdyZ2d'ddzd{Z3dodd|d}Z4d'dd~dZ5dEd'dddZ6d3dddZ7ddddZ8ddddZ9e:dd Z;e:dd Z<edddddZ=ed'dddZ=dd Z=dd Z>e>Z?dd Z@dd ZAdd ZBe:eCdFddZDe:eCdGddZEdd ZFdd ZGeGZHdd ZIeIZJdd ZKdd ZLdd ZMeLZNeMZOeKZPdd ZQe:dd ZRe:dd ZSe:dd ZTe:dd ZUe:dd ZVe:dd ZWe:dd ZXe:dd ZYe:d'dddZZe:d'dddZ[d'dddĄZ\dHdddȜddʄZ]d'ddd̄Z^d'ddd΄Z_e:ddЄ Z`e:dd҄ Zae:ddԄ Zbddք Zcddք Zdddք Zeddք ZfddddۄZgegZhdZiddބ Zjdd ZkdddgZldd ZmdIddddZndJddZoddod$ddZpdKddod$ddZqed'dddZred'dddZsedd Ztedd ZueddddZvevjwdd ZvdLddZxdd  Zyezddd Z{dd Z|d3dddZ}d<ddd	Z~d
d Zdd Zdd ZdMddZdddddZeddddZddddZddddZdddddZdNddd d!Zd"dd$d#d$Zd%d& Zd'd( Zd)d* Zed+d, Zed-d. Zd/d0 Zd1d2 Zed3d4 Zed5d6 Zed7d8 Zed9d: Z  ZS (O  Quantitya  Implements a class to describe a physical quantity:
    the product of a numerical value and a unit of measurement.

    Parameters
    ----------
    value : str, pint.Quantity or any numeric type
        Value of the physical quantity to be created.
    units : UnitsContainer, str or pint.Quantity
        Units of the physical quantity to be created.

    Returns
    -------

     r_   default_formatr   rb   bool)returnc             C  s   | j jS )N)rI   force_ndarray)rB   rC   rC   rD   rr      s    zQuantity.force_ndarrayc             C  s   | j jS )N)rI   force_ndarray_like)rB   rC   rC   rD   rs      s    zQuantity.force_ndarray_likezCallable[..., UnitsContainerT]c             C  s   | j jS )N)rI   r8   )rB   rC   rC   rD   r8      s    zQuantity.UnitsContainertuplec             C  s   ddl m} |t| j| jffS )zAllow pickling quantities. Since UnitRegistries are not pickled, upon
        unpickling the new object is always attached to the application registry.
        r   )_unpickle_quantity)rn   ru   rm   	magnitude_units)rB   ru   rC   rC   rD   
__reduce__   s    zQuantity.__reduce__NzOptional[UnitLike]zQuantity[Magnitude])valueunitsrq   c             C  s   d S )NrC   )clsry   rz   rC   rC   rD   __new__   s    zQuantity.__new__r   zQuantity[np.ndarray]c             C  s   d S )NrC   )r{   ry   rz   rC   rC   rD   r|      s    c             C  s   d S )NrC   )r{   ry   rz   rC   rC   rD   r|      s    rl   c             C  s   d S )NrC   )r{   ry   rz   rC   rC   rD   r|      s    c             C  sx  t t|rtdt| |d kr@t|tr@|dkr@td|d krtt|trtt| j}|	|}| | |S |d krt|| rt

|S t | }|d kr| }nt|ttfr|}npt|tr|j|j}nVt|tr t|tr|jdkrt

|j}td n|j}ntdt|t|| rL||j}nt||j|j}||_||_d|_d |_|S )Nz!Quantity cannot wrap upcast type rn   z:Expression to parse as Quantity cannot be an empty string.r   z:Creating new Quantity using a non unity Quantity as units.z>units must be of type str, Quantity or UnitsContainer; not {}.F)r   rU   	TypeErrorrW   r_   
ValueErrorr7   r|   rI   Zparse_expressioncopyr8   r$   parse_unitsrw   rm   rv   r;   Zwarningrd   torb   r   rr   rs   _Quantity__usedZ_Quantity__handling)r{   ry   rz   Zureginstrv   rC   rC   rD   r|      sH    



c             C  s   | j S )N)r   )rB   rC   rC   rD   
debug_used3  s    zQuantity.debug_usedzQuantity[Iterable[S]]zIterator[S])rB   rq   c               s   t j  fdd}| S )Nc              3  s"   x D ]}  | jV  qW d S )N)re   rw   )element)it_magnituderB   rC   rD   it_outer=  s    
z#Quantity.__iter__.<locals>.it_outer)iterrv   )rB   r   rC   )r   rB   rD   __iter__7  s    
zQuantity.__iter__zQuantity[_MagnitudeType]c             C  s"   |  t| j| j}| j|_|S )N)re   r   rb   rw   r   )rB   retrC   rC   rD   __copy__C  s    zQuantity.__copy__c             C  s,   |  t| j|t| j|}| j|_|S )N)re   r   deepcopyrb   rw   r   )rB   memor   rC   rC   rD   __deepcopy__H  s    zQuantity.__deepcopy__c             C  s   | j jd k	r|  S t| S )N)rI   
fmt_localeformat_babelrd   )rB   rC   rC   rD   __str__O  s    zQuantity.__str__bytesc             C  s   t | t S )N)r_   encodelocalegetpreferredencoding)rB   rC   rC   rD   	__bytes__U  s    zQuantity.__bytes__c             C  s>   t | jtr$d| jdd| j dS d| j d| j dS d S )Nz
<Quantity(z.9z, 'z')>)rW   rb   floatrw   )rB   rC   rC   rD   __repr__X  s    zQuantity.__repr__intc             C  s0   |   }|jrt|jS t|j|j|jfS d S )N)to_base_unitsdimensionlesshashrv   re   rz   )rB   Z	self_baserC   rC   rD   __hash__^  s    
zQuantity.__hash__z"([0-9]\.?[0-9]*)e(-?)\+?0*([0-9]+))specrq   c          	   C  s  | j jd k	r| |S |p| j}d|kr>|dd}|  }n| }d|krTd }}n(d|krtd }}t|jr|d}nd }}d|kr|dd}d}t|j	j
|j }d	| }nt|}t|j	|}t|}d|krt|jd
r|j }	nt| jtr`d|}
| jjdkr(d }}|
|j}	n6td|
jid  dt|jdd d }	W d Q R X n6t|jszt|j|}	ndt|j|dd d }	nt| jtrd|krt|j|}	nTd|}
|jjdkr|
|j}	n.td|
jid t|jdd}	W d Q R X nt|j|dd}	d|krB| jd|	}	njd|ksVd|kr| j|	}d|krptndd }|rt|d|d }| jd|| |	}	||kr|dr|dd  }||	| S )N#rn   Lz{}\ {}Hz{} {}z<table><tbody><tr><th>Magnitude</th><td style='text-align:left;'>{}</td></tr><tr><th>Units</th><td style='text-align:left;'>{}</td></tr></tbody></table>ZLxz\SI[%s]{{{}}}{{{}}}_repr_html_z{{:{}}}r   Z
float_kind)	formatterz<pre>
z<br>z</pre>z\1\\times 10^{\2\3}Pc             S  s   d|  dS )Nz<sup>z</sup>rC   )srC   rC   rD   <lambda>      z%Quantity.__format__.<locals>.<lambda>      u   \1×10z1 /)rI   r   r   ro   replace
to_compactr:   rv   r-   rz   rw   r*   rd   r,   hasattrr   rW   r   ndimrk   r+   _exp_patternsubmatchr)   r   group
startswithstrip)rB   r   objZallfZ
plain_allfrj   ZustrZuspecZmspecZmstrr   mZ_exp_formatterexprC   rC   rD   
__format__g  sn    







&


zQuantity.__format__c               s:   |rt  || n"|| j |d || j d S )N )super_repr_pretty_Zprettyrv   textrz   )rB   pcycle)re   rC   rD   r     s
    
zQuantity._repr_pretty_r   )r   kwspecrq   c             K  s   |p| j }d|kr(|dd}|  }n| }t|}d|krJ|d|d< |d| jj}|d krjtdt	||d< |d 
|j|d< dt|jt||jj|f|d	dS )
Nr   rn   lengthZbabel_lengthr   z1Provide a `locale` value to localize translation.Zbabel_plural_formz{} {}r   )ro   r   r   dictpopgetrI   r   r~   r   Zplural_formrv   rd   r,   rz   r   )rB   r   r   r   locrC   rC   rD   r     s"    

zQuantity.format_babelc             C  s   | j S )z'Quantity's magnitude. Long form for `m`)rb   )rB   rC   rC   rD   rv     s    zQuantity.magnitudec             C  s   | j S )z0Quantity's magnitude. Short form for `magnitude`)rb   )rB   rC   rC   rD   r     s    z
Quantity.mc             C  s   |  |jS )zQuantity's magnitude expressed in particular units.

        Parameters
        ----------
        units : pint.Quantity, str or dict
            destination units

        Returns
        -------

        )r   rv   )rB   rz   rC   rC   rD   m_as  s    zQuantity.m_asz'Unit'c             C  s   | j | jS )z#Quantity's units. Long form for `u`)rI   r>   rw   )rB   rC   rC   rD   rz     s    zQuantity.unitsc             C  s   | j | jS )z(Quantity's units. Short form for `units`)rI   r>   rw   )rB   rC   rC   rD   u  s    z
Quantity.uc             C  s   t |  j S )r   )rp   to_root_unitsrw   )rB   rC   rC   rD   unitless  s    zQuantity.unitlessc             C  s   |   }t|j S )r   )r   rp   dimensionality)rB   ZtmprC   rC   rD   r     s    zQuantity.dimensionlesszOptional[UnitsContainerT]_dimensionalityUnitsContainerTc             C  s    | j dkr| j| j| _ | j S )z
        Returns
        -------
        dict
            Dimensionality of the Quantity, e.g. ``{length: 1, time: -1}``
        N)r   rI   Z_get_dimensionalityrw   )rB   rC   rC   rD   r      s    
zQuantity.dimensionalityr   )	dimensionrq   c             C  s   | j | j|kS )zAReturn true if the quantity's dimension matches passed dimension.)r   rI   Zget_dimensionality)rB   r   rC   rC   rD   check-  s    zQuantity.checkzList[Quantity])
quant_listrq   c             C  s   | j ||dS )a\  Transforms a list of Quantities into an numpy.array quantity.
        If no units are specified, the unit of the first element will be used.
        Same as from_sequence.

        If units is not specified and list is empty, the unit cannot be determined
        and a ValueError is raised.

        Parameters
        ----------
        quant_list : list of pint.Quantity
            list of pint.Quantity
        units : UnitsContainer, str or pint.Quantity
            units of the physical quantity to be created (Default value = None)

        Returns
        -------
        pint.Quantity
        )rz   )from_sequence)r{   r   rz   rC   rC   rD   	from_list1  s    zQuantity.from_listzSequence[Quantity])seqrq   c             C  s`   t |}|dkr(|r |d j}ntdt|}x"t|D ]\}}||||< q<W | ||S )aF  Transforms a sequence of Quantities into an numpy.array quantity.
        If no units are specified, the unit of the first element will be used.

        If units is not specified and sequence is empty, the unit cannot be determined
        and a ValueError is raised.

        Parameters
        ----------
        seq : sequence of pint.Quantity
            sequence of pint.Quantity
        units : UnitsContainer, str or pint.Quantity
            units of the physical quantity to be created (Default value = None)

        Returns
        -------
        pint.Quantity
        Nr   z+Cannot determine units from empty sequence!)lenr   r~   r    empty	enumerater   )r{   r   rz   Zlen_seqaiZseq_irC   rC   rD   r   G  s    
zQuantity.from_sequencec             C  s   | |d | j |d S )Nr   r   )rI   r8   )r{   tuprC   rC   rD   
from_tuplej  s    zQuantity.from_tuplez(Tuple[_MagnitudeType, Tuple[Tuple[str]]]c             C  s   | j t| j fS )N)r   rt   rw   items)rB   rC   rC   rD   to_tuplen  s    zQuantity.to_tuplec          	   G  s4   |r&| j j|  | j | jS Q R X | j | jS )N)rI   contextZget_compatible_unitsrw   )rB   contextsrC   rC   rD   compatible_unitsq  s    zQuantity.compatible_unitszUnion[str, Context])rY   r   
ctx_kwargsrq   c             O  sv   |r0y| j |f|| dS  tk
r.   dS X t|| jj| jjfrR| j|jkS t|trp| j| j|jkS | j	S )a  check if the other object is compatible

        Parameters
        ----------
        other
            The object to check. Treated as dimensionless if not a
            Quantity, Unit or str.
        *contexts : str or pint.Context
            Contexts to use in the transformation.
        **ctx_kwargs :
            Values for the Context/s

        Returns
        -------
        bool
        TF)
r   r%   rW   rI   rm   r>   r   r_   r   r   )rB   rY   r   r   rC   rC   rD   is_compatible_withx  s    
zQuantity.is_compatible_withc          	   O  sB   |r.| j j|| | j | j| j|S Q R X | j | j| j|S )N)rI   r   convertrb   rw   )rB   rY   r   r   rC   rC   rD   _convert_magnitude_not_inplace  s    z'Quantity._convert_magnitude_not_inplacec          	   O  sP   |r.| j j|| | j | j| j|S Q R X | j j| j| j|tt| jdS )N)Zinplace)rI   r   r   rb   rw   r   rU   )rB   rY   r   r   rC   rC   rD   _convert_magnitude  s    zQuantity._convert_magnitudeNonec             O  s*   t || j}| j|f||| _|| _dS )aK  Inplace rescale to different units.

        Parameters
        ----------
        other : pint.Quantity, str or dict
            Destination units. (Default value = None)
        *contexts : str or pint.Context
            Contexts to use in the transformation.
        **ctx_kwargs :
            Values for the Context/s
        N)r<   rI   r   rb   rw   )rB   rY   r   r   rC   rC   rD   ito  s    zQuantity.itoc             O  s*   t || j}| j|f||}| ||S )a  Return Quantity rescaled to different units.

        Parameters
        ----------
        other : pint.Quantity, str or dict
            destination units. (Default value = None)
        *contexts : str or pint.Context
            Contexts to use in the transformation.
        **ctx_kwargs :
            Values for the Context/s

        Returns
        -------
        pint.Quantity
        )r<   rI   r   re   )rB   rY   r   r   rv   rC   rC   rD   r     s    zQuantity.toc             C  s(   | j | j\}}| || _|| _dS )z'Return Quantity rescaled to root units.N)rI   _get_root_unitsrw   r   rb   )rB   _rY   rC   rC   rD   ito_root_units  s    zQuantity.ito_root_unitsc             C  s(   | j | j\}}| |}| ||S )z'Return Quantity rescaled to root units.)rI   r   rw   r   re   )rB   r   rY   rv   rC   rC   rD   r     s    
zQuantity.to_root_unitsc             C  s(   | j | j\}}| || _|| _dS )z'Return Quantity rescaled to base units.N)rI   _get_base_unitsrw   r   rb   )rB   r   rY   rC   rC   rD   ito_base_units  s    zQuantity.ito_base_unitsc             C  s(   | j | j\}}| |}| ||S )z'Return Quantity rescaled to base units.)rI   r   rw   r   re   )rB   r   rY   rv   rC   rC   rD   r     s    
zQuantity.to_base_unitsc             C  s   | j r| i S t| jdkr"dS | j }xb| j D ]T\}}||krJq8x@|D ]8}||krP| j||}|rP|||| 	|g}P qPW q8W | |S )zReturn Quantity scaled in place to reduced units, i.e. one unit per
        dimension. This will not reduce compound units (e.g., 'J/kg' will not
        be reduced to m**2/s**2), nor can it make use of contexts at this time.
        r   N)
r   r   r   rw   r   r   rI   Z_get_dimensionality_ratioaddremove)rB   ZnewunitsZunit1r   Zunit2powerrC   rC   rD   rS     s    



zQuantity.ito_reduced_unitsc             C  s   t  | }|  |S )zReturn Quantity scaled in place to reduced units, i.e. one unit per
        dimension. This will not reduce compound units (intentionally), nor
        can it make use of contexts at this time.
        )r   rS   )rB   ZnewqrC   rC   rD   rK     s    
zQuantity.to_reduced_unitsc          	   C  s  t | jtjs,d}t|}tj|dd | S | jsT| jdksTt	| jsTt
| jrX| S i }xd| jj D ]T}y2|jj}tt|}|t|kr|j||< W qj tk
r   d|d< Y qjX qjW t| }dd |D }	dd |D }
|d	krt| }nt| d
|}| |}|j}t|j }dd |D }t|dkrT|d \}}n|d \}}|dkrttt|| d d }n ttt|| d d }t |	|}|t|
krd}|
| }|| }|j!||}| |S )a   "Return Quantity rescaled to compact, human-readable units.

        To get output in terms of a different unit, use the unit parameter.


        Examples
        --------

        >>> import pint
        >>> ureg = pint.UnitRegistry()
        >>> (200e-9*ureg.s).to_compact()
        <Quantity(200.0, 'nanosecond')>
        >>> (1e-2*ureg('kg m/s^2')).to_compact('N')
        <Quantity(10.0, 'millinewton')>
        zDto_compact applied to non numerical types has an undefined behavior.r   )
stacklevelr   rn   c             S  s   g | ]}|d  qS )r   rC   ).0itemrC   rC   rD   
<listcomp>S  s    z'Quantity.to_compact.<locals>.<listcomp>c             S  s   g | ]}|d  qS )r   rC   )r   r   rC   rC   rD   r   T  s    Nr   c             S  s   g | ]}|d  dkr|qS )r   r   rC   )r   r   rC   rC   rD   r   `  s    r   )"rW   rv   numbersNumberRuntimeWarningwarningswarnr   mathisnanZisinfrI   Z	_prefixesvaluesZ	converterscaler   Zlog10name	Exceptionsortedr   r9   re   r   rX   rw   r   ZfloorabsZceilbisectZbisect_leftrename)rB   unitrf   wZSI_prefixesprefixr   Zlog10_scaleZSI_prefixes_listZ	SI_powersZSI_basesZq_baserv   rz   Zunits_numeratorZunit_strZ
unit_powerr   indexZ
prefix_strZnew_unit_strZnew_unit_containerrC   rC   rD   r   %  sT    



" zQuantity.to_compactc             C  s&   | j rt| t S t| jdd S )Nr   )r   r   r   r8   r%   rw   )rB   rC   rC   rD   __int__y  s    zQuantity.__int__r   c             C  s&   | j rt| t S t| jdd S )Nr   )r   r   r   r8   r%   rw   )rB   rC   rC   rD   	__float__~  s    zQuantity.__float__complexc             C  s&   | j rt| t S t| jdd S )Nr   )r   r  r   r8   r%   rw   )rB   rC   rC   rD   __complex__  s    zQuantity.__complex__c             C  s  |  |syt|| j| j}W n( tk
r4    Y n tk
rF   tS X t|drb|| j|| _n0| j	r| 
|   || j|| _nt| jd| S | j|jkst| j|j| j|j|  }t|dk}t|dkr|d }| }t|dk}t|dkr
|d }	|r|r| j|jkr6|| j|j| _nL|  rj| sj|| |j|j| _|j| _n|| j|| jj| _n|tjkrt|dkr| j| dkr||s| j|jkr|| j|j| _n|| j|| jj| _| j|d| | _n|tjkr\t|dkr\|j|	 dkr\| |	s\|| j|| jj| _nt|dkr| j| dkr||r| j|d| }
|| j||
j| _nht|dkr
|j|	 dkr
| |	r
|j|	d|	 }
|| |
|j| _|j| _nt| j|j| S )aV  Perform addition or subtraction operation in-place and return the result.

        Parameters
        ----------
        other : pint.Quantity or any type accepted by :func:`_to_magnitude`
            object to be added to / subtracted from self
        op : function
            operator function (e.g. operator.add, operator.isub)

        Tr   r   r   delta_)_checkr   rr   rs   r'   r}   rV   r#   rb   r   r   r8   r%   rw   r   _get_non_multiplicative_unitsr   _get_delta_unitsr   r   operatorisub_has_compatible_deltar   r&   )rB   rY   opother_magnitudeself_non_mul_unitsis_self_multiplicativeself_non_mul_unitother_non_mul_unitsis_other_multiplicativeother_non_mul_unitturC   rC   rD   	_iadd_sub  sz    



zQuantity._iadd_subc             C  s  |  |szt|dr4| j}|| jt|| j| j}n:| jrb|  }|| 	|jt|| j| j}nt
| jd| ||S | j|jkst
| j|j| j|j|  }t|dk}t|dkr|d }| }t|dk}	t|dkr|d }
|rl|	rl| j|jkr|| j|j}| j}nL|  rL| sL|| |j|j}|j}n| j}|| j|	| jj}n|tjkrt|dkr| j| dkr||s| j|jkr|| j|j}n|| j|	| jj}| j|d| }n|tjkr@t|dkr@|j|
 dkr@| |
s@|| j|	| jj}| j}nt|dkr| j| dkr||r| j|d| }|| j|	|j}| j}ndt|dkr|j|
 dkr| |
r|j|
d|
 }|| ||j}|j}nt| j|j| ||S )aL  Perform addition or subtraction operation and return the result.

        Parameters
        ----------
        other : pint.Quantity or any type accepted by :func:`_to_magnitude`
            object to be added to / subtracted from self
        op : function
            operator function (e.g. operator.add, operator.isub)
        Tr   r   r   r	  )r
  r#   rw   rb   r   rr   rs   r   r8   r   r%   re   r   r  r   r  r   rv   r  r   r  r   r&   )rB   rY   r  rz   rv   r  r  r  r  r  r  r  rC   rC   rD   _add_sub  s|    


zQuantity._add_subzdatetime.datetimezdatetime.timedelta)rY   rq   c             C  s   d S )NrC   )rB   rY   rC   rC   rD   __iadd__j  s    zQuantity.__iadd__c             C  s   d S )NrC   )rB   rY   rC   rC   rD   r  n  s    c             C  sF   t |tjr|  | S tt| jr4| |tjS | 	|tj
S d S )N)rW   datetimeto_timedeltar   rU   rb   r  r  iaddr  r   )rB   rY   rC   rC   rD   r  r  s
    c             C  s*   t |tjr|  | S | |tjS d S )N)rW   r  r  r  r  r   )rB   rY   rC   rC   rD   __add__z  s    zQuantity.__add__c             C  s.   t t| jr| |tjS | |tjS d S )N)r   rU   rb   r  r  r  r  r   )rB   rY   rC   rC   rD   __isub__  s    zQuantity.__isub__c             C  s   |  |tjS )N)r  r  r   )rB   rY   rC   rC   rD   __sub__  s    zQuantity.__sub__c             C  s,   t |tjr||   S | |tj S d S )N)rW   r  r  r  r  r   )rB   rY   rC   rC   rD   __rsub__  s    zQuantity.__rsub__c             C  s  |dkr|}|   }t|}| |s| |sDt| jt|ddt|dkr| j|d  dksr|tjtj	gkrt| jt|ddyt
|| j| j}W n( tk
r    Y n tk
r   tS X || j|| _|| j|  | _| S t|| jjr d| }| |st| j|jn"|dkr>t| jdkr>|   t|  }||sft| j|jn"|dkrt|jdkr|  || j|j| _|| j|j| _| S )aA  Perform multiplication or division operation in-place and return the
        result.

        Parameters
        ----------
        other : pint.Quantity or any type accepted by :func:`_to_magnitude`
            object to be multiplied/divided with self
        magnitude_op : function
            operator function to perform on the magnitudes
            (e.g. operator.mul)
        units_op : function or None
            operator function to perform on the units; if None,
            *magnitude_op* is used (Default value = None)

        Returns
        -------

        Nrz   rn   r   r   )r  r   r
  _ok_for_muldivr&   rw   r`   r  mulimulr   rr   rs   r'   r}   rV   rb   r8   rW   rI   r>   r   )rB   rY   magnitude_opunits_opoffset_units_selfno_offset_units_selfr  no_offset_units_otherrC   rC   rD   	_imul_div  sJ    


zQuantity._imul_divc             C  s  |dkr|}|   }t|}| |s| |sDt| jt|ddt|dkr| j|d  dksr|tjtj	gkrt| jt|ddyt
|| j| j}W n( tk
r    Y n tk
r   tS X || j|}|| j|  }| ||S t|| jjrd| }| }	| |s$t| j|jn"|dkrFt| jdkrF|  }	t|  }
||
snt| j|jn"|
dkrt|jdkr| }||	j|j}||	j|j}| ||S )a0  Perform multiplication or division operation and return the result.

        Parameters
        ----------
        other : pint.Quantity or any type accepted by :func:`_to_magnitude`
            object to be multiplied/divided with self
        magnitude_op : function
            operator function to perform on the magnitudes
            (e.g. operator.mul)
        units_op : function or None
            operator function to perform on the units; if None,
            *magnitude_op* is used (Default value = None)

        Returns
        -------

        Nrz   rn   r   r   )r  r   r
  r#  r&   rw   r`   r  r$  r%  r   rr   rs   r'   r}   rV   rb   r8   re   rW   rI   r>   r   )rB   rY   r&  r'  r(  r)  r  rv   rz   new_selfr*  rC   rC   rD   _mul_div  sL    


zQuantity._mul_divc             C  s.   t t| jr| |tjS | |tjS d S )N)r   rU   rb   r+  r  r%  r-  r$  )rB   rY   rC   rC   rD   __imul__"  s    zQuantity.__imul__c             C  s   |  |tjS )N)r-  r  r$  )rB   rY   rC   rC   rD   __mul__(  s    zQuantity.__mul__c             C  s   t | |S )N)r    matmul)rB   rY   rC   rC   rD   
__matmul__-  s    zQuantity.__matmul__c             C  s.   t t| jr| |tjS | |tjS d S )N)r   rU   rb   r+  r  itruedivr-  truediv)rB   rY   rC   rC   rD   __itruediv__2  s    zQuantity.__itruediv__c             C  s   |  |tjS )N)r-  r  r3  )rB   rY   rC   rC   rD   __truediv__8  s    zQuantity.__truediv__c             C  s   yt || j| j}W n( tk
r*    Y n tk
r<   tS X t|  }| |sbt	| j
dn|dkrt| j
dkr|  } | || j d| j
 S )Nrn   r   )r   rr   rs   r'   r}   rV   r   r  r#  r&   rw   r   re   rb   )rB   rY   r  r)  rC   rC   rD   __rtruediv__;  s    
zQuantity.__rtruediv__c             C  sZ   |  |r$|  j|| jj  _n&| jr>| dj| | _nt| jd| i | _| S )Nrn   r   )r
  rb   r   rw   r   r%   r8   )rB   rY   rC   rC   rD   __ifloordiv__Q  s    
zQuantity.__ifloordiv__c             C  sV   |  |r | j|| jj }n$| jr8| dj| }nt| jd| || i S )Nrn   r   )r
  rb   r   rw   r   r%   re   r8   )rB   rY   rv   rC   rC   rD   __floordiv__[  s    
zQuantity.__floordiv__c             C  sV   |  |r |j| |jj }n$| jr8|| dj }nt| jd| || i S )Nrn   r   )r
  rb   r   rw   r   r%   re   r8   )rB   rY   rv   rC   rC   rD   __rfloordiv__e  s    
zQuantity.__rfloordiv__c             C  s8   |  |s| || i }|  j|| jj;  _| S )N)r
  re   r8   rb   r   rw   )rB   rY   rC   rC   rD   __imod__o  s    
zQuantity.__imod__c             C  s>   |  |s| || i }| j|| jj }| || jS )N)r
  re   r8   rb   r   rw   )rB   rY   rv   rC   rC   rD   __mod__v  s    
zQuantity.__mod__c             C  sd   |  |r,|j| |jj }| ||jS | jrT|| dj }| || i S t| jdd S )Nrn   r   )r
  rb   r   rw   re   r   r8   r%   )rB   rY   rv   rC   rC   rD   __rmod__}  s    
zQuantity.__rmod__c             C  sV   |  |s| || i }t| j|| jj\}}| || i | || jfS )N)r
  re   r8   divmodrb   r   rw   )rB   rY   qrrC   rC   rD   
__divmod__  s
    
zQuantity.__divmod__c             C  s~   |  |r,t|j| |jj\}}|j}n4| jrTt|| dj\}}| i }nt| jd| || i | ||fS )Nrn   r   )	r
  r=  rb   r   rw   r   r8   r%   re   )rB   rY   r>  r?  r  rC   rC   rD   __rdivmod__  s    
zQuantity.__rdivmod__c             C  s  t t| js| |S yt|| j| j W n* tk
rD    Y n tk
rV   t	S X | j
sht| jt tt|d|r| jrt|ddr| d|d | _|  | _| S t|ddst|jdn| d| | _|  | _| S n t|dkrt| jddd|dkr| S |d	kr2|  | _nx| jsX| jjrN|   n
t| jt|ddr| j}|  j|C  _n*t|ddst| jdn|  j|C  _|  jt|| j| jC  _| S d S )
Nrb   r   Frn   Tr   zH. Quantity array exponents are only allowed if the base is dimensionless)	extra_msgr   )r   rU   rb   __pow__r   rr   rs   r'   r}   rV   r#  r&   rw   r`   r   r   r8   r%   r    size_is_multiplicativerI   autoconvert_offset_to_baseunitr   r   rv   )rB   rY   rC   rC   rD   __ipow__  sV    









zQuantity.__ipow__c             C  s  yt || j| j W n* tk
r,    Y nx tk
r>   tS X | jsPt| jt	t
t|d|r| jrt|ddr| | |  |d S t|ddst|jdq| | |  | S nt|dkrt| jddd| }|dk r| S |d	krd	}|  }n~| js6| jjr,|  }n
t| jt|ddrZ| j}|j| }n4t|ddsvt|jdnt |ddd
}|j| }|j| }| ||S d S )Nrb   r   Frn   Tr   zH. Quantity array exponents are only allowed if the base is dimensionless)rB  r   )rr   rs   )r   rr   rs   r'   r}   rV   r#  r&   rw   r   rU   r`   r   re   r   r8   r   r%   r    rD  rE  rI   rF  r   rv   rb   )rB   rY   r,  Zexponentrz   rv   rC   rC   rD   rC    sX    










zQuantity.__pow__c             C  sf   yt || j| j W n( tk
r*    Y n8 tk
r<   tS X | jsPt| jd| 	 }||j
 S d S )Nr   )r   rr   rs   r'   r}   rV   r   r%   rw   r   rb   )rB   rY   r,  rC   rC   rD   __rpow__  s    zQuantity.__rpow__c             C  s   |  t| j| jS )N)re   r   rb   rw   )rB   rC   rC   rD   __abs__-  s    zQuantity.__abs__r   zOptional[int]zQuantity[int])ndigitsrq   c             C  s   |  t| j|d| jS )N)rJ  )re   roundrb   rw   )rB   rJ  rC   rC   rD   	__round__0  s    zQuantity.__round__c             C  s   |  t| j| jS )N)re   r  posrb   rw   )rB   rC   rC   rD   __pos__3  s    zQuantity.__pos__c             C  s   |  t| j| jS )N)re   r  negrb   rw   )rB   rC   rC   rD   __neg__6  s    zQuantity.__neg__c               s    fdd}t  ts~t drZjr6tj dS jjrPt j dS t	j
jrvt  dS |dS tjddrt jddr|j jkS j
 j
krtj jdS yt j
 jdS  tk
 r   |dS X d S )Nc               sF   t tjs| S t tr" j tj \}}tj|| tjdS )N)Z
fill_valueZdtype)	r   rU   rb   rW   rm   r    Zbroadcast_arraysZ	full_likeZbool_)ry   templater   )rY   rB   rC   rD   bool_result;  s    
z$Quantity.__eq__.<locals>.bool_resultTFr   )rW   rm   r#   rE  r   rb   rI   rF  r   r&   rw   r   r   r8   r   r%   )rB   rY   rR  rC   )rY   rB   rD   __eq__9  s2    



zQuantity.__eq__c             C  s&   |  |}tt|r t|S | S )N)rS  r   rU   r    Zlogical_not)rB   rY   outrC   rC   rD   __ne__q  s    

zQuantity.__ne__c             C  s   t |tsv| jr$|| |  |S t|drd| jr@|| j|S | jj	rX|| 
 j|S t| jntdt|| j|jk	rd}t|| jj|jj| j|jkr|| j|jS | j|jkrt| j|j| j|j||  j| jS )NTzCannot compare Quantity and {}z6Cannot operate with {} and {} of different registries.)rW   rm   r   r   r8   r#   rE  rb   rI   rF  r   r&   rw   r~   rd   rU   re   rF   r   r%   r   rv   )rB   rY   r  ZmessrC   rC   rD   comparex  s*    

zQuantity.comparec             C  s   | j |tjdS )N)r  )rV  r  lt)rB   rY   rC   rC   rD   r     r   zQuantity.<lambda>c             C  s   | j |tjdS )N)r  )rV  r  le)rB   rY   rC   rC   rD   r     r   c             C  s   | j |tjdS )N)r  )rV  r  ge)rB   rY   rC   rC   rD   r     r   c             C  s   | j |tjdS )N)r  )rV  r  gt)rB   rY   rC   rC   rD   r     r   c             C  s   | j rt| jS tdd S )Nz8Boolean value of Quantity with offset unit is ambiguous.)rE  rp   rb   r~   )rB   rC   rC   rD   __bool__  s    
zQuantity.__bool__   c             O  s>   |dkrt S tdd t|t|  D }td||||S )N__call__c             s  s    | ]}t |d rt|V  qdS )__array_ufunc__N)r   rU   )r   argrC   rC   rD   	<genexpr>  s   z+Quantity.__array_ufunc__.<locals>.<genexpr>ufunc)rV   setrX   r   r3   )rB   ra  methodZinputsrN   typesrC   rC   rD   r^    s    zQuantity.__array_ufunc__c             C  s   t d||||S )NZfunction)r3   )rB   r\   rd  rM   rN   rC   rC   rD   __array_function__  s    zQuantity.__array_function__ZflattenZastyper   c             O  s   |j tkr| t|j  d  |||}|j tt | j krD| j}nj|j tkr^t|j  d }nP|j tkrtt|j  }n:|j tkrt	t|j  | j
t|t|  | jj}nd}|dk	r| ||S |S dS )zfConvenience method to wrap on the fly NumPy ndarray methods taking
        care of the units.
        r   r   N)rF   r5   _Quantity__ito_if_neededr1   r/   _wrapped_numpy_methodsrw   r2   r4   r0   rz   rX   r   rb   rD  re   )rB   r\   rM   rN   ry   Zoutput_unitrC   rC   rD   _numpy_method_wrap  s(    




zQuantity._numpy_method_wrapz
np.ndarrayc             C  s   t jdtdd t| jddS )NzAThe unit of the quantity is stripped when downcasting to ndarray.r   )r   T)rr   )r   r   r(   r   rb   )rB   trC   rC   rD   	__array__  s
    zQuantity.__array__c             K  s   |d k	r6t || jr"|| j}n| jr*ntd| j|d k	rlt || jrX|| j}n| jr`ntd| j| | jj|||f|| jS )Nr   )rW   re   r   rv   r   r%   rw   clip)rB   minmaxrT  rN   rC   rC   rD   rk    s    zQuantity.clipc             C  s   |j | _ | j|jS )N)rw   rv   fill)rB   ry   rC   rC   rD   rn    s    zQuantity.fillraisec             C  sT   t || jr|| j}n&| jr4| |d| }ntd| j| j||| d S )Nrn   r   )rW   re   r   rv   r   r%   rw   put)rB   indicesr   moderC   rC   rD   rp    s    zQuantity.putc             C  s   |  | jj| jS )N)re   rb   realrw   )rB   rC   rC   rD   rs    s    zQuantity.realc             C  s   |  | jj| jS )N)re   rb   imagrw   )rB   rC   rC   rD   rt    s    zQuantity.imagc             C  s   |  | jj| jS )N)re   rb   Trw   )rB   rC   rC   rD   ru    s    z
Quantity.Tc             c  s&   x | j jD ]}| || jV  q
W d S )N)rb   flatre   rw   )rB   vrC   rC   rD   rv    s    zQuantity.flatr   c             C  s   | j jS )N)rb   shape)rB   rC   rC   rD   rx     s    zQuantity.shapec             C  s   || j _d S )N)rb   rx  )rB   ry   rC   rC   rD   rx  $  s    leftc             C  sN   t || jr|| j}n&| jr4| |d| }ntd| j| j||S )Nrn   r   )rW   re   r   rv   r   r%   rw   searchsorted)rB   rw  ZsideZsorterrC   rC   rD   rz  (  s    zQuantity.searchsortedc             C  s   t | |S )z<Dot product of two arrays.

        Wraps np.dot().
        )r    dot)rB   brC   rC   rD   r{  1  s    zQuantity.dotprodc             O  s   t j| f||S )z\Return the product of quantity elements over a given axis

        Wraps np.prod().
        )r    r}  )rB   rM   rN   rC   rC   rD   r}  9  s    zQuantity.prodc             C  s    | j r|dkrd S | | d S )NZradian)r   r   )rB   Zto_unitsrC   rC   rD   Z__ito_if_neededA  s    zQuantity.__ito_if_neededc             C  s
   t | jS )N)r   rb   )rB   rC   rC   rD   __len__G  s    zQuantity.__len__c          
   C  s  | drtd| dn|tks.|| jkrt| jdd}yt||}t| j	|S  tk
r   td| dt
| Y nL tk
r } z.dt|krtd| d	t
| n|W d d }~X Y nX yt| j|S  tk
r    td
| j|Y nX d S )NZ__array_zArray protocol attribute z not available.T)rs   zNumPy method z not available on znot callablez not callable on zANeither Quantity object nor its magnitude ({}) has attribute '{}')r   rL   r.   rg  r   rb   r`   rg   partialrh  rU   r}   r_   rd   )rB   r   Zmagnitude_as_duck_arrayattrexcrC   rC   rD   __getattr__J  s,    

zQuantity.__getattr__c             C  sT   yt | | j| | jS  tk
r,    Y n$ tk
rN   td| jY nX d S )Nz?Neither Quantity object nor its magnitude ({})supports indexing)rU   rb   rw   r'   r}   rd   )rB   keyrC   rC   rD   __getitem__i  s    zQuantity.__getitem__c          
   C  s  y(t j|st|r&|| j|< d S W n tk
r<   Y nX yt|| jrh| |j	|j
| j
  }n| || j
d  }t|| jr|jst|| jd| d| dd|j	| j|< n
|| j|< W nL tk
r    Y n8 tk
r } ztd| j d|W d d }~X Y nX d S )Nr   zd. Assign a quantity with the same dimensionality or access the magnitude directly as `obj.magnitude[z] = z`.)rB  z+Neither Quantity object nor its magnitude (z) supports indexing)r    ZmaZ	is_maskedr   r   rb   r}   rW   re   rv   rw   r   r   r%   rz   r'   )rB   r  ry   Zfactorr  rC   rC   rD   __setitem__t  s2    
zQuantity.__setitem__c               sr    j y: j }t|ts( |S  fdd j D S  tk
rl   tdt jj dY nX d S )Nc               s2   g | ]*}t |tr" | n
 |qS rC   )rW   rX   re   tolist)r   ry   )rB   rz   rC   rD   r     s   z#Quantity.tolist.<locals>.<listcomp>zMagnitude 'z' does not support tolist.)	rw   rb   r  rW   rX   re   rL   rU   rF   )rB   r   rC   )rB   rz   rD   r    s    

zQuantity.tolistFc             C  sZ   t || jr.|rtd||| jj}n|r@|t| j }| j	t

| j|| jS )Nz!{} is not a valid relative error.)rW   re   r~   rd   r   rw   rv   r   rI   ZMeasurementr   )rB   errorZrelativerC   rC   rD   
plus_minus  s    zQuantity.plus_minusr$   )r  rq   c             C  s:   y| j j| S  tk
r4   | j | | j j| S X d S )N)rI   rw   KeyErrorr   )rB   r  rC   rC   rD   _get_unit_definition  s
    zQuantity._get_unit_definitionc             C  s
   |    S )z;Check if the Quantity object has only multiplicative units.)r  )rB   rC   rC   rD   rE    s    zQuantity._is_multiplicativez	List[str]c               s    fdd j D S )zHReturn a list of the of non-multiplicative units of the Quantity object.c               s   g | ]}  |js|qS rC   )r  Zis_multiplicative)r   r  )rB   rC   rD   r     s   z:Quantity._get_non_multiplicative_units.<locals>.<listcomp>)rw   )rB   rC   )rB   rD   r    s    
z&Quantity._get_non_multiplicative_unitsc             C  s   dd | j D S )z2Return list of delta units ot the Quantity object.c             S  s   g | ]}| d r|qS )r	  )r   )r   r   rC   rC   rD   r     s    z-Quantity._get_delta_units.<locals>.<listcomp>)rw   )rB   rC   rC   rD   r    s    zQuantity._get_delta_unitsc               s<     }d| |krdS |j t fdd|D S )zH "Check if Quantity object has a delta_unit that is compatible with unitr	  Tc             3  s   | ]} |j kV  qd S )N)r  	reference)r   d)offset_unit_dimrB   rC   rD   r`    s    z1Quantity._has_compatible_delta.<locals>.<genexpr>)r  r  r  any)rB   r  ZdeltasrC   )r  rB   rD   r    s    zQuantity._has_compatible_deltac             C  sv   d}|dkrt |  }|dkr$d}|dkrrt | jdkr>d}t | jdkrX| jjsXd}tt| j dkrrd}|S )z6Checks if Quantity object can be multiplied or dividedTNr   F)r   r  rw   rI   rF  nextr   r   )rB   Zno_offset_unitsZis_okrC   rC   rD   r#    s    zQuantity._ok_for_muldivzQuantity[float]c             C  s   t j| djdS )Nmicroseconds)r  )r  Z	timedeltar   rv   )rB   rC   rC   rD   r    s    zQuantity.to_timedeltac             C  s    t | jtjr| j S d S d S )N)rW   rb   r   rc   __dask_graph__)rB   rC   rC   rD   r    s    
zQuantity.__dask_graph__c             C  s
   | j  S )N)rb   __dask_keys__)rB   rC   rC   rD   r    s    zQuantity.__dask_keys__c             C  s   ddl m} t|| j| jfS )Nr   )tokenize)Z	dask.baser  rm   rb   rz   )rB   r  rC   rC   rD   __dask_tokenize__  s    zQuantity.__dask_tokenize__c             C  s   t jjS )N)r   rc   __dask_optimize__)rB   rC   rC   rD   r    s    zQuantity.__dask_optimize__c             C  s   t jjS )N)r   rc   __dask_scheduler__)rB   rC   rC   rD   r  
  s    zQuantity.__dask_scheduler__c             C  s    | j  \}}| j||| jffS )N)rb   __dask_postcompute___dask_finalizerz   )rB   r\   rM   rC   rC   rD   r    s    zQuantity.__dask_postcompute__c             C  s    | j  \}}| j||| jffS )N)rb   __dask_postpersist__r  rz   )rB   r\   rM   rC   rC   rD   r    s    zQuantity.__dask_postpersist__c             C  s   || f| }t ||S )N)rm   )resultsr\   rM   rz   r   rC   rC   rD   r    s    zQuantity._dask_finalizec             K  s   t | f|\}|S )a  Compute the Dask array wrapped by pint.Quantity.

        Parameters
        ----------
        **kwargs : dict
            Any keyword arguments to pass to ``dask.compute``.

        Returns
        -------
        pint.Quantity
            A pint.Quantity wrapped numpy array.
        )r   )rB   rN   rO   rC   rC   rD   r     s    zQuantity.computec             K  s   t | f|\}|S )a  Persist the Dask Array wrapped by pint.Quantity.

        Parameters
        ----------
        **kwargs : dict
            Any keyword arguments to pass to ``dask.persist``.

        Returns
        -------
        pint.Quantity
            A pint.Quantity wrapped Dask array.
        )r!   )rB   rN   rO   rC   rC   rD   r!   ,  s    zQuantity.persistc             K  s   t | f| dS )a  Produce a visual representation of the Dask graph.

        The graphviz library is required.

        Parameters
        ----------
        **kwargs : dict
            Any keyword arguments to pass to ``dask.visualize``.

        Returns
        -------

        N)r"   )rB   rN   rC   rC   rD   r"   =  s    zQuantity.visualize)N)N)N)N)N)rn   )N)N)N)N)N)N)N)r   )N)NNN)ro  )ry  N)F)N)rF   rG   rH   __doc__ro   __annotations__propertyrr   rs   r8   rx   r   r|   r   r   r   r   r   r   r   r   recompiler   r   r   r   rv   r   r   rz   r   r   r   r   r   r   classmethodr   r   r   r   r   r   r   r   r   r   r   r   r   r   rS   rK   r   r  r  r  rZ   r  r  r  r  __radd__r   r!  r"  rT   r+  r-  r.  r/  __rmul__r1  __rmatmul__r4  r5  r6  Z__div__Z__rdiv__Z__idiv__r7  r8  r9  r:  r;  r<  r@  rA  rG  rC  rH  rI  rL  rN  rP  rS  rU  rV  __lt____le____ge____gt__r[  Z__nonzero__Z__array_priority__r^  re  rg  rh  rj  rk  rn  rp  rs  rt  ru  rv  rx  setterrz  r{  ra   r}  rf  r~  r  r  r  r  r  r  rE  r  r  r  r#  r  r  r  r  r  r  r  r  staticmethodr  ri   r   r!   r"   __classcell__rC   rC   )re   rD   rm      s4  

4
i"$
	
	TqqEH



@A8&
%		
%rm   r?   zType[Quantity])registryrq   c               s   G  fdddt }|S )Nc                  s   e Zd Z ZdS )z&build_quantity_class.<locals>.QuantityN)rF   rG   rH   rI   rC   )r  rC   rD   rm   S  s   rm   )	_Quantity)r  rm   rC   )r  rD   build_quantity_classR  s    r  )dr  Z
__future__r   r   
contextlibr   r  rg   r   r   r   r  r  r   typingr   r   r   r   r   r   r	   r
   r   r   r   r   r   r   r   Z_typingr   r   r   r   compatr   r   r   r   r   r   r   r   r   r    r!   r"   r#   Zdefinitionsr$   errorsr%   r&   r'   r(   Z
formattingr)   r*   r+   r,   r-   r]   r.   r/   r0   r1   r2   r3   r4   r5   utilr6   r7   r8   r9   r:   r;   r<   rn   r=   r>   r  r?   r  r   Znumpyr   r@   rR   rT   rZ   ra   ri   contextmanagerrk   rl   rm   r  r  rC   rC   rC   rD   <module>   sh   D<(
$
               !