def _bin_merge(x, edges, bin_stats):
bins = collections.OrderedDict(
enumerate(zip(dsp_utl.pairwise(edges), bin_stats)))
new_edges = [edges[0]]
new_bin_stats = []
for k0 in range(len(bins) - 1):
v0, v1 = (bins[k0], bins[k0 + 1])
e_min, e_max = (v0[0][0], v1[0][1])
if (v1[1][0] - v0[1][0]) / (e_max - e_min) <= 0.33:
y = x[(e_min <= x) & (x < e_max)]
m, std = _stats(y)
if std < bin_std[1]:
n = v0[1][-1] + v1[1][-1]
bins[k0 + 1] = ((e_min, e_max),
[np.median(y), std / n, std, m, n])
del bins[k0]
for e, s in bins.values():
new_edges.append(e[1])
if s[2] < bin_std[1]:
s[2] *= s[3]
new_bin_stats.append(s[1:] + [s[0]])
new_bin_stats = sorted(new_bin_stats)
return new_edges, new_bin_stats
def select_phases_integration_times(cycle_type):
"""
Selects the cycle phases integration times [s].
:param cycle_type:
Cycle type (WLTP or NEDC).
:type cycle_type: str
:return:
Cycle phases integration times [s].
:rtype: tuple
"""
from ..defaults import dfl
v = dfl.functions.select_phases_integration_times.INTEGRATION_TIMES
return tuple(dsp_utl.pairwise(v[cycle_type.upper()]))
def interpolate_cloud(x, y):
"""
Defines a function that interpolate a cloud of points.
:param x:
x data.
:type x: Iterable
:param y:
y data.
:type y: Iterable
:return:
A function that interpolate a cloud of points.
:rtype: scipy.interpolate.InterpolatedUnivariateSpline
"""
p = np.asarray(x)
v = np.asarray(y)
edges, s = bin_split(p, bin_std=(0, 10))
if len(s) > 2:
x, y = ([0.0], [None])
for e0, e1 in dsp_utl.pairwise(edges):
b = (e0 <= p) & (p < e1)
x.append(np.mean(p[b]))
y.append(np.mean(v[b]))
y[0] = y[1]
x.append(x[-1])
# noinspection PyTypeChecker,PyTypeChecker
y.append(y[-1] * 1.1)
else:
x, y = ([0, 1], [np.mean(y)] * 2)
return sci_itp.InterpolatedUnivariateSpline(x, y, k=1)
def is_sorted(iterable, key=lambda a, b: a <= b):
return all(key(a, b) for a, b in dsp_utl.pairwise(iterable))
def check(x):
it = dsp_utl.pairwise(_extract_indices(x))
return all(i[-1] <= j[0] for i, j in it)