class MembershipFunctionPiecewiseLinear(FunctionPiecewiseLinear):
function_undefined = FunctionHorizontalLinear(0)
def __call__(self, time=None):
if time is None:
time = self.input_list
return invoke_function_on(
super(MembershipFunctionPiecewiseLinear, self).__call__, time)
def __init__(self, dictionary_input_output):
cdf_input_list, cdf_output_list = convert_dict_to_sorted_lists(
dictionary_input_output)
list.__init__(self, cdf_input_list)
TimeInterval.__init__(self, self[0], self[-1], 2)
self.cdf = FunctionPiecewiseLinear(dictionary_input_output,
function_undefined=FUNCTION_ZERO)
self.cdf.dictionary_bounds_function[(self.b,
POSITIVE_INFINITY)] = FUNCTION_ONE
pdf_output_list = []
dictionary_bounds_function = {}
for bounds in sorted(self.cdf.dictionary_bounds_function):
a, b = bounds
if a in [NEGATIVE_INFINITY, POSITIVE_INFINITY
] or b in [NEGATIVE_INFINITY, POSITIVE_INFINITY]:
continue
pdf_y_intercept = fabs(self.cdf.derivative((a + b) / 2.0))
pdf_output_list.append(pdf_y_intercept)
dictionary_bounds_function[bounds] = FunctionHorizontalLinear(
pdf_y_intercept)
#dictionary_bounds_function[bounds] = FunctionLinear(
# x_0=a, y_0=pdf_y_intercept - pdf_y_intercept / 2.0,
# x_1=b, y_1=pdf_y_intercept + pdf_y_intercept / 2.0)
self.pdf = FunctionComposite(dictionary_bounds_function,
function_undefined=FUNCTION_ZERO,
domain=self,
is_normalised=True)
self.roulette_wheel = []
#center_of_mass_lower_bound = 0
#center_of_mass_set = False
self._mean = 0
for bounds in sorted(self.pdf.dictionary_bounds_function):
(a, b) = bounds
if a in [NEGATIVE_INFINITY, POSITIVE_INFINITY
] and b in [NEGATIVE_INFINITY, POSITIVE_INFINITY]:
continue
cdf = self.cdf.dictionary_bounds_function[bounds]
pdf = self.pdf.dictionary_bounds_function[bounds]
share = cdf(b)
self.roulette_wheel.append((a, b, share))
#if not center_of_mass_set and share > 0.5:
# self._center_of_mass = UnixTime(self._calculate_center_of_mass(center_of_mass_lower_bound, b))
# center_of_mass_set = True
#center_of_mass_lower_bound = b
self._mean += (a + b) / 2.0 * pdf(a) * (b - a)
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()