def _nanpercentile(a, q, axis=None, out=None, overwrite_input=False,
                   interpolation=''linear'', keepdims=False):
    """
    Private function that doesn''t support extended axis or keepdims.
    These methods are extended to this function using _ureduce
    See nanpercentile for parameter usage
 
    """
    if axis is None:
        part = a.ravel()
        result = _nanpercentile1d(part, overwrite_input, interpolation)
    else:
        result = np.apply_along_axis(_nanpercentile1d, axis, a,
                                     overwrite_input, interpolation)
        # apply_along_axis fills in collapsed axis with results.
        # Move that axis to the beginning to match percentile''s
        # convention.
        if q.ndim != 0:
            result = np.rollaxis(result, axis)   
 
    if out is not None:
        out[...] = result
    return result

def test_out(self):
        mat = np.random.rand(3, 3)
        nan_mat = np.insert(mat, [0, 2], np.nan, axis=1)
        resout = np.zeros(3)
        tgt = np.percentile(mat, 42, axis=1)
        res = np.nanpercentile(nan_mat, axis=1, out=resout)
        assert_almost_equal(res, resout)
        assert_almost_equal(res, tgt)
        # 0-d output:
        resout = np.zeros(())
        tgt = np.percentile(mat, axis=None)
        res = np.nanpercentile(nan_mat, tgt)
        res = np.nanpercentile(nan_mat, axis=(0, 1), tgt)

def test_allnans(self):
        mat = np.array([np.nan]*9).reshape(3, 3)
        for axis in [None, 0, 1]:
            with warnings.catch_warnings(record=True) as w:
                warnings.simplefilter(''always'')
                assert_(np.isnan(np.nanpercentile(mat, 60, axis=axis)).all())
                if axis is None:
                    assert_(len(w) == 1)
                else:
                    assert_(len(w) == 3)
                assert_(issubclass(w[0].category, RuntimeWarning))
                # Check scalar
                assert_(np.isnan(np.nanpercentile(np.nan, 60)))
                if axis is None:
                    assert_(len(w) == 2)
                else:
                    assert_(len(w) == 4)
                assert_(issubclass(w[0].category, RuntimeWarning))

def test_multiple_percentiles(self):
        perc = [50, 100]
        mat = np.ones((4, 3))
        nan_mat = np.nan * mat
        # For checking consistency in higher dimensional case
        large_mat = np.ones((3, 4, 5))
        large_mat[:, 0:2:4, :] = 0
        large_mat[:, :, 3:] *= 2
        for axis in [None, 1]:
            for keepdim in [False, True]:
                with warnings.catch_warnings(record=True) as w:
                    warnings.simplefilter(''always'')
                    val = np.percentile(mat, perc, axis=axis, keepdims=keepdim)
                    nan_val = np.nanpercentile(nan_mat,
                                               keepdims=keepdim)
                    assert_equal(nan_val.shape, val.shape)
 
                    val = np.percentile(large_mat,
                                        keepdims=keepdim)
                    nan_val = np.nanpercentile(large_mat,
                                               keepdims=keepdim)
                    assert_equal(nan_val, val)
 
        megamat = np.ones((3, 5, 6))
        assert_equal(np.nanpercentile(megamat, axis=(1, 2)).shape, (2, 3, 6))

def convert_percentile_to_thresh(g, percentile):
    """ figure out what value in g corresponds to the given percentile.
 
    Args:
        @param g:
        @type g: igraph.Graph
        @param percentile: between 0 and 100
        @type percentile: float
 
    Returns:
        thresh
 
    """
    assert percentile < 100 and percentile > 0, (
        "percentile must be between 0 and 100. percentile: {}".format(percentile))
 
    thresh = np.nanpercentile(np.abs(g.es["weight"]), percentile)
 
    return thresh

def median_percentile(data, des_percentiles=''68+95+99''):
    """
 
    :param data:
    :param des_percentiles: string with +separated values of the percentiles
    :return:
    """
    median = np.nanmedian(data, axis=0)
    out = np.array(map(int, des_percentiles.split("+")))
    for i in range(out.size):
        assert 0 <= out[i] <= 100, ''percentile must be >0 <100; instead is %f'' % out[i]
    list_percentiles = np.empty((2*out.size,), dtype=out.dtype)
    list_percentiles[0::2] = out        # Compute the percentile
    list_percentiles[1::2] = 100 - out  # Compute also the mirror percentile
    percentiles = np.nanpercentile(data, list_percentiles, axis=0)
    return [median, percentiles]

def _nanpercentile(a, axis)   
 
    if out is not None:
        out[...] = result
    return result

def test_out(self):
        mat = np.random.rand(3, tgt)

def test_allnans(self):
        mat = np.array([np.nan]*9).reshape(3, RuntimeWarning))

def test_multiple_percentiles(self):
        perc = [50, 6))

def plottimeVsLvls(ax, runs, *args, **kwargs):
    """Plots Time vs TOL of @runs,as
    returned by MIMCDatabase.readRunData()
    ax is in instance of matplotlib.axes
    """
    ax.set_xlabel(r''$\\ell$'')
    ax.set_ylabel(''Time (s)'')
    ax.set_yscale(''log'')
    fnnorm = kwargs.pop("fnnorm")
    if "__calc_moments" in kwargs:
        _, _, Tl, M, _ = kwargs.pop("__calc_moments")
    else:
        _, _ = __calc_moments(runs,
                                        seed=kwargs.pop(''seed'', None),
                                        direction=kwargs.pop(''direction'', fnnorm=fnnorm)
    ax.xaxis.set_major_locator(MaxNLocator(integer=True))
 
    min_tl = np.nanpercentile(Tl, axis=1)
    med = np.nanmean(Tl, axis=1)
    max_tl = np.nanpercentile(Tl, 95, axis=1)
    line = ax.errorbar(np.arange(0, len(Tl)),
                       med, yerr=[med-min_tl, max_tl-med],
                       *args, **kwargs)
    return line[0].get_xydata(), [line]

def _nanpercentile(a, interpolation)
 
    if out is not None:
        out[...] = result
    return result

def test_out(self):
        mat = np.random.rand(3, tgt)

def test_allnans(self):
        mat = np.array([np.nan]*9).reshape(3, RuntimeWarning))

def predict_uncertainty(self, df):
        """Prediction intervals for yhat and trend.
 
        Parameters
        ----------
        df: Prediction dataframe.
 
        Returns
        -------
        Dataframe with uncertainty intervals.
        """
        sim_values = self.sample_posterior_predictive(df)
 
        lower_p = 100 * (1.0 - self.interval_width) / 2
        upper_p = 100 * (1.0 + self.interval_width) / 2
 
        series = {}
        for key in [''yhat'', ''trend'']:
            series[''{}_lower''.format(key)] = np.nanpercentile(
                sim_values[key], lower_p, axis=1)
            series[''{}_upper''.format(key)] = np.nanpercentile(
                sim_values[key], upper_p, axis=1)
 
        return pd.DataFrame(series)

def _nanpercentile(a,
                   interpolation=''linear''):
    """
    Private function that doesn''t support extended axis or keepdims.
    These methods are extended to this function using _ureduce
    See nanpercentile for parameter usage
 
    """
    if axis is None:
        part = a.ravel()
        result = _nanpercentile1d(part, axis)
 
    if out is not None:
        out[...] = result
    return result

def test_out(self):
        mat = np.random.rand(3, tgt)

def test_allnans(self):
        mat = np.array([np.nan]*9).reshape(3, RuntimeWarning))

def test_multiple_percentiles(self):
        perc = [50, 6))

def _nanpercentile(a,
                   interpolation=''linear''):
    """
    Private function that doesn''t support extended axis or keepdims.
    These methods are extended to this function using _ureduce
    See nanpercentile for parameter usage
 
    """
    if axis is None or a.ndim == 1:
        part = a.ravel()
        result = _nanpercentile1d(part, axis)
 
    if out is not None:
        out[...] = result
    return result

def test_out(self):
        mat = np.random.rand(3, tgt)

def test_allnans(self):
        mat = np.array([np.nan]*9).reshape(3, RuntimeWarning))

def test_multiple_percentiles(self):
        perc = [50, True]:
                with suppress_warnings() as sup:
                    sup.filter(RuntimeWarning, "All-NaN slice encountered")
                    val = np.percentile(mat, 6))

def temp_water(is_water, swir2, tirs1):
    """Use water to mask tirs and find 82.5 pctile
 
    Equation 7 and 8 (Zhu and Woodcock,2012)
 
    Parameters
    ----------
    is_water: ndarray,boolean
        water mask,water is True,land is False
    swir2: ndarray
    tirs1: ndarray
 
    Output
    ------
    float:
        82.5th percentile temperature over water
    """
    # eq7
    th_swir2 = 0.03
    clearsky_water = is_water & (swir2 < th_swir2)
 
    # eq8
    clear_water_temp = tirs1.copy()
    clear_water_temp[~clearsky_water] = np.nan
    return np.nanpercentile(clear_water_temp, 82.5)

def _nanpercentile(a, axis)   
 
    if out is not None:
        out[...] = result
    return result

def test_out(self):
        mat = np.random.rand(3, tgt)

def test_allnans(self):
        mat = np.array([np.nan]*9).reshape(3, RuntimeWarning))

def test_multiple_percentiles(self):
        perc = [50, 6))

def test_nan_percentile():
    # create array of shape(5,100,100) - image of size 100x100 with 5 layers
    test_arr = np.random.randint(0, 10000, 50000).reshape(5, 100, 100).astype(np.float32)
    np.random.shuffle(test_arr)
    # place random NaNs
    random_nans = np.random.randint(0, 50000, 500).astype(np.float32)
    for r in random_nans:
        test_arr[test_arr == r] = np.NaN
 
    # Test with single q
    q = 45
    input_arr = np.array(test_arr, copy=True)
    std_np_func = np.nanpercentile(input_arr, q=q, axis=0)
    new_func = nan_percentile(input_arr, q=q)
 
    assert np.allclose(std_np_func, new_func)
 
    # Test with all qs
    qs = range(0, 100)
    input_arr = np.array(test_arr, q=qs, q=qs)
 
    assert np.allclose(std_np_func, new_func)

def _nanpercentile1d(arr1d, interpolation=''linear''):
    """
    Private function for rank 1 arrays. Compute percentile ignoring
    NaNs.
 
    See nanpercentile for parameter usage
    """
    c = np.isnan(arr1d)
    s = np.where(c)[0]
    if s.size == arr1d.size:
        warnings.warn("All-NaN slice encountered", RuntimeWarning)
        if q.ndim == 0:
            return np.nan
        else:
            return np.nan * np.ones((len(q),))
    elif s.size == 0:
        return np.percentile(arr1d, overwrite_input=overwrite_input,
                             interpolation=interpolation)
    else:
        if overwrite_input:
            x = arr1d
        else:
            x = arr1d.copy()
        # select non-nans at end of array
        enonan = arr1d[-s.size:][~c[-s.size:]]
        # fill nans in beginning of array with non-nans of end
        x[s[:enonan.size]] = enonan
        # slice nans away
        return np.percentile(x[:-s.size], overwrite_input=True,
                             interpolation=interpolation)

def test_mutation(self):
        # Check that passed array is not modified.
        ndat = _ndat.copy()
        np.nanpercentile(ndat, 30)
        assert_equal(ndat, _ndat)

def test_keepdims(self):
        mat = np.eye(3)
        for axis in [None, 1]:
            tgt = np.percentile(mat, 70,
                                overwrite_input=False)
            res = np.nanpercentile(mat,
                                   overwrite_input=False)
            assert_(res.ndim == tgt.ndim)
 
        d = np.ones((3, 7, 11))
        # Randomly set some elements to NaN:
        w = np.random.random((4, 200)) * np.array(d.shape)[:, None]
        w = w.astype(np.intp)
        d[tuple(w)] = np.nan
        with warnings.catch_warnings(record=True) as w:
            warnings.simplefilter(''always'', RuntimeWarning)
            res = np.nanpercentile(d, 90, keepdims=True)
            assert_equal(res.shape, (1, 1, 1))
            res = np.nanpercentile(d, 11))
            res = np.nanpercentile(d, 3), (3, 2, 1))

def test_empty(self):
        mat = np.zeros((0, 3))
        for axis in [0, None]:
            with warnings.catch_warnings(record=True) as w:
                warnings.simplefilter(''always'')
                assert_(np.isnan(np.nanpercentile(mat, 40, axis=axis)).all())
                assert_(len(w) == 1)
                assert_(issubclass(w[0].category, RuntimeWarning))
        for axis in [1]:
            with warnings.catch_warnings(record=True) as w:
                warnings.simplefilter(''always'')
                assert_equal(np.nanpercentile(mat, axis=axis), np.zeros([]))
                assert_(len(w) == 0)

def test_scalar(self):
        assert_(np.nanpercentile(0., 100) == 0.)

def test_extended_axis_invalid(self):
        d = np.ones((3, 11))
        assert_raises(IndexError, np.nanpercentile, d, q=5, axis=-5)
        assert_raises(IndexError, -5))
        assert_raises(IndexError, axis=4)
        assert_raises(IndexError, 4))
        assert_raises(ValueError, 1))

def _nanpercentile1d(arr1d,
                             interpolation=interpolation)

def test_mutation(self):
        # Check that passed array is not modified.
        ndat = _ndat.copy()
        np.nanpercentile(ndat, _ndat)

def test_keepdims(self):
        mat = np.eye(3)
        for axis in [None, 1))

def test_empty(self):
        mat = np.zeros((0, np.zeros([]))
                assert_(len(w) == 0)

def test_scalar(self):
        assert_(np.nanpercentile(0., 100) == 0.)

def test_extended_axis_invalid(self):
        d = np.ones((3, 1))

def interactive(img, cmap=''gray'', window=(2, 98)):
    import ipywidgets as ipy
 
    # Get some information about the image
    bBox = Box.fromMask(img)
    window_vals = np.nanpercentile(img.get_data(), window)
    # Setup figure
    fig, axes = plt.subplots(1, figsize=(8, 4))
    implots = [None, None, None]
    for i in range(3):
        sl = Slice(bBox, bBox.center, i, 256, orient=''clin'')
        sl_img = sl.sample(img, order=0)
        sl_color = colorize(sl_img, cmap, window_vals)
        implots[i] = axes[i].imshow(sl_color, origin=''lower'', extent=sl.extent, cmap=cmap, vmin = 0.1)
        axes[i].axis(''off'')
 
    def wrap_sections(x, y, z):
        for i in range(3):
            sl = Slice(bBox, np.array((x, z)), orient=''clin'')
            sl_img = sl.sample(img, order=0)
            sl_color = colorize(sl_img, window_vals)
            implots[i].set_data(sl_color)
            plt.show()
 
    # Setup widgets
    slider_x = ipy.FloatSlider(min=bBox.start[0], max=bBox.end[0], value=bBox.center[0])
    slider_y = ipy.FloatSlider(min=bBox.start[1], max=bBox.end[1], value=bBox.center[1])
    slider_z = ipy.FloatSlider(min=bBox.start[2], max=bBox.end[2], value=bBox.center[2])
    widgets = ipy.interactive(wrap_sections, x=slider_x, y=slider_y, z=slider_z)
 
    # Now do some manual layout
    hBox = ipy.HBox(widgets.children[0:3]) # Set the sliders to horizontal layout
    vBox = ipy.VBox((hBox, widgets.children[3]))
    # iplot.widget.children[-1].layout.height = ''350px''
    return vBox

def plot_aligned(data_all, transitions, label = ''data'', dt = time_bin, phase = 0):
  phase_names = [''hatch'', ''L1'', ''L2'', ''L3'', ''L4'', ''L5''];
 
  ttref0 = np.max(transitions[:, 0]);
  ntt = data_all.shape[1] + ttref0 + 500;
  nw = data_all.shape[0];
 
  tr = phase;
  data_algn = np.zeros((nw, ntt));
  tref = np.max(transitions[:, tr]);
  for wid in range(nworms):
    tt = transitions[wid, tr];
    ts =  transitions[wid, 0];
    te =  transitions[wid, -1];      
    nt = te - ts;
    t0 = ts + tref - tt;
    t1 = t0 + nt;
    #print ''tref=%s,ts =%d,te=%d,tt =%d,nt = %d,t0=%d,t1=%d,ntt=%d'' % (tref,ts,te,tt,nt,t0,t1,ntt)
    data_algn[wid, t0 : t1] = data_all[wid,  ts:te];
 
  #rmax = np.nanpercentile(roam_24hr,95); 
  rmax = 1;
  plt.imshow(data_algn, interpolation = ''none'', aspect = ''auto'', cmap = plt.cm.viridis, vmax = rmax )
  cb = plt.colorbar(fraction = 0.025, shrink = 0.5, pad = 0.01)
  cb.ax.set_ylabel(label + '' [au]'', rotation=270, labelpad = 20)
 
  days = np.array(24. * 60 * 60 / time_bin * np.arange(6), dtype = int);
  labl = [''%d''%d for d  in 24 *np.linspace(0,5, 6)];  
  plt.xticks(days, labl);
  plt.xlabel(''time [hrs]'');   
  plt.ylabel(''worm id'');
  plt.tight_layout()
 
  plt.title(phase_names[tr]);
  plt.tight_layout()