def function_convolution(self, dist_1, dist_2, bins=50):
a_1, b_1, a_2, b_2 = 0, 0, 0, 0
if dist_1 in self.bounds:
a_1, b_1 = self.bounds[dist_1]
else:
a_1, b_1 = calculate_bounds_of_probability_distribution(dist_1)
self.bounds[dist_1] = a_1, b_1
if dist_2 in self.bounds:
a_2, b_2 = self.bounds[dist_2]
else:
a_2, b_2 = calculate_bounds_of_probability_distribution(dist_2)
self.bounds[dist_2] = a_2, b_2
if (type(dist_1.dist), type(dist_2.dist)) == (uniform_gen, uniform_gen):
return self.function_convolution_uniform((a_1, b_1), (a_2, b_2))
convolution_bounds_a, convolution_bounds_b = min(a_1, a_2), max(b_1, b_2)
delta = fabs(convolution_bounds_a - convolution_bounds_b) / bins
convolution_interval = TimeInterval(convolution_bounds_a, convolution_bounds_b, bins)
x = [dist_1.pdf(t) for t in convolution_interval]
y = [dist_2.pdf(t) for t in reversed(convolution_interval)]
c = convolve(x, y)
dictionary_convolution = {}
for t in xrange(len(c)):
dictionary_convolution[delta * t] = c[t]
bias = calculateCenterMass(dictionary_convolution)[0] + dist_2.mean() - dist_1.mean()
dictionary_convolution_biased = {}
for t in dictionary_convolution:
dictionary_convolution_biased[t - bias] = dictionary_convolution[t]
convolution_function = FunctionPiecewiseLinear(dictionary_convolution_biased, FunctionHorizontalLinear(0))
return convolution_function.normalised()
def __init__(self, distribution_beginning, distribution_ending,
bins=50, relation_formula=None):
if not isinstance(distribution_beginning, rv_frozen):
raise TypeError("'distribution_beginning' should be a scipy frozen distribution")
if not isinstance(distribution_ending, rv_frozen):
raise TypeError("'distribution_ending' should be a scipy frozen distribution")
self._distribution_beginning = distribution_beginning
self._distribution_ending = distribution_ending
a, beginning = calculate_bounds_of_probability_distribution(distribution_beginning)
ending, b = calculate_bounds_of_probability_distribution(distribution_ending)
self._beginning = UnixTime(beginning)
self._ending = UnixTime(ending)
self.membership_function = MembershipFunction(self)
bins_beginning = bins / 2
bins_ending = bins - bins_beginning
self.interval_beginning = TimeInterval(a, beginning, bins_beginning)
self.interval_ending = TimeInterval(ending, b, bins_ending)
list.__init__(self, self.interval_beginning + self.interval_ending)
TimeInterval.__init__(self, a, b, bins)
if relation_formula is None:
relation_formula = RelationFormulaGeometricMean()
elif not isinstance(relation_formula, BaseRelationFormula):
raise TypeError("'relation_formula' should be of type 'BaseRelationFormula'")
relation_formula.bounds[distribution_beginning] = self.a, self.beginning
relation_formula.bounds[distribution_ending] = self.ending, self.b
self._formula_creator = FormulaCreator(relation_formula)
def function_convolution(self, dist_1, dist_2, bins=50):
a_1, b_1, a_2, b_2 = 0, 0, 0, 0
if dist_1 in self.bounds:
a_1, b_1 = self.bounds[dist_1]
else:
a_1, b_1 = calculate_bounds_of_probability_distribution(dist_1)
self.bounds[dist_1] = a_1, b_1
if dist_2 in self.bounds:
a_2, b_2 = self.bounds[dist_2]
else:
a_2, b_2 = calculate_bounds_of_probability_distribution(dist_2)
self.bounds[dist_2] = a_2, b_2
if (type(dist_1.dist), type(dist_2.dist)) == (uniform_gen, uniform_gen):
return self.function_convolution_uniform((a_1, b_1), (a_2, b_2))
convolution_bounds_a, convolution_bounds_b = min(a_1, a_2), max(b_1, b_2)
delta = fabs(convolution_bounds_a - convolution_bounds_b) / bins
convolution_interval = TimeInterval(convolution_bounds_a, convolution_bounds_b, bins)
x = [dist_1.pdf(t) for t in convolution_interval]
y = [dist_2.pdf(t) for t in reversed(convolution_interval)]
c = convolve(x, y)
dictionary_convolution = {}
for t in xrange(len(c)):
dictionary_convolution[delta * t] = c[t]
bias = calculateCenterMass(dictionary_convolution)[0] + dist_2.mean() - dist_1.mean()
dictionary_convolution_biased = {}
for t in dictionary_convolution:
dictionary_convolution_biased[t - bias] = dictionary_convolution[t]
convolution_function = FunctionPiecewiseLinear(dictionary_convolution_biased, FunctionHorizontalLinear(0))
return convolution_function.normalised()
def __init__(self,
distribution_beginning,
distribution_ending,
bins=50,
distribution_integral_limit=DISTRIBUTION_INTEGRAL_LIMIT):
if not isinstance(distribution_beginning, rv_frozen):
raise TypeError(
"'distribution_beginning' should be a scipy frozen distribution"
)
if not isinstance(distribution_ending, rv_frozen):
raise TypeError(
"'distribution_ending' should be a scipy frozen distribution")
if not 0 < distribution_integral_limit <= 1:
raise TypeError(
"'distribution_integral_limit' should be within (0, 1]")
self._distribution_beginning = distribution_beginning
self._distribution_ending = distribution_ending
a, beginning = calculate_bounds_of_probability_distribution(
distribution_beginning, distribution_integral_limit)
ending, b = calculate_bounds_of_probability_distribution(
distribution_ending, distribution_integral_limit)
self._beginning = UnixTime(beginning)
self._ending = UnixTime(ending)
self.membership_function = MembershipFunction(self)
bins_beginning = bins / 2
bins_ending = bins - bins_beginning
self.interval_beginning = TimeInterval(a, beginning, bins_beginning)
self.interval_ending = TimeInterval(ending, b, bins_ending)
list.__init__(self, self.interval_beginning + self.interval_ending)
TimeInterval.__init__(self, a, b, bins)
def bounds_of(self, dist):
# if dist in self.bounds:
# return self.bounds[dist]
bounds = calculate_bounds_of_probability_distribution(dist)
self.bounds[dist] = bounds
return bounds
def bounds_of(self, dist):
# if dist in self.bounds:
# return self.bounds[dist]
bounds = calculate_bounds_of_probability_distribution(dist)
self.bounds[dist] = bounds
return bounds
def duration(self, dist):
a, b = 0, 0
if dist in self.bounds:
a, b = self.bounds[dist]
else:
a, b = calculate_bounds_of_probability_distribution(dist)
self.bounds[dist] = a, b
return b - a
def duration(self, dist):
a, b = 0, 0
if dist in self.bounds:
a, b = self.bounds[dist]
else:
a, b = calculate_bounds_of_probability_distribution(dist)
self.bounds[dist] = a, b
return b - a
def fn_before_point(dist, time_step):
a, b = calculate_bounds_of_probability_distribution(dist)
p = dist.pdf(a)
if time_step < a:
return 1
if a <= time_step <= b:
value = p * (b - time_step) - p * (time_step - a)
if value < 0:
return 0
return value
return 0
def fn_before_point(dist, time_step):
a, b = calculate_bounds_of_probability_distribution(dist)
p = dist.pdf(a)
if time_step < a:
return 1
if a <= time_step <= b:
value = p * (b - time_step) - p * (time_step - a)
if value < 0:
return 0
return value
return 0
def function_cosine(self, dist_1, dist_2, bins=50):
a1, b1, a2, b2 = 0, 0, 0, 0
if dist_1 in self.bounds:
a1, b1 = self.bounds[dist_1]
else:
a1, b1 = calculate_bounds_of_probability_distribution(dist_1)
self.bounds[dist_1] = a1, b1
if dist_2 in self.bounds:
a2, b2 = self.bounds[dist_2]
else:
a2, b2 = calculate_bounds_of_probability_distribution(dist_2)
self.bounds[dist_2] = a2, b2
cosine_bounds_a, cosine_bounds_b = min(a1, a2), max(b1, b2)
delta = fabs(cosine_bounds_a - cosine_bounds_b) / bins
convolution_interval = TimeInterval(cosine_bounds_a, cosine_bounds_b, bins)
#convolution_interval = linspace(cosine_bounds_a, cosine_bounds_b, bins)
x = [dist_1.pdf(t) for t in convolution_interval]
y = [dist_2.pdf(t) for t in convolution_interval]
return cosine(x, y)
def function_cosine(self, dist_1, dist_2, bins=50):
a1, b1, a2, b2 = 0, 0, 0, 0
if dist_1 in self.bounds:
a1, b1 = self.bounds[dist_1]
else:
a1, b1 = calculate_bounds_of_probability_distribution(dist_1)
self.bounds[dist_1] = a1, b1
if dist_2 in self.bounds:
a2, b2 = self.bounds[dist_2]
else:
a2, b2 = calculate_bounds_of_probability_distribution(dist_2)
self.bounds[dist_2] = a2, b2
cosine_bounds_a, cosine_bounds_b = min(a1, a2), max(b1, b2)
delta = fabs(cosine_bounds_a - cosine_bounds_b) / bins
convolution_interval = TimeInterval(cosine_bounds_a, cosine_bounds_b,
bins)
#convolution_interval = linspace(cosine_bounds_a, cosine_bounds_b, bins)
x = [dist_1.pdf(t) for t in convolution_interval]
y = [dist_2.pdf(t) for t in convolution_interval]
return cosine(x, y)
def __init__(self, distribution_beginning, distribution_ending,
bins=50, distribution_integral_limit=DISTRIBUTION_INTEGRAL_LIMIT):
if not isinstance(distribution_beginning, rv_frozen):
raise TypeError("'distribution_beginning' should be a scipy frozen distribution")
if not isinstance(distribution_ending, rv_frozen):
raise TypeError("'distribution_ending' should be a scipy frozen distribution")
if not 0 < distribution_integral_limit <= 1:
raise TypeError("'distribution_integral_limit' should be within (0, 1]")
self._distribution_beginning = distribution_beginning
self._distribution_ending = distribution_ending
a, beginning = calculate_bounds_of_probability_distribution(distribution_beginning, distribution_integral_limit)
ending, b = calculate_bounds_of_probability_distribution(distribution_ending, distribution_integral_limit)
self._beginning = UnixTime(beginning)
self._ending = UnixTime(ending)
self.membership_function = MembershipFunction(self)
bins_beginning = bins / 2
bins_ending = bins - bins_beginning
self.interval_beginning = TimeInterval(a, beginning, bins_beginning)
self.interval_ending = TimeInterval(ending, b, bins_ending)
list.__init__(self, self.interval_beginning + self.interval_ending)
TimeInterval.__init__(self, a, b, bins)
def before_integral_bounds(self, dist_1, dist_2):
return calculate_bounds_of_probability_distribution(dist_1)
def same_integral_bounds(self, dist_1, dist_2):
dist_1_a, dist_1_b = calculate_bounds_of_probability_distribution(dist_1)
dist_2_a, dist_2_b = calculate_bounds_of_probability_distribution(dist_2)
return max(dist_1_a, dist_2_a), min(dist_1_b, dist_2_b)
def same_integral_bounds(self, dist_1, dist_2):
dist_1_a, dist_1_b = calculate_bounds_of_probability_distribution(
dist_1)
dist_2_a, dist_2_b = calculate_bounds_of_probability_distribution(
dist_2)
return max(dist_1_a, dist_2_a), min(dist_1_b, dist_2_b)
def after_integral_bounds(self, dist_1, dist_2):
return calculate_bounds_of_probability_distribution(dist_2)
def fn_after(dist_1, dist_2):
a1, b1 = calculate_bounds_of_probability_distribution(dist_1)
a2, b2 = calculate_bounds_of_probability_distribution(dist_2)
return integral(lambda z: dist_2.pdf(z) * fn_before_point(dist_1, z),
min(a1, a2), max(b1, b2))
def fn_after(dist_1, dist_2):
a1, b1 = calculate_bounds_of_probability_distribution(dist_1)
a2, b2 = calculate_bounds_of_probability_distribution(dist_2)
return integral(lambda z: dist_2.pdf(z) * fn_before_point(dist_1, z), min(a1, a2), max(b1, b2))
