def hist(y, bins=10, normed=0):
"""
Return the histogram of y with bins equally sized bins. If bins
is an array, use the bins. Return value is
(n,x) where n is the count for each bin in x
If normed is False, return the counts in the first element of the
return tuple. If normed is True, return the probability density
n/(len(y)*dbin)
If y has rank>1, it will be raveled
Credits: the Numeric 22 documentation
"""
y = asarray(y)
if len(y.shape)>1: y = ravel(y)
if not iterable(bins):
ymin, ymax = min(y), max(y)
if ymin==ymax:
ymin -= 0.5
ymax += 0.5
bins = linspace(ymin, ymax, bins)
n = searchsorted(sort(y), bins)
n = diff(concatenate([n, [len(y)]]))
if normed:
db = bins[1]-bins[0]
return 1/(len(y)*db)*n, bins
else:
return n, bins
def hist(y, bins=10, normed=0):
"""
Return the histogram of y with bins equally sized bins. If bins
is an array, use the bins. Return value is
(n,x) where n is the count for each bin in x
If normed is False, return the counts in the first element of the
return tuple. If normed is True, return the probability density
n/(len(y)*dbin)
If y has rank>1, it will be raveled
Credits: the Numeric 22 documentation
"""
y = asarray(y)
if len(y.shape) > 1: y = ravel(y)
if not iterable(bins):
ymin, ymax = min(y), max(y)
if ymin == ymax:
ymin -= 0.5
ymax += 0.5
bins = linspace(ymin, ymax, bins)
n = searchsorted(sort(y), bins)
n = diff(concatenate([n, [len(y)]]))
if normed:
db = bins[1] - bins[0]
return 1 / (len(y) * db) * n, bins
else:
return n, bins
def _set_clip(self):
if not self._useDataClipping: return
#self._logcache = None
try:
self._xmin, self._xmax
except AttributeError:
indx = arange(len(self._x))
else:
if not hasattr(self, '_xsorted'):
self._xsorted = self._is_sorted(self._x)
if len(self._x) == 1:
indx = [0]
elif self._xsorted:
# for really long signals, if we know they are sorted
# on x we can save a lot of time using search sorted
# since the alternative approach requires 3 O(len(x) ) ops
indMin, indMax = searchsorted(self._x,
array([self._xmin, self._xmax]))
indMin = max(0, indMin - 1)
indMax = min(indMax + 1, len(self._x))
skip = 0
if self._lod:
# if level of detail is on, decimate the data
# based on pixel width
raise NotImplementedError('LOD deprecated')
l, b, w, h = self.get_window_extent().get_bounds()
skip = int((indMax - indMin) / w)
if skip > 0: indx = arange(indMin, indMax, skip)
else: indx = arange(indMin, indMax)
else:
indx = nonzero(
logical_and(self._x >= self._xmin, self._x <= self._xmax))
self._xc = take(self._x, indx)
self._yc = take(self._y, indx)
# y data clipping for connected lines can introduce horizontal
# line artifacts near the clip region. If you really need y
# clipping for efficiency, consider using plot(y,x) instead.
if (self._yc.shape == self._xc.shape and self._linestyle is None):
try:
self._ymin, self._ymax
except AttributeError:
indy = arange(len(self._yc))
else:
indy = nonzero(
logical_and(self._yc >= self._ymin,
self._yc <= self._ymax))
else:
indy = arange(len(self._yc))
self._xc = take(self._xc, indy)
self._yc = take(self._yc, indy)
def _set_clip(self):
if not self._useDataClipping:
return
# self._logcache = None
try:
self._xmin, self._xmax
except AttributeError:
indx = arange(len(self._x))
else:
if not hasattr(self, "_xsorted"):
self._xsorted = self._is_sorted(self._x)
if len(self._x) == 1:
indx = [0]
elif self._xsorted:
# for really long signals, if we know they are sorted
# on x we can save a lot of time using search sorted
# since the alternative approach requires 3 O(len(x) ) ops
indMin, indMax = searchsorted(self._x, array([self._xmin, self._xmax]))
indMin = max(0, indMin - 1)
indMax = min(indMax + 1, len(self._x))
skip = 0
if self._lod:
# if level of detail is on, decimate the data
# based on pixel width
raise NotImplementedError("LOD deprecated")
l, b, w, h = self.get_window_extent().get_bounds()
skip = int((indMax - indMin) / w)
if skip > 0:
indx = arange(indMin, indMax, skip)
else:
indx = arange(indMin, indMax)
else:
indx = nonzero(logical_and(self._x >= self._xmin, self._x <= self._xmax))
self._xc = take(self._x, indx)
self._yc = take(self._y, indx)
# y data clipping for connected lines can introduce horizontal
# line artifacts near the clip region. If you really need y
# clipping for efficiency, consider using plot(y,x) instead.
if self._yc.shape == self._xc.shape and self._linestyle is None:
try:
self._ymin, self._ymax
except AttributeError:
indy = arange(len(self._yc))
else:
indy = nonzero(logical_and(self._yc >= self._ymin, self._yc <= self._ymax))
else:
indy = arange(len(self._yc))
self._xc = take(self._xc, indy)
self._yc = take(self._yc, indy)
def makeMappingArray(N, data):
"""Create an N-element 1-d lookup table
data represented by a list of x,y0,y1 mapping correspondences.
Each element in this list represents how a value between 0 and 1
(inclusive) represented by x is mapped to a corresponding value
between 0 and 1 (inclusive). The two values of y are to allow
for discontinuous mapping functions (say as might be found in a
sawtooth) where y0 represents the value of y for values of x
<= to that given, and y1 is the value to be used for x > than
that given). The list must start with x=0, end with x=1, and
all values of x must be in increasing order. Values between
the given mapping points are determined by simple linear interpolation.
The function returns an array "result" where result[x*(N-1)]
gives the closest value for values of x between 0 and 1.
"""
try:
adata = array(data)
except:
raise TypeError("data must be convertable to an array")
shape = adata.shape
if len(shape) != 2 and shape[1] != 3:
raise ValueError("data must be nx3 format")
x = adata[:,0]
y0 = adata[:,1]
y1 = adata[:,2]
if x[0] != 0. or x[-1] != 1.0:
raise ValueError(
"data mapping points must start with x=0. and end with x=1")
if sometrue(sort(x)-x):
raise ValueError(
"data mapping points must have x in increasing order")
# begin generation of lookup table
x = x * (N-1)
lut = zeros((N,), Float)
xind = arange(float(N))
ind = searchsorted(x, xind)[1:-1]
lut[1:-1] = ( divide(xind[1:-1] - take(x,ind-1),
take(x,ind)-take(x,ind-1) )
*(take(y0,ind)-take(y1,ind-1)) + take(y1,ind-1))
lut[0] = y1[0]
lut[-1] = y0[-1]
# ensure that the lut is confined to values between 0 and 1 by clipping it
clip(lut, 0.0, 1.0)
#lut = where(lut > 1., 1., lut)
#lut = where(lut < 0., 0., lut)
return lut
def makeMappingArray(N, data):
"""Create an N-element 1-d lookup table
data represented by a list of x,y0,y1 mapping correspondences.
Each element in this list represents how a value between 0 and 1
(inclusive) represented by x is mapped to a corresponding value
between 0 and 1 (inclusive). The two values of y are to allow
for discontinuous mapping functions (say as might be found in a
sawtooth) where y0 represents the value of y for values of x
<= to that given, and y1 is the value to be used for x > than
that given). The list must start with x=0, end with x=1, and
all values of x must be in increasing order. Values between
the given mapping points are determined by simple linear interpolation.
The function returns an array "result" where result[x*(N-1)]
gives the closest value for values of x between 0 and 1.
"""
try:
adata = array(data)
except:
raise TypeError("data must be convertable to an array")
shape = adata.shape
if len(shape) != 2 and shape[1] != 3:
raise ValueError("data must be nx3 format")
x = adata[:,0]
y0 = adata[:,1]
y1 = adata[:,2]
if x[0] != 0. or x[-1] != 1.0:
raise ValueError(
"data mapping points must start with x=0. and end with x=1")
if sometrue(sort(x)-x):
raise ValueError(
"data mapping points must have x in increasing order")
# begin generation of lookup table
x = x * (N-1)
lut = zeros((N,), Float)
xind = arange(float(N))
ind = searchsorted(x, xind)[1:-1]
lut[1:-1] = ( divide(xind[1:-1] - take(x,ind-1),
take(x,ind)-take(x,ind-1) )
*(take(y0,ind)-take(y1,ind-1)) + take(y1,ind-1))
lut[0] = y1[0]
lut[-1] = y0[-1]
# ensure that the lut is confined to values between 0 and 1 by clipping it
lut = where(lut > 1., 1., lut)
lut = where(lut < 0., 0., lut)
return lut
