def __init__(self, bins, pdfs, *args, **kwargs):
"""
Create a new distribution using the given histogram
Parameters
----------
bins : array_like
The second containing the (n+1) bin boundaries
"""
self._hbins = np.asarray(bins)
self._nbins = self._hbins.size - 1
self._hbin_widths = self._hbins[1:] - self._hbins[:-1]
if pdfs.shape[-1] != self._nbins: # pragma: no cover
raise ValueError("Number of bins (%i) != number of values (%i)" % (self._nbins, pdfs.shape[-1]))
check_input = kwargs.pop('check_input', True)
if check_input:
pdfs_2d = reshape_to_pdf_size(pdfs, -1)
sums = np.sum(pdfs_2d*self._hbin_widths, axis=1)
self._hpdfs = (pdfs_2d.T / sums).T
else: #pragma: no cover
self._hpdfs = reshape_to_pdf_size(pdfs, -1)
self._hcdfs = None
# Set support
kwargs['a'] = self.a = self._hbins[0]
kwargs['b'] = self.b = self._hbins[-1]
kwargs['shape'] = pdfs.shape[:-1]
super(hist_gen, self).__init__(*args, **kwargs)
self._addmetadata('bins', self._hbins)
self._addobjdata('pdfs', self._hpdfs)
def __init__(self, xvals, yvals, *args, **kwargs):
"""
Create a new distribution by interpolating the given values
Parameters
----------
xvals : array_like
The x-values used to do the interpolation
yvals : array_like
The y-values used to do the interpolation
"""
if xvals.shape != yvals.shape: # pragma: no cover
raise ValueError("Shape of xvals (%s) != shape of yvals (%s)" %
(xvals.shape, yvals.shape))
self._xvals = reshape_to_pdf_size(xvals, -1)
# Set support
kwargs['a'] = self.a = np.min(self._xvals)
kwargs['b'] = self.b = np.max(self._xvals)
kwargs['shape'] = xvals.shape[:-1]
check_input = kwargs.pop('check_input', True)
self._yvals = reshape_to_pdf_size(yvals, -1)
if check_input:
self._yvals = normalize_interp1d(self._xvals, self._yvals)
self._ycumul = None
super(interp_irregular_gen, self).__init__(*args, **kwargs)
self._addobjdata('xvals', self._xvals)
self._addobjdata('yvals', self._yvals)
def __init__(self, quants, locs, *args, **kwargs):
"""
Create a new distribution using the given values
Parameters
----------
quants : array_like
The quantiles used to build the CDF
locs : array_like
The locations at which those quantiles are reached
"""
print(quants.shape)
print(locs.shape)
kwargs['shape'] = locs.shape[:-1]
kwargs['a'] = self.a = np.min(locs)
kwargs['b'] = self.b = np.max(locs)
super(quant_gen, self).__init__(*args, **kwargs)
locs_2d = reshape_to_pdf_size(locs, -1)
check_input = kwargs.pop('check_input', True)
if check_input:
quants, locs_2d = pad_quantiles(quants, locs_2d)
self._quants = np.asarray(quants)
self._nquants = self._quants.size
if locs_2d.shape[-1] != self._nquants: # pragma: no cover
raise ValueError(
"Number of locations (%i) != number of quantile values (%i)" %
(self._nquants, locs_2d.shape[-1]))
self._locs = locs_2d
self._valatloc = None
self._addmetadata('quants', self._quants)
self._addobjdata('locs', self._locs)
def __init__(self, means, stds, weights, *args, **kwargs):
"""
Create a new distribution using the given histogram
Parameters
----------
means : array_like
The means of the Gaussians
stds: array_like
The standard deviations of the Gaussians
weights : array_like
The weights to attach to the Gaussians
"""
self._means = reshape_to_pdf_size(means, -1)
self._stds = reshape_to_pdf_size(stds, -1)
self._weights = reshape_to_pdf_size(weights, -1)
kwargs['shape'] = means.shape[:-1]
self._ncomps = means.shape[-1]
super(mixmod_gen, self).__init__(*args, **kwargs)
self._addobjdata('weights', self._weights)
self._addobjdata('stds', self._stds)
self._addobjdata('means', self._means)
def histogramize(self, bins):
"""
Computes integrated histogram bin values for all PDFs
Parameters
----------
bins: ndarray, float, optional
Array of N+1 endpoints of N bins
Returns
-------
self.histogram: ndarray, tuple, ndarray, floats
Array of pairs of arrays of lengths (N+1, N) containing endpoints
of bins and values in bins
"""
cdf_vals = reshape_to_pdf_size(self.cdf(bins), -1)
bin_vals = cdf_vals[:, 1:] - cdf_vals[:, 0:-1]
return (bins, reshape_to_pdf_shape(bin_vals, self._shape,
bins.size - 1))
def __init__(self, xvals, yvals, *args, **kwargs):
"""
Create a new distribution by interpolating the given values
Parameters
----------
xvals : array_like
The x-values used to do the interpolation
yvals : array_like
The y-values used to do the interpolation
"""
if xvals.size != np.sum(yvals.shape[1:]): # pragma: no cover
raise ValueError(
"Shape of xbins in xvals (%s) != shape of xbins in yvals (%s)"
% (xvals.size, np.sum(yvals.shape[1:])))
self._xvals = xvals
# Set support
kwargs['a'] = self.a = np.min(self._xvals)
kwargs['b'] = self.b = np.max(self._xvals)
kwargs['shape'] = yvals.shape[:-1]
#self._yvals = normalize_interp1d(xvals, yvals)
self._yvals = reshape_to_pdf_size(yvals, -1)
check_input = kwargs.pop('check_input', True)
if check_input:
self._compute_ycumul()
self._yvals = (self._yvals.T / self._ycumul[:, -1]).T
self._ycumul = (self._ycumul.T / self._ycumul[:, -1]).T
else: # pragma: no cover
self._ycumul = None
super(interp_gen, self).__init__(*args, **kwargs)
self._addmetadata('xvals', self._xvals)
self._addobjdata('yvals', self._yvals)