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)
self.pdf = FunctionComposite(dictionary_bounds_function, function_undefined=FUNCTION_ZERO, domain=self,
is_normalised=True)
self.roulette_wheel = []
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))
self._mean += (a + b) / 2.0 * pdf(a) * (b - a)
def compare(self, dist_1, dist_2):
dist_1_interval = TimeInterval(*self.bounds_of(dist_1))
dist_2_interval = TimeInterval(*self.bounds_of(dist_2))
dictionary_input_output = {}
for time_step in dist_1_interval + dist_2_interval:
dictionary_input_output[time_step] = sqrt(
dist_1.pdf(time_step) * dist_2.pdf(time_step))
geometric_mean = FunctionPiecewiseLinear(
dictionary_input_output, function_undefined=FUNCTION_ZERO)
same = integral(geometric_mean, NEGATIVE_INFINITY, POSITIVE_INFINITY)
dist_1_mean, dist_1_skewness, dist_1_kurtosis = dist_1.stats(
moments='msk')
dist_1_standard_deviation = dist_1.std()
dist_2_mean, dist_2_skewness, dist_2_kurtosis = dist_2.stats(
moments='msk')
dist_2_standard_deviation = dist_2.std()
distance = fabs(dist_1_standard_deviation -
dist_2_standard_deviation) + fabs(dist_1_skewness -
dist_2_skewness)
distance += fabs(dist_1_kurtosis - dist_2_kurtosis)
delta = dist_1_mean - dist_2_mean
non_same_portion = 1.0 - same
portion_after, portion_before = 1.0, 0.0
if almost_equals(distance, 0):
if delta < 0:
portion_after, portion_before = 0.0, 1.0
else:
dist_1_standardized_pdf = lambda x: dist_1.pdf(
dist_1_standard_deviation * x + dist_1_mean)
dist_2_standardized_pdf = lambda x: dist_2.pdf(
dist_2_standard_deviation * x + dist_2_mean)
geometric_mean = lambda t: sqrt(
dist_1_standardized_pdf(t) * dist_2_standardized_pdf(t))
geometric_mean_scaled = lambda p: geometric_mean(p / distance)
geometric_mean_scaled_length = max(self.duration_of(dist_1),
self.duration_of(dist_2))
dictionary_input_output = {}
for time_step in TimeInterval(-geometric_mean_scaled_length / 2.0,
geometric_mean_scaled_length / 2.0):
dictionary_input_output[time_step] = geometric_mean_scaled(
time_step)
geometric_mean_scaled = FunctionPiecewiseLinear(
dictionary_input_output, function_undefined=FUNCTION_ZERO)
portion_after = integral(geometric_mean_scaled, NEGATIVE_INFINITY,
delta)
portion_before = integral(geometric_mean_scaled, delta,
POSITIVE_INFINITY)
after = portion_after / (portion_after +
portion_before) * non_same_portion
return 1.0 - same - after, same, after
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 generate_random_events(size=20):
from datetime import datetime
from spatiotemporal.time_intervals import TimeInterval
events = []
year_2010 = TimeInterval(datetime(2010, 1, 1), datetime(2011, 1, 1))
for i in xrange(size):
start = year_2010.random_time()
end = year_2010.random_time(start)
event = TemporalEventTrapezium(start, end)
events.append(event)
return events
def generate_random_events(size=20):
from datetime import datetime
from spatiotemporal.time_intervals import TimeInterval
events = []
year_2010 = TimeInterval(datetime(2010, 1, 1), datetime(2011, 1, 1))
for i in xrange(size):
start = year_2010.random_time()
end = year_2010.random_time(start)
event = TemporalEventTrapezium(start, end)
events.append(event)
return events
def __init__(self, event_a, event_b, event_c, plt=plt):
self.event_a = event_a
self.event_c = event_c
self.event_b_length_beginning = event_b.beginning - event_b.a
self.event_b_length_middle = self.event_b_length_beginning + event_b.ending - event_b.beginning
self.event_b_length_total = event_b.b - event_b.ending
self.plt = plt
self.fig = plt.figure(1)
self.ax_a_b = self.fig.add_subplot(4, 1, 1)
self.ax_b_c = self.fig.add_subplot(4, 1, 2)
self.ax_a_c = self.fig.add_subplot(4, 1, 3)
self.ax_relations = self.fig.add_subplot(4, 1, 4)
self.ax_a_b.set_xlim(0, 13)
self.ax_a_b.set_ylim(0, 1)
self.ax_b_c.set_xlim(0, 13)
self.ax_b_c.set_ylim(0, 1)
self.ax_a_c.set_xlim(0, 13)
self.ax_a_c.set_ylim(0, 1)
self.rects_a_b = self.ax_a_b.bar(x_axis, zeros_13)
self.rects_b_c = self.ax_b_c.bar(x_axis, zeros_13)
self.rects_a_c = self.ax_a_c.bar(x_axis, zeros_13)
self.line_a = Line2D([], [])
self.line_b = Line2D([], [])
self.line_c = Line2D([], [])
self.ax_relations.add_line(self.line_a)
self.ax_relations.add_line(self.line_b)
self.ax_relations.add_line(self.line_c)
a = min(event_a.a, event_c.a) - self.event_b_length_total
b = max(event_a.b, event_c.b)
self.ax_relations.set_xlim(a, b + self.event_b_length_total)
self.ax_relations.set_ylim(0, 1.1)
# self.interval = TimeInterval(a, b, 150)
self.interval = TimeInterval(a, b, 2)
self.ax_a_b.xaxis.set_minor_formatter(
self.ax_a_b.xaxis.get_major_formatter())
self.ax_a_b.xaxis.set_minor_locator(AutoMinorLocator(2))
self.ax_a_b.xaxis.set_ticklabels('poDedOP')
self.ax_a_b.xaxis.set_ticklabels('mFsSfM', minor=True)
self.ax_b_c.xaxis.set_minor_formatter(
self.ax_b_c.xaxis.get_major_formatter())
self.ax_b_c.xaxis.set_minor_locator(AutoMinorLocator(2))
self.ax_b_c.xaxis.set_ticklabels('poDedOP')
self.ax_b_c.xaxis.set_ticklabels('mFsSfM', minor=True)
self.ax_a_c.xaxis.set_minor_formatter(
self.ax_a_c.xaxis.get_major_formatter())
self.ax_a_c.xaxis.set_minor_locator(AutoMinorLocator(2))
self.ax_a_c.xaxis.set_ticklabels('poDedOP')
self.ax_a_c.xaxis.set_ticklabels('mFsSfM', minor=True)
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 _interval_from_self_if_none(self, a, b, interval):
if interval is None:
if (a, b) == (None, None):
interval = self
else:
interval = TimeInterval(a, b)
else:
assert_is_time_interval(interval)
return interval
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 same(self, dist_1, dist_2):
dist_1_a, dist_1_b = self.bounds_of(dist_1)
dist_2_a, dist_2_b = self.bounds_of(dist_2)
a, b = max(dist_1_a, dist_2_a), min(dist_1_b, dist_2_b)
interval = TimeInterval(a, b)
dictionary_input_output = {}
for time_step in interval:
dictionary_input_output[time_step] = dist_1.pdf(
time_step) * dist_2.pdf(time_step)
function = FunctionPiecewiseLinear(dictionary_input_output,
FUNCTION_ZERO)
return integral(function, a, b)
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 __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 generate_random_relations_file(size=20):
from datetime import datetime
from spatiotemporal.time_intervals import TimeInterval
csv_writer = csv.writer(open('relations.csv~', 'w'))
year_2010 = TimeInterval(datetime(2010, 1, 1), datetime(2011, 1, 1))
i = size
specifications = [None, None]
while i >= 0:
for j in xrange(2):
a = year_2010.random_time()
beg = year_2010.random_time(start=a)
end = year_2010.random_time(start=beg) #(start=a)
b = year_2010.random_time(start=end) #(start=max(end, beg))
specifications[j] = (a, b, beg, end)
a_beg, a_end = (specifications[0][0], specifications[0][2]), (specifications[0][3], specifications[0][1])
b_beg, b_end = (specifications[1][0], specifications[1][2]), (specifications[1][3], specifications[1][1])
valid = False
for bounds_1, bounds_2 in [
(a_beg, b_beg), (a_beg, b_end), (a_end, b_beg), (a_end, b_end)
]:
if overlaps(bounds_1, bounds_2):
valid = True
break
if not valid:
continue
event_1, event_2 = TemporalEventTrapezium(*specifications[0]), TemporalEventTrapezium(*specifications[1])
csv_writer.writerow((event_1 * event_2).to_list())
percentage = (size - i + 1) / float(size) * 100
if (size - i + 1) % 10**3 == 0:
print '%' + str(int(percentage))
i -= 1
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)
self.pdf = FunctionComposite(dictionary_bounds_function,
function_undefined=FUNCTION_ZERO,
domain=self,
is_normalised=True)
self.roulette_wheel = []
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))
self._mean += (a + b) / 2.0 * pdf(a) * (b - a)
def before(self, dist_1, dist_2):
a, b = self.bounds_of(dist_1)
# Cancel pdf's error
a += EPSILON
b -= EPSILON
interval = TimeInterval(a, b)
dictionary_input_output = {}
for time_step in interval:
dictionary_input_output[time_step] = dist_1.pdf(time_step) * (
1 - dist_2.cdf(time_step))
function = FunctionPiecewiseLinear(dictionary_input_output,
FUNCTION_ZERO)
return integral(function, a, b)
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 degree(self, time_step=None, a=None, b=None, interval=None):
"""
usage: provide 'time_step' or 'a' and 'b' or 'interval'
"""
if time_step is not None:
return self.membership_function(time_step)
if interval is None:
if (a, b) == (None, None):
interval = self
else:
interval = TimeInterval(a, b)
else:
check_is_time_interval(interval)
return integral(self.membership_function, interval.a, interval.b)
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 __repr__(self):
return TimeInterval.__repr__(self)
def __init__(self, a, b):
TimeInterval.__init__(self, a, b, 1)
class TemporalEvent(list, TimeInterval):
_distribution_beginning = None
_distribution_ending = None
_beginning = None
_ending = None
_dict = None
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 = RelationFormulaGeometricMean()
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 degree(self, time_step=None, a=None, b=None, interval=None):
"""
usage: provide 'time_step' or 'a' and 'b' or 'interval'
"""
if time_step is not None:
return self.membership_function(time_step)
if interval is None:
if (a, b) == (None, None):
interval = self
else:
interval = TimeInterval(a, b)
else:
check_is_time_interval(interval)
return integral(self.membership_function, interval.a, interval.b)
def temporal_relations_with(self, other):
return self._formula_creator.temporal_relations_between(self, other)
def instance(self):
return TemporalInstance(self.distribution_beginning.rvs(),
self.distribution_ending.rvs())
def to_dict(self):
if self._dict is None:
self._dict = {}
for time_step in self.to_list():
self._dict[time_step] = self.membership_function(time_step)
return self._dict
# def plot(self, show_distributions=False):
# import matplotlib.pyplot as plt
# plt.plot(self.to_datetime_list(), self.membership_function())
# if show_distributions:
# if hasattr(self.distribution_beginning, 'plot'):
# self.distribution_beginning.plot()
# else:
# plt.plot(self.interval_beginning.to_datetime_list(),
# self.distribution_beginning.pdf(self.interval_beginning))
# if hasattr(self.distribution_ending, 'plot'):
# self.distribution_ending.plot()
# else:
# plt.plot(self.interval_ending.to_datetime_list(),
# self.distribution_ending.pdf(self.interval_ending))
# return plt
def plot(self, plt=None, show_distributions=False):
if plt is None:
import matplotlib.pyplot as plt
plt.plot(self.to_float_list(), self.membership_function())
if show_distributions:
if hasattr(self.distribution_beginning, 'plot'):
self.distribution_beginning.plot()
else:
plt.plot(
self.interval_beginning.to_float_list(),
self.distribution_beginning.pdf(self.interval_beginning))
if hasattr(self.distribution_ending, 'plot'):
self.distribution_ending.plot()
else:
plt.plot(self.interval_ending.to_float_list(),
self.distribution_ending.pdf(self.interval_ending))
return plt
@property
def distribution_beginning(self):
return self._distribution_beginning
@property
def distribution_ending(self):
return self._distribution_ending
@property
def beginning(self):
return self._beginning
@property
def ending(self):
return self._ending
def __mul__(self, other):
return self.temporal_relations_with(other)
def __str__(self):
return repr(self)
def __init__(self, a, b):
TimeInterval.__init__(self, a, b, 1)
class TemporalEvent(list, TimeInterval):
_distribution_beginning = None
_distribution_ending = None
_beginning = None
_ending = None
_dict = None
_formula_creator = FormulaCreator(TemporalFormulaConvolution())
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 degree(self, time_step=None, a=None, b=None, interval=None):
"""
usage: provide 'time_step' or 'a' and 'b' or 'interval'
"""
if time_step is not None:
return self.membership_function(time_step)
if interval is None:
if (a, b) == (None, None):
interval = self
else:
interval = TimeInterval(a, b)
else:
check_is_time_interval(interval)
return integral(self.membership_function, interval.a, interval.b)
def temporal_relations_with(self, other):
return self._formula_creator.temporal_relations_between(self, other)
def instance(self):
return TemporalInstance(self.distribution_beginning.rvs(), self.distribution_ending.rvs())
def to_dict(self):
if self._dict is None:
self._dict = {}
for time_step in self.to_list():
self._dict[time_step] = self.membership_function(time_step)
return self._dict
def plot(self, show_distributions=False):
import matplotlib.pyplot as plt
plt.plot(self.to_datetime_list(), self.membership_function())
if show_distributions:
if hasattr(self.distribution_beginning, 'plot'):
self.distribution_beginning.plot()
else:
plt.plot(self.interval_beginning.to_datetime_list(),
self.distribution_beginning.pdf(self.interval_beginning))
if hasattr(self.distribution_ending, 'plot'):
self.distribution_ending.plot()
else:
plt.plot(self.interval_ending.to_datetime_list(),
self.distribution_ending.pdf(self.interval_ending))
return plt
@property
def distribution_beginning(self):
return self._distribution_beginning
@property
def distribution_ending(self):
return self._distribution_ending
@property
def beginning(self):
return self._beginning
@property
def ending(self):
return self._ending
def __mul__(self, other):
return self.temporal_relations_with(other)
def __str__(self):
return repr(self)
def __repr__(self):
return TimeInterval.__repr__(self)
class TemporalEvent(list, TimeInterval):
_distribution_beginning = None
_distribution_ending = None
_beginning = None
_ending = None
_dict = None
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 = RelationFormulaGeometricMean()
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 degree(self, time_step=None, a=None, b=None, interval=None):
"""
usage: provide 'time_step' or 'a' and 'b' or 'interval'
"""
if time_step is not None:
return self.membership_function(time_step)
if interval is None:
if (a, b) == (None, None):
interval = self
else:
interval = TimeInterval(a, b)
else:
check_is_time_interval(interval)
return integral(self.membership_function, interval.a, interval.b)
def temporal_relations_with(self, other):
return self._formula_creator.temporal_relations_between(self, other)
def instance(self):
return TemporalInstance(self.distribution_beginning.rvs(), self.distribution_ending.rvs())
def to_dict(self):
if self._dict is None:
self._dict = {}
for time_step in self.to_list():
self._dict[time_step] = self.membership_function(time_step)
return self._dict
# def plot(self, show_distributions=False):
# import matplotlib.pyplot as plt
# plt.plot(self.to_datetime_list(), self.membership_function())
# if show_distributions:
# if hasattr(self.distribution_beginning, 'plot'):
# self.distribution_beginning.plot()
# else:
# plt.plot(self.interval_beginning.to_datetime_list(),
# self.distribution_beginning.pdf(self.interval_beginning))
# if hasattr(self.distribution_ending, 'plot'):
# self.distribution_ending.plot()
# else:
# plt.plot(self.interval_ending.to_datetime_list(),
# self.distribution_ending.pdf(self.interval_ending))
# return plt
def plot(self, plt=None, show_distributions=False):
if plt is None:
import matplotlib.pyplot as plt
plt.plot(self.to_float_list(), self.membership_function())
if show_distributions:
if hasattr(self.distribution_beginning, 'plot'):
self.distribution_beginning.plot()
else:
plt.plot(self.interval_beginning.to_float_list(),
self.distribution_beginning.pdf(self.interval_beginning))
if hasattr(self.distribution_ending, 'plot'):
self.distribution_ending.plot()
else:
plt.plot(self.interval_ending.to_float_list(),
self.distribution_ending.pdf(self.interval_ending))
return plt
@property
def distribution_beginning(self):
return self._distribution_beginning
@property
def distribution_ending(self):
return self._distribution_ending
@property
def beginning(self):
return self._beginning
@property
def ending(self):
return self._ending
def __mul__(self, other):
return self.temporal_relations_with(other)
def __str__(self):
return repr(self)
