ó
¦–Õ\c           @` s±  d  d l  m Z m Z m Z d  d l m Z d  d l m Z d  d l m	 Z	 d  d l
 m Z m Z m Z m Z d  d l m Z d d l m Z m Z d d	 l m Z m Z m Z m Z m Z d
 d l m Z d
 d l m Z d
 d l m Z d
 d l m  Z  d „  Z! d  d  d „ Z# d „  Z$ d  d „ Z% d  d „ Z& d „  Z' d „  Z( d „  Z) d „  Z* d „  Z+ d „  Z, d  d  d „ Z- d „  Z. d „  Z/ d  e0 d „ Z1 d „  Z2 d „  Z3 d  S(!   i    (   t   absolute_importt   divisiont   print_function(   t   getitem(   t   product(   t   Integral(   t   merget   pipet   concatt   partial(   t   mapi   (   t   chunkt   wrap(   t   Arrayt
   map_blockst   concatenatet   concatenate3t   reshapelisti   (   t   HighLevelGraph(   t   tokenize(   t   flatten(   t   concretec         C` s=  |  d f t  d „  |  d Dƒ ƒ } g  } xØ t t |  d | d ƒ ƒ D]¹ \ } \ } } | j | d ƒ } | | k r• | j t d d d ƒ ƒ qI | | k  rº | j t d | ƒ ƒ qI | | k rë | d k rë | j t d d ƒ ƒ qI | j t | d ƒ ƒ qI Wt  | ƒ } t d „  | Dƒ ƒ r,|  St | | f Sd S(   sƒ  

    >>> fractional_slice(('x', 5.1), {0: 2})  # doctest: +SKIP
    (getitem, ('x', 6), (slice(0, 2),))

    >>> fractional_slice(('x', 3, 5.1), {0: 2, 1: 3})  # doctest: +SKIP
    (getitem, ('x', 3, 5), (slice(None, None, None), slice(-3, None)))

    >>> fractional_slice(('x', 2.9, 5.1), {0: 2, 1: 3})  # doctest: +SKIP
    (getitem, ('x', 3, 5), (slice(0, 2), slice(-3, None)))
    i    c         s` s!   |  ] } t  t | ƒ ƒ Vq d  S(   N(   t   intt   round(   t   .0t   i(    (    s1   lib/python2.7/site-packages/dask/array/overlap.pys	   <genexpr>   s    i   c         s` s'   |  ] } | t  d  d  d  ƒ k Vq d  S(   N(   t   slicet   None(   R   t   ind(    (    s1   lib/python2.7/site-packages/dask/array/overlap.pys	   <genexpr>.   s    N(	   t   tuplet	   enumeratet   zipt   gett   appendR   R   t   allR   (   t   taskt   axest   roundedt   indexR   t   tt   rt   depth(    (    s1   lib/python2.7/site-packages/dask/array/overlap.pyt   fractional_slice   s    %0c         ` sQ  ‡  f d †  } g  } xk t  |  d ƒ D]Y \ } } d } | d k rQ | d 7} n  | ˆ  | d k  rr | d 7} n  | j | ƒ q& Wg  t  |  d ƒ D]6 \ } } | j | d ƒ rÁ | | | ƒ n | g ^ q” }	 | d k	 rï | g g |	 }	 n  t t |	 Œ  ƒ }
 g  t  | ƒ D]* \ } } | j | d ƒ r2| n d ^ q} t | |
 ƒ } | S(   sˆ   Get all neighboring keys around center

    Parameters
    ----------
    k: tuple
        They key around which to generate new keys
    dims: Sequence[int]
        The number of chunks in each dimension
    name: Option[str]
        The name to include in the output keys, or none to include no name
    axes: Dict[int, int]
        The axes active in the expansion.  We don't expand on non-active axes

    Examples
    --------
    >>> expand_key(('x', 2, 3), dims=[5, 5], name='y', axes={0: 1, 1: 1})  # doctest: +NORMALIZE_WHITESPACE
    [[('y', 1.1, 2.1), ('y', 1.1, 3), ('y', 1.1, 3.9)],
     [('y',   2, 2.1), ('y',   2, 3), ('y',   2, 3.9)],
     [('y', 2.9, 2.1), ('y', 2.9, 3), ('y', 2.9, 3.9)]]

    >>> expand_key(('x', 0, 4), dims=[5, 5], name='y', axes={0: 1, 1: 1})  # doctest: +NORMALIZE_WHITESPACE
    [[('y',   0, 3.1), ('y',   0,   4)],
     [('y', 0.9, 3.1), ('y', 0.9,   4)]]
    c         ` sg   g  } | d d k r* | j  | d ƒ n  | j  | ƒ | d ˆ  |  d k  rc | j  | d ƒ n  | S(   NgÍÌÌÌÌÌì?i    i   (   R!   (   R   R   t   rv(   t   dims(    s1   lib/python2.7/site-packages/dask/array/overlap.pyt   indsM   s    i   i    N(   R   R!   R    R   t   listR   R   (   t   kR,   t   nameR$   R-   t   shapeR   R   t   numt   argst   seqt   dt   shape2t   result(    (   R,   s1   lib/python2.7/site-packages/dask/array/overlap.pyt
   expand_key4   s     	M=c         C` sD  t  t t |  j ƒ ƒ } t t d | d | ƒ} t |  j ƒ  t t | ƒ t t ƒ t	 t  ƒ } d t
 |  | ƒ } d t
 |  | ƒ } i  } i  } x™ | D]‘ }	 t |  j f |	 | ƒ }
 |  j f |	 |
 k rß |
 | | f |	 <q– |  j f |	 | | f |	 <t t | d |	 d | ƒf f | | f |	 <q– Wg  } xÍ t |  j ƒ D]¼ \ } } t | ƒ d k ro| j | ƒ qA| d | j | d ƒ g } | d | j | d ƒ g } g  } x6 | d d !D]' } | j | | j | d ƒ d	 ƒ q½W| j | | | ƒ qAWt | | ƒ } t j | | d
 |  g ƒ} t | | | d |  j ƒS(   sK   Share boundaries between neighboring blocks

    Parameters
    ----------

    x: da.Array
        A dask array
    axes: dict
        The size of the shared boundary per axis

    The axes input informs how many cells to overlap between neighboring blocks
    {0: 2, 2: 5} means share two cells in 0 axis, 5 cells in 2 axis
    R,   R$   s   overlap-s   getitem-R0   i   i    iÿÿÿÿi   t   dependenciest   dtypeN(   N(   R.   R
   t   lent   chunksR	   R8   R   t   __dask_keys__R   R   R   R*   R0   R   R   R   R   R!   R    R   R   t   from_collectionsR   R:   (   t   xR$   R,   t   expand_key2t   interior_keysR0   t   getitem_namet   interior_slicest   overlap_blocksR/   t
   frac_sliceR<   R   t   bdst   leftt   rightt   midt   bdt   dskt   graph(    (    s1   lib/python2.7/site-packages/dask/array/overlap.pyt   overlap_internalh   s8    .%c         C` s:   t  |  j | ƒ } t |  j | ƒ } t |  d | d | ƒS(   sÈ   Trim sides from each block.

    This couples well with the ``map_overlap`` operation which may leave
    excess data on each block.

    See also
    --------
    dask.array.overlap.map_overlap

    R$   t   boundary(   t   coerce_deptht   ndimt   coerce_boundaryt   trim_internal(   R?   R)   RN   R$   t	   boundary2(    (    s1   lib/python2.7/site-packages/dask/array/overlap.pyt   trim_overlapœ   s    c         C` sJ  t  |  j | ƒ } g  } xõ t |  j ƒ D]ä \ } } | j | d ƒ } g  } xª t | ƒ D]œ \ } }	 | d k rŽ |	 | j | d ƒ d }	 nZ | d k r° |	 | j | d ƒ n |	 }	 | t | ƒ d k râ |	 | j | d ƒ n |	 }	 | j |	 ƒ qY W| j t | ƒ ƒ q( Wt | ƒ }
 t t	 t
 d | d | ƒ|  d |
 d |  j ƒS(	   sÐ    Trim sides from each block

    This couples well with the overlap operation, which may leave excess data on
    each block

    See also
    --------
    dask.array.chunk.trim
    dask.array.map_blocks
    t   nonei    i   i   R$   RN   R<   R:   (   RQ   RP   R   R<   R    R;   R!   R   R   R	   t   _trimR:   (   R?   R$   RN   t   olistR   RJ   t   bdyt   ilistt   jR5   R<   (    (    s1   lib/python2.7/site-packages/dask/array/overlap.pyRR   ®   s    (2c         ` sÄ   g  t  |  j ƒ D] } | j | d ƒ ^ q } d „  | Dƒ } ‡  f d †  t t | d d | ƒ ƒ Dƒ } ‡  f d †  t t | d d | d d | ƒ ƒ Dƒ } |  t d „  t | | ƒ Dƒ ƒ S(   s¢   Similar to dask.array.chunk.trim but requires one to specificy the
    boundary condition.

    ``axes``, and ``boundary`` are assumed to have been coerced.

    i    c         s` s"   |  ] } | r | n d  Vq d  S(   N(   R   (   R   t   ax(    (    s1   lib/python2.7/site-packages/dask/array/overlap.pys	   <genexpr>Ö   s    c         3` sK   |  ]A \ } \ } } | d  k r? ˆ  j  | d ƒ d k r? d  n | Vq d S(   i    RU   N(   R    (   R   R   t   chunk_locationR[   (   RN   (    s1   lib/python2.7/site-packages/dask/array/overlap.pys	   <genexpr>Ù   s   s   chunk-locationc         3` sR   |  ]H \ } \ } } } | | d  k rF ˆ  j  | d ƒ d k rF d n | Vq d S(   i   RU   N(   R    R   (   R   R   R<   R\   R[   (   RN   (    s1   lib/python2.7/site-packages/dask/array/overlap.pys	   <genexpr>Þ   s   s
   num-chunksc         s` s$   |  ] \ } } t  | | ƒ Vq d  S(   N(   R   (   R   t   frontt   back(    (    s1   lib/python2.7/site-packages/dask/array/overlap.pys	   <genexpr>å   s   (   t   rangeRP   R    R   R   R   (   R?   R$   RN   t
   block_infoR   t	   axes_backt
   trim_frontt	   trim_back(    (   RN   s1   lib/python2.7/site-packages/dask/array/overlap.pyRV   Î   s    .c         C` sß   t  d d d ƒ f | t  d | ƒ f t  d d d ƒ f |  j | d } t  d d d ƒ f | t  | d ƒ f t  d d d ƒ f |  j | d } |  | } |  | } t | | | | ƒ \ } } t | |  | g d | ƒS(   sv    Copy a slice of an array around to its other side

    Useful to create periodic boundary conditions for overlap
    i    i   t   axisN(   R   R   RP   t   _remove_overlap_boundariesR   (   R?   Rd   R)   RG   RH   t   lR(   (    (    s1   lib/python2.7/site-packages/dask/array/overlap.pyt   periodicé   s    &%'%

c         C` sG  | d k rZ t  d d d ƒ f | t  d d ƒ f t  d d d ƒ f |  j | d } nR t  d d d ƒ f | t  | d d d ƒ f t  d d d ƒ f |  j | d } t  d d d ƒ f | t  d | d d ƒ f t  d d d ƒ f |  j | d } |  | } |  | } t | | | | ƒ \ } } t | |  | g d | ƒS(   s\    Reflect boundaries of array on the same side

    This is the converse of ``periodic``
    i   i    iÿÿÿÿRd   N(   R   R   RP   Re   R   (   R?   Rd   R)   RG   RH   Rf   R(   (    (    s1   lib/python2.7/site-packages/dask/array/overlap.pyt   reflectý   s    &(-%.%

c         C` s  t  d d d ƒ f | t  d d ƒ f t  d d d ƒ f |  j | d } t  d d d ƒ f | t  d d d ƒ f t  d d d ƒ f |  j | d } t |  | g | d | ƒ} t |  | g | d | ƒ} t | | | | ƒ \ } } t | |  | g d | ƒS(   s‡    Each reflect each boundary value outwards

    This mimics what the skimage.filters.gaussian_filter(... mode="nearest")
    does.
    i    i   iÿÿÿÿiþÿÿÿRd   N(   R   R   RP   R   Re   (   R?   Rd   R)   RG   RH   Rf   R(   (    (    s1   lib/python2.7/site-packages/dask/array/overlap.pyt   nearest  s    &%)%c         C` sk   t  |  j ƒ } | f | | <t j t t t | ƒ ƒ | d t | ƒ d |  j ƒ} t | |  | g d | ƒS(   s,    Add constant slice to either side of array R<   R:   Rd   (	   R.   R<   R   t   fullR   R
   t   sumR:   R   (   R?   Rd   R)   t   valueR<   t   c(    (    s1   lib/python2.7/site-packages/dask/array/overlap.pyt   constant*  s
    c         C` sl   t  |  j ƒ } | f | | <t  | j ƒ } | f | | <|  j t | ƒ ƒ }  | j t | ƒ ƒ } |  | f S(   N(   R.   R<   t   rechunkR   (   Rf   R(   Rd   R)   t   lchunkst   rchunks(    (    s1   lib/python2.7/site-packages/dask/array/overlap.pyRe   5  s    c         ` s_  t  ˆ t ƒ s7 t ‡ f d †  t |  j ƒ Dƒ ƒ ‰ n  t  ˆ  t ƒ sn t ‡  f d †  t |  j ƒ Dƒ ƒ ‰  n  xê t |  j ƒ D]Ù } ˆ  j | d ƒ } | d k r¨ q~ n  ˆ j | d ƒ } | d k rÌ q~ q~ | d k rí t |  | | ƒ }  q~ | d k rt |  | | ƒ }  q~ | d k r/t |  | | ƒ }  q~ | ˆ k r~ t |  | | ˆ | ƒ }  q~ q~ W|  S(   sp    Add boundary conditions to an array before overlaping

    See Also
    --------
    periodic
    constant
    c         3` s   |  ] } | ˆ  f Vq d  S(   N(    (   R   R   (   t   kind(    s1   lib/python2.7/site-packages/dask/array/overlap.pys	   <genexpr>I  s    c         3` s   |  ] } | ˆ  f Vq d  S(   N(    (   R   R   (   R)   (    s1   lib/python2.7/site-packages/dask/array/overlap.pys	   <genexpr>K  s    i    RU   Rg   Rh   Ri   (	   t
   isinstancet   dictR_   RP   R    Rg   Rh   Ri   Rn   (   R?   R)   Rr   R   R5   t	   this_kind(    (   R)   Rr   s1   lib/python2.7/site-packages/dask/array/overlap.pyt
   boundaries@  s(    (( c         ` sÿ   t  |  j | ƒ } t |  j | ƒ ‰  g  t |  j ƒ D] } | j | d ƒ ^ q4 } xQ t | |  j ƒ D]= \ } } | t | ƒ k re t d | t | ƒ f ƒ ‚ qe qe Wt	 |  | ˆ  ƒ } t
 | | ƒ }	 t ‡  f d †  | j ƒ  Dƒ ƒ }
 t j |	 |
 ƒ } | S(   so   Share boundaries between neighboring blocks

    Parameters
    ----------

    x: da.Array
        A dask array
    depth: dict
        The size of the shared boundary per axis
    boundary: dict
        The boundary condition on each axis. Options are 'reflect', 'periodic',
        'nearest', 'none', or an array value.  Such a value will fill the
        boundary with that value.

    The depth input informs how many cells to overlap between neighboring
    blocks ``{0: 2, 2: 5}`` means share two cells in 0 axis, 5 cells in 2 axis.
    Axes missing from this input will not be overlapped.

    Examples
    --------
    >>> import numpy as np
    >>> import dask.array as da

    >>> x = np.arange(64).reshape((8, 8))
    >>> d = da.from_array(x, chunks=(4, 4))
    >>> d.chunks
    ((4, 4), (4, 4))

    >>> g = da.overlap.overlap(d, depth={0: 2, 1: 1},
    ...                       boundary={0: 100, 1: 'reflect'})
    >>> g.chunks
    ((8, 8), (6, 6))

    >>> np.array(g)
    array([[100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100],
           [100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100],
           [  0,   0,   1,   2,   3,   4,   3,   4,   5,   6,   7,   7],
           [  8,   8,   9,  10,  11,  12,  11,  12,  13,  14,  15,  15],
           [ 16,  16,  17,  18,  19,  20,  19,  20,  21,  22,  23,  23],
           [ 24,  24,  25,  26,  27,  28,  27,  28,  29,  30,  31,  31],
           [ 32,  32,  33,  34,  35,  36,  35,  36,  37,  38,  39,  39],
           [ 40,  40,  41,  42,  43,  44,  43,  44,  45,  46,  47,  47],
           [ 16,  16,  17,  18,  19,  20,  19,  20,  21,  22,  23,  23],
           [ 24,  24,  25,  26,  27,  28,  27,  28,  29,  30,  31,  31],
           [ 32,  32,  33,  34,  35,  36,  35,  36,  37,  38,  39,  39],
           [ 40,  40,  41,  42,  43,  44,  43,  44,  45,  46,  47,  47],
           [ 48,  48,  49,  50,  51,  52,  51,  52,  53,  54,  55,  55],
           [ 56,  56,  57,  58,  59,  60,  59,  60,  61,  62,  63,  63],
           [100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100],
           [100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100]])
    i    s²   The overlapping depth %d is larger than your
smallest chunk size %d. Rechunk your array
with a larger chunk size or a chunk size that
more evenly divides the shape of your array.c         3` sC   |  ]9 \ } } | ˆ  j  | d  ƒ d  k r4 | d n d f Vq d S(   RU   i   i    N(   R    (   R   R/   t   v(   RS   (    s1   lib/python2.7/site-packages/dask/array/overlap.pys	   <genexpr>£  s   (   RO   RP   RQ   R_   R    R   R<   t   mint
   ValueErrorRv   RM   Rt   t   itemsR   t   trim(   R?   R)   RN   t   depth2R   t   depth_valuesR5   Rm   t   x2t   x3R{   t   x4(    (   RS   s1   lib/python2.7/site-packages/dask/array/overlap.pyt   overlapa  s    4.c         C` s  x| j  ƒ  D]\ } } | j | d ƒ } | d k r | d k r t |  j ƒ } | | | <t |  j ƒ } | f | | <t j | d | d |  j ƒ} t |  j ƒ }	 t |	 | ƒ }
 |
 d c | 7<|
 d c | 7<t |
 ƒ |	 | <t	 | |  | g d | ƒ}  |  j
 |	 ƒ }  q q W|  S(   s?  
    Pads an array which has 'none' as the boundary type.
    Used to simplify trimming arrays which use 'none'.

    >>> import dask.array as da
    >>> x = da.arange(6, chunks=3)
    >>> add_dummy_padding(x, {0: 1}, {0: 'none'}).compute()  # doctest: +NORMALIZE_WHITESPACE
    array([..., 0, 1, 2, 3, 4, 5, ...])
    i    RU   R<   R:   iÿÿÿÿRd   (   Rz   R    R.   R1   R<   R   t   emptyR:   R   R   Ro   (   R?   R)   RN   R/   Rw   R5   t   empty_shapet   empty_chunksR‚   t
   out_chunkst	   ax_chunks(    (    s1   lib/python2.7/site-packages/dask/array/overlap.pyt   add_dummy_padding©  s     

c   
      K` sÉ   t  |  j | ƒ } t |  j | ƒ } t d „  |  j Dƒ ƒ sC t ‚ t |  d | d | ƒ} t d „  | j Dƒ ƒ sz t ‚ | j | |  }	 t d „  |	 j Dƒ ƒ s« t ‚ | rÁ t |	 | | ƒ S|	 Sd S(   sU   Map a function over blocks of the array with some overlap

    We share neighboring zones between blocks of the array, then map a
    function, then trim away the neighboring strips.

    Parameters
    ----------
    func: function
        The function to apply to each extended block
    depth: int, tuple, or dict
        The number of elements that each block should share with its neighbors
        If a tuple or dict then this can be different per axis
    boundary: str, tuple, dict
        How to handle the boundaries.
        Values include 'reflect', 'periodic', 'nearest', 'none',
        or any constant value like 0 or np.nan
    trim: bool
        Whether or not to trim ``depth`` elements from each block after
        calling the map function.
        Set this to False if your mapping function already does this for you
    **kwargs:
        Other keyword arguments valid in ``map_blocks``

    Examples
    --------
    >>> import numpy as np
    >>> import dask.array as da

    >>> x = np.array([1, 1, 2, 3, 3, 3, 2, 1, 1])
    >>> x = da.from_array(x, chunks=5)
    >>> def derivative(x):
    ...     return x - np.roll(x, 1)

    >>> y = x.map_overlap(derivative, depth=1, boundary=0)
    >>> y.compute()
    array([ 1,  0,  1,  1,  0,  0, -1, -1,  0])

    >>> x = np.arange(16).reshape((4, 4))
    >>> d = da.from_array(x, chunks=(2, 2))
    >>> d.map_overlap(lambda x: x + x.size, depth=1).compute()
    array([[16, 17, 18, 19],
           [20, 21, 22, 23],
           [24, 25, 26, 27],
           [28, 29, 30, 31]])

    >>> func = lambda x: x + x.size
    >>> depth = {0: 1, 1: 1}
    >>> boundary = {0: 'reflect', 1: 'none'}
    >>> d.map_overlap(func, depth, boundary).compute()  # doctest: +NORMALIZE_WHITESPACE
    array([[12,  13,  14,  15],
           [16,  17,  18,  19],
           [20,  21,  22,  23],
           [24,  25,  26,  27]])
    c         s` s.   |  ]$ } | D] } t  | ƒ t k Vq q d  S(   N(   t   typeR   (   R   t   ccRm   (    (    s1   lib/python2.7/site-packages/dask/array/overlap.pys	   <genexpr>  s    R)   RN   c         s` s.   |  ]$ } | D] } t  | ƒ t k Vq q d  S(   N(   Rˆ   R   (   R   R‰   Rm   (    (    s1   lib/python2.7/site-packages/dask/array/overlap.pys	   <genexpr>  s    c         s` s.   |  ]$ } | D] } t  | ƒ t k Vq q d  S(   N(   Rˆ   R   (   R   R‰   Rm   (    (    s1   lib/python2.7/site-packages/dask/array/overlap.pys	   <genexpr>  s    N(	   RO   RP   RQ   R"   R<   t   AssertionErrorR   R   RR   (
   R?   t   funcR)   RN   R{   t   kwargsR|   RS   t   gt   g2(    (    s1   lib/python2.7/site-packages/dask/array/overlap.pyt   map_overlapÉ  s    7c         C` sP   t  | t ƒ r | f |  } n  t  | t ƒ rL t t t |  ƒ | ƒ ƒ } n  | S(   N(   Rs   R   R   Rt   R   R_   (   RP   R)   (    (    s1   lib/python2.7/site-packages/dask/array/overlap.pyRO     s
    c         C` sk   | d  k r d } n  t | t t f ƒ s: | f |  } n  t | t ƒ rg t t t |  ƒ | ƒ ƒ } n  | S(   NRh   (   R   Rs   R   Rt   R   R_   (   RP   RN   (    (    s1   lib/python2.7/site-packages/dask/array/overlap.pyRQ     s    	N(4   t
   __future__R    R   R   t   operatorR   t	   itertoolsR   t   numbersR   t   toolzR   R   R   R	   t   toolz.curriedR
   t    R   R   t   coreR   R   R   R   R   t   highlevelgraphR   t   baseR   R   t   utilsR   R*   R   R8   RM   RT   RR   RV   Rg   Rh   Ri   Rn   Re   Rv   R   R‡   t   TrueR   RO   RQ   (    (    (    s1   lib/python2.7/site-packages/dask/array/overlap.pyt   <module>   s8   "(	"4	4 						!	H	 E		