def test_tranproc():
import wafo.transform.models as wtm
tr = wtm.TrHermite()
x = linspace(-5, 5, 501)
g = tr(x)
y0, y1 = tranproc(x, g, range(5), ones(5))
assert_allclose(y0, [0.02659612, 1.00115284, 1.92872532, 2.81453257, 3.66292878])
assert_allclose(y1, [1.00005295, 0.9501118, 0.90589954, 0.86643821, 0.83096482])
def test_tranproc():
import wafo.transform.models as wtm
tr = wtm.TrHermite()
x = linspace(-5, 5, 501)
g = tr(x)
y0, y1 = tranproc(x, g, range(5), ones(5))
assert_array_almost_equal(
y0,
np.array([0.02659612, 1.00115284, 1.92872532,
2.81453257, 3.66292878]))
assert_array_almost_equal(
y1,
np.array([1.00005295, 0.9501118, 0.90589954,
0.86643821, 0.83096482]))
def test_tranproc():
p = np.poly1d(
[2.53309567e-04, 2.65759139e-02, 9.98533350e-01, -2.65759139e-02])
g = np.linspace(-6, 4.5, 501)
x = p(g)
y0, y1 = tranproc(x, g, np.arange(5), np.ones(5))
assert_allclose(y0, [
0.0265929056674, 1.00114978495, 1.92872202911, 2.8145300482,
3.6629257237
])
assert_allclose(y1, [
1.00004046620, 0.95007409636, 0.90585612024, 0.86640213535,
0.83091299820
])
def _dat2gauss(self, x, *xi):
return tranproc(self.args, self.data, x, *xi)
def _gauss2dat(self, y, *yi):
return tranproc(self.data, self.args, y, *yi)
def _dat2gauss(self, x, *xi):
return tranproc(self.args, self.data, x, *xi)
def _gauss2dat(self, y, *yi):
return tranproc(self.data, self.args, y, *yi)
def qlevels(pdf, p=(10, 30, 50, 70, 90, 95, 99, 99.9), xi=(), indexing='xy'):
"""QLEVELS Calculates quantile levels which encloses P% of pdf.
Parameters
----------
pdf: array-like
joint point density function given as array or vector
p : float in range of [0,100] (or sequence of floats)
Percentage to compute which must be between 0 and 100 inclusive.
xi : tuple
input arguments to the pdf, i.e., (x0, x1,...., xn)
indexing : {'xy', 'ij'}, optional
Cartesian ('xy', default) or matrix ('ij') indexing of pdf.
See numpy.meshgrid for more details.
Returns
------
levels: array-like
discrete levels which encloses P% of pdf
QLEVELS numerically integrates PDF by decreasing height and find the
quantile levels which encloses P% of the distribution.
If Xi is unspecified it is assumed that dX0, dX1,..., and dXn is constant.
NB! QLEVELS normalizes the integral of PDF to n/(n+0.001) before
calculating 'levels' in order to reflect the sampling of PDF is finite.
Examples
--------
>>> import wafo.stats as ws
>>> x = np.linspace(-8,8,2001);
>>> PL = np.r_[10:90:20, 90, 95, 99, 99.9]
>>> qlevels(ws.norm.pdf(x),p=PL, xi=(x,));
array([ 0.39591707, 0.37058719, 0.31830968, 0.23402133, 0.10362052,
0.05862129, 0.01449505, 0.00178806])
# compared with the exact values
>>> ws.norm.pdf(ws.norm.ppf((100-PL)/200))
array([ 0.39580488, 0.370399 , 0.31777657, 0.23315878, 0.10313564,
0.05844507, 0.01445974, 0.00177719])
See also
--------
qlevels2, tranproc
"""
def _dx(x):
dx = np.diff(x.ravel()) * 0.5
return np.r_[0, dx] + np.r_[dx, 0]
def _init(pdf, xi, indexing):
if not xi:
return pdf.ravel()
if not isinstance(xi, tuple):
xi = (xi,)
dx = np.meshgrid(*[_dx(x) for x in xi], sparse=True, indexing=indexing)
dxij = np.ones((1))
for dxi in dx:
dxij = dxij * dxi
_assert(dxij.shape == pdf.shape,
'Shape of pdf does not match the arguments')
return (pdf * dxij).ravel()
def _check_levels(levels, pdf):
_assert_warn(not np.any(levels >= max(pdf.ravel())),
'The lowest percent level is too close to 0%')
_assert_warn(not np.any(levels <= min(pdf.ravel())),
'The given pdf is too sparsely sampled or the highest '
'percent level is too close to 100%')
pdf, p = np.atleast_1d(pdf, p)
_assert(not any(pdf.ravel() < 0),
'This is not a pdf since one or more values of pdf is negative')
_assert(not np.any((p < 0) | (100 < p)), 'PL must satisfy 0 <= PL <= 100')
if min(pdf.shape) == 0:
return []
ind = np.argsort(pdf.ravel()) # sort by height of pdf
ind = ind[::-1]
sorted_pdf = pdf.flat[ind]
pdf_dx = _init(pdf, xi, indexing=indexing)
# integration in the order of decreasing height of pdf
cdf = np.cumsum(pdf_dx[ind])
n = pdf_dx.size
# normalize cdf to make sure int pdf dx1 dx2 approx 1
cdf = cdf / cdf[-1] * n / (n + 1.5e-8)
# make sure cdf is strictly increasing by not considering duplicate values
ind, = np.where(np.diff(np.r_[cdf, 1]) > 0)
# calculating the inverse of cdf to find the levels
levels = tranproc(cdf[ind], sorted_pdf[ind], p / 100.0)
_check_levels(levels, pdf)
levels[levels < 0] = 0.0
return levels
