def test_Union_of_ProductSets_shares():
line = Interval(0, 2)
points = FiniteSet(0, 1, 2)
assert Union(line * line, line * points) == line * line
def compare_single_doc(gs, ann):
"""
Report on what proportion of a gold standard dataframe is
covered by the given annotations.
Assumes all annotations correspond to the same single document.
Evaluation
- exact - 0/1 an exact match on interval (1)
- partial - 0/1 partially detected (counts as miss)
False positives
- proportion of string incorrectly labelled as PHI (excluding white space)
- or proportion of labelled text beyond true labels
"""
# short circuit comparisons if trivial cases
if (gs.shape[0] == 0) | (ann.shape[0] == 0):
# if both df are empty, we will output an empty dataframe
performance = []
if gs.shape[0] > 0:
doc_id = gs['document_id'].values[0]
# append gold standard rows as misses
for i, row in gs.iterrows():
span = '{} {}'.format(row['start'], row['stop'])
performance.append(
[doc_id, row['annotation_id'], 0, 0, 1, span]
)
# if ann.shape[0] == 0:
# # append ann rows as false positives
# for i, row in ann.iterrows():
# span = '{} {}'.format(row['start'], row['stop'])
# performance.append(
# [doc_id, row['annotation_id'], 0, 0, 0, span])
performance = pd.DataFrame.from_records(
performance,
columns=[
'document_id', 'annotation_id', 'exact', 'partial', 'missed',
'span'
]
)
return performance
# performance is list of lists
# index, document_id, exact, partial, missed, start, stop
# if partial, start/stop denote the missed section
# otherwise, they encompass the entire entity
performance = list()
if gs.shape[0] > 0:
doc_id = gs['document_id'].values[0]
else:
doc_id = ann['document_id'].values[0]
# create right-open intervals
cmp_intervals = [
[x[0], x[1], False, True] for x in ann.loc[:, ['start', 'stop']].values
]
cmp_intervals = [Interval(*c) for c in cmp_intervals]
cmp_intervals = Union(*cmp_intervals)
for _, row in gs.iterrows():
# indices are right open
i = Interval(row['start'], row['stop'], False, True)
overlap = i.intersect(cmp_intervals)
mismatch = i - overlap
# exact match
if mismatch.is_EmptySet:
span = '{} {}'.format(row['start'], row['stop'])
performance.append([doc_id, row['annotation_id'], 1, 0, 0, span])
# partial match
else:
# no match
if mismatch == i:
span = '{} {}'.format(row['start'], row['stop'])
performance.append(
[doc_id, row['annotation_id'], 0, 0, 1, span]
)
else:
if type(mismatch) is Union:
# we have non-continuous segments in our mismatch
span = []
for m in mismatch.args:
m = adjust_interval(m)
span.append('{} {}'.format(m.left, m.right))
# brat format: non-contiguous segments are delimited by ';'
span = ';'.join(span)
else:
mismatch = adjust_interval(mismatch)
span = '{} {}'.format(mismatch.left, mismatch.right)
performance.append(
[doc_id, row['annotation_id'], 0, 1, 0, span]
)
# convert back to a dataframe with same index as gs
performance = pd.DataFrame.from_records(
performance,
columns=[
'document_id', 'annotation_id', 'exact', 'partial', 'missed', 'span'
]
)
return performance
def test_reduce_poly_inequalities_real_interval():
assert reduce_rational_inequalities([[Eq(x**2, 0)]], x,
relational=False) == FiniteSet(0)
assert reduce_rational_inequalities([[Le(x**2, 0)]], x,
relational=False) == FiniteSet(0)
assert reduce_rational_inequalities([[Lt(x**2, 0)]], x,
relational=False) == S.EmptySet
assert reduce_rational_inequalities(
[[Ge(x**2, 0)]], x, relational=False) == \
S.Reals if x.is_real else Interval(-oo, oo)
assert reduce_rational_inequalities(
[[Gt(x**2, 0)]], x, relational=False) == \
FiniteSet(0).complement(S.Reals)
assert reduce_rational_inequalities(
[[Ne(x**2, 0)]], x, relational=False) == \
FiniteSet(0).complement(S.Reals)
assert reduce_rational_inequalities([[Eq(x**2, 1)]], x,
relational=False) == FiniteSet(-1, 1)
assert reduce_rational_inequalities([[Le(x**2, 1)]], x,
relational=False) == Interval(-1, 1)
assert reduce_rational_inequalities([[Lt(x**2, 1)]], x,
relational=False) == Interval(
-1, 1, True, True)
assert reduce_rational_inequalities(
[[Ge(x**2, 1)]], x, relational=False) == \
Union(Interval(-oo, -1), Interval(1, oo))
assert reduce_rational_inequalities(
[[Gt(x**2, 1)]], x, relational=False) == \
Interval(-1, 1).complement(S.Reals)
assert reduce_rational_inequalities(
[[Ne(x**2, 1)]], x, relational=False) == \
FiniteSet(-1, 1).complement(S.Reals)
assert reduce_rational_inequalities([[Eq(x**2, 1.0)]], x,
relational=False) == FiniteSet(
-1.0, 1.0).evalf()
assert reduce_rational_inequalities([[Le(x**2, 1.0)]], x,
relational=False) == Interval(
-1.0, 1.0)
assert reduce_rational_inequalities([[Lt(x**2, 1.0)]], x,
relational=False) == Interval(
-1.0, 1.0, True, True)
assert reduce_rational_inequalities(
[[Ge(x**2, 1.0)]], x, relational=False) == \
Union(Interval(-inf, -1.0), Interval(1.0, inf))
assert reduce_rational_inequalities(
[[Gt(x**2, 1.0)]], x, relational=False) == \
Union(Interval(-inf, -1.0, right_open=True),
Interval(1.0, inf, left_open=True))
assert reduce_rational_inequalities([[Ne(
x**2, 1.0)]], x, relational=False) == \
FiniteSet(-1.0, 1.0).complement(S.Reals)
s = sqrt(2)
assert reduce_rational_inequalities(
[[Lt(x**2 - 1, 0), Gt(x**2 - 1, 0)]], x,
relational=False) == S.EmptySet
assert reduce_rational_inequalities(
[[Le(x**2 - 1, 0), Ge(x**2 - 1, 0)]], x,
relational=False) == FiniteSet(-1, 1)
assert reduce_rational_inequalities(
[[Le(x**2 - 2, 0), Ge(x**2 - 1, 0)]], x,
relational=False) == Union(Interval(-s, -1, False, False),
Interval(1, s, False, False))
assert reduce_rational_inequalities(
[[Le(x**2 - 2, 0), Gt(x**2 - 1, 0)]], x,
relational=False) == Union(Interval(-s, -1, False, True),
Interval(1, s, True, False))
assert reduce_rational_inequalities(
[[Lt(x**2 - 2, 0), Ge(x**2 - 1, 0)]], x,
relational=False) == Union(Interval(-s, -1, True, False),
Interval(1, s, False, True))
assert reduce_rational_inequalities(
[[Lt(x**2 - 2, 0), Gt(x**2 - 1, 0)]], x,
relational=False) == Union(Interval(-s, -1, True, True),
Interval(1, s, True, True))
assert reduce_rational_inequalities(
[[Lt(x**2 - 2, 0), Ne(x**2 - 1, 0)]], x,
relational=False) == Union(Interval(-s, -1, True, True),
Interval(-1, 1, True, True),
Interval(1, s, True, True))
assert reduce_rational_inequalities([[Lt(x**2, -1.)]], x) is S.false
def test_intersect():
x = Symbol('x')
assert Interval(0, 2).intersect(Interval(1, 2)) == Interval(1, 2)
assert Interval(0, 2).intersect(Interval(1, 2, True)) == \
Interval(1, 2, True)
assert Interval(0, 2, True).intersect(Interval(1, 2)) == \
Interval(1, 2, False, False)
assert Interval(0, 2, True, True).intersect(Interval(1, 2)) == \
Interval(1, 2, False, True)
assert Interval(0, 2).intersect(Union(Interval(0, 1), Interval(2, 3))) == \
Union(Interval(0, 1), Interval(2, 2))
assert FiniteSet(1, 2, x).intersect(FiniteSet(x)) == FiniteSet(x)
assert FiniteSet('ham', 'eggs').intersect(FiniteSet('ham')) == \
FiniteSet('ham')
assert FiniteSet(1, 2, 3, 4, 5).intersect(S.EmptySet) == S.EmptySet
assert Interval(0, 5).intersect(FiniteSet(1, 3)) == FiniteSet(1, 3)
assert Interval(0, 1, True, True).intersect(FiniteSet(1)) == S.EmptySet
assert Union(Interval(0, 1), Interval(2, 3)).intersect(Interval(1, 2)) == \
Union(Interval(1, 1), Interval(2, 2))
assert Union(Interval(0, 1), Interval(2, 3)).intersect(Interval(0, 2)) == \
Union(Interval(0, 1), Interval(2, 2))
assert Union(Interval(0, 1), Interval(2, 3)).intersect(Interval(1, 2, True, True)) == \
S.EmptySet
assert Union(Interval(0, 1), Interval(2, 3)).intersect(S.EmptySet) == \
S.EmptySet
assert Union(Interval(0, 5), FiniteSet('ham')).intersect(FiniteSet(2, 3, 4, 5, 6)) == \
FiniteSet(2, 3, 4, 5)
# tests for the intersection alias
assert Interval(0, 5).intersection(FiniteSet(1, 3)) == FiniteSet(1, 3)
assert Interval(0, 1, True, True).intersection(FiniteSet(1)) == S.EmptySet
assert Union(Interval(0, 1), Interval(2, 3)).intersection(Interval(1, 2)) == \
Union(Interval(1, 1), Interval(2, 2))
def test_union_iter():
# Use Range because it is ordered
u = Union(Range(3), Range(5), Range(4), evaluate=False)
# Round robin
assert list(u) == [0, 0, 0, 1, 1, 1, 2, 2, 2, 3, 3, 4]
def test_image_piecewise():
f = Piecewise((x, x <= -1), (1 / x**2, x <= 5), (x**3, True))
f1 = Piecewise((0, x <= 1), (1, x <= 2), (2, True))
assert imageset(x, f, Interval(-5, 5)) == Union(Interval(-5, -1),
Interval(S(1) / 25, oo))
assert imageset(x, f1, Interval(1, 2)) == FiniteSet(0, 1)
def H(S, alpha):
S = list(S.atoms())
a = S[1]
b = S[0]
return (alpha * a) + ((1 - alpha) * b)
# for alph in np.arange(0.1, 0.9, 0.1):
#%%
alph = 0.8
for i in range(15):
s1_min = np.random.randint(-100, 100)
s1_max = np.random.randint(s1_min, 100)
s2_min = np.random.randint(-100, 100)
s2_max = np.random.randint(s2_min, 100)
S1 = Interval(s1_min, s1_max)
S2 = Interval(s2_min, s2_max)
SU = Union(S1, S2)
HS1 = H(S1, alph)
HS2 = H(S2, alph)
HSU = H(SU, alph)
print("=====Alpha={}".format(alph))
print("S1={}, H[S1]={}".format(S1, HS1))
print("S2={}, H[S2]={}".format(S2, HS2))
print("SU={}, H[SU]={}".format(SU, HSU))
if HSU == HS1:
print("H[SU] is H[S1]")
elif HSU == HS2:
print("H[SU] is H[S2]")
def test_issue_9956():
assert Union(Interval(-oo, oo), FiniteSet(1)) == Interval(-oo, oo)
assert Interval(-oo, oo).contains(1) is S.true
def test_issue_9447():
a = Interval(0, 1) + Interval(2, 3)
assert Complement(S.UniversalSet, a) == Complement(
S.UniversalSet, Union(Interval(0, 1), Interval(2, 3)), evaluate=False)
assert Complement(S.Naturals, a) == Complement(
S.Naturals, Union(Interval(0, 1), Interval(2, 3)), evaluate=False)
def test_union():
assert Union(Interval(1, 2), Interval(2, 3)) == Interval(1, 3)
assert Union(Interval(1, 2), Interval(2, 3, True)) == Interval(1, 3)
assert Union(Interval(1, 3), Interval(2, 4)) == Interval(1, 4)
assert Union(Interval(1, 2), Interval(1, 3)) == Interval(1, 3)
assert Union(Interval(1, 3), Interval(1, 2)) == Interval(1, 3)
assert Union(Interval(1, 3, False, True), Interval(1, 2)) == \
Interval(1, 3, False, True)
assert Union(Interval(1, 3), Interval(1, 2, False, True)) == Interval(1, 3)
assert Union(Interval(1, 2, True), Interval(1, 3)) == Interval(1, 3)
assert Union(Interval(1, 2, True), Interval(1, 3,
True)) == Interval(1, 3, True)
assert Union(Interval(1, 2, True), Interval(1, 3, True, True)) == \
Interval(1, 3, True, True)
assert Union(Interval(1, 2, True, True), Interval(1, 3, True)) == \
Interval(1, 3, True)
assert Union(Interval(1, 3), Interval(2, 3)) == Interval(1, 3)
assert Union(Interval(1, 3, False, True), Interval(2, 3)) == \
Interval(1, 3)
assert Union(Interval(1, 2, False, True), Interval(2, 3, True)) != \
Interval(1, 3)
assert Union(Interval(1, 2), S.EmptySet) == Interval(1, 2)
assert Union(S.EmptySet) == S.EmptySet
assert Union(Interval(0,1), [FiniteSet(1.0/n) for n in range(1,10)]) == \
Interval(0,1)
assert Interval(1, 2).union(Interval(2, 3)) == \
Interval(1, 2) + Interval(2, 3)
assert Interval(1, 2).union(Interval(2, 3)) == Interval(1, 3)
assert Union(Set()) == Set()
assert FiniteSet(1) + FiniteSet(2) + FiniteSet(3) == FiniteSet(1, 2, 3)
assert FiniteSet(['ham']) + FiniteSet(['eggs']) == FiniteSet('ham', 'eggs')
assert FiniteSet(1, 2, 3) + S.EmptySet == FiniteSet(1, 2, 3)
assert FiniteSet(1, 2, 3) & FiniteSet(2, 3, 4) == FiniteSet(2, 3)
assert FiniteSet(1, 2, 3) | FiniteSet(2, 3, 4) == FiniteSet(1, 2, 3, 4)
# Test that Intervals and FiniteSets play nicely
assert Interval(1, 3) + FiniteSet(2) == Interval(1, 3)
assert Interval(1, 3, True, True) + FiniteSet(3) == Interval(
1, 3, True, False)
X = Interval(1, 3) + FiniteSet(5)
Y = Interval(1, 2) + FiniteSet(3)
XandY = X.intersect(Y)
assert 2 in X and 3 in X and 3 in XandY
assert X.subset(XandY) and Y.subset(XandY)
raises(TypeError, "Union(1, 2, 3)")
assert X.is_iterable == False
def test_issue_10113():
f = x**2/(x**2 - 4)
assert imageset(x, f, S.Reals) == Union(Interval(-oo, 0), Interval(1, oo, True, True))
assert imageset(x, f, Interval(-2, 2)) == Interval(-oo, 0)
assert imageset(x, f, Interval(-2, 3)) == Union(Interval(-oo, 0), Interval(S(9)/5, oo))
def union(data):
""" Union of a list of intervals e.g. [(1,2),(3,4)] """
intervals = [Interval(begin, end) for (begin, end) in data]
u = Union(*intervals)
return [u] if isinstance(u, Interval) \
else list(u.args)
from statsmodels.discrete.discrete_model import Probit, Logit
#Treasurer bills data
df = pd.read_csv("/Users/curtis/Desktop/stockfiles/Recession/GS10-TB3MS.csv", index_col=False)
#other parameters data
xls_file = pd.ExcelFile('/Users/curtis/Desktop/stockfiles/Recession/DataOrg.xlsx')
dfx=xls_file.parse('RInd')
#recession data from NBER
dfr = pd.read_csv("/Users/curtis/Desktop/stockfiles/Recession/NBER-1950.csv", index_col=False)
# construct recession intervals as one set
n = len(dfr['Start'])
k = Interval(0,0)
i=0
while i < n :
k = Union(k, Interval(dfr.iloc[i].values[0],dfr.iloc[i].values[1]))
i += 1
# k is the set of recession intervals
#construct a column for the target variable: If there is an recession in 12 months it will 1, otherwise 0.
df['Month'] = df.Month.astype(float)
df['Target'] =[1 if x+12 in k else 0 for x in df['Month']]
m=len(df["Target"])
df.loc[m,"Target"]=0
dfx["Target"]=df["Target"]
#we focus on last 420 rows and last 5 columns (parameters)
dfx=dfx.iloc[-420:,-5:]
dfx = dfx.reset_index(drop=True)
def test_solve_trig_abs():
assert solveset(Eq(sin(Abs(x)), 1), x, domain=S.Reals) == \
Union(ImageSet(Lambda(n, n*pi + (-1)**n*pi/2), S.Naturals0),
ImageSet(Lambda(n, -n*pi - (-1)**n*pi/2), S.Naturals0))
def test_reduce_poly_inequalities_real_interval():
with assuming(Q.real(x), Q.real(y)):
assert reduce_rational_inequalities([[Eq(x**2, 0)]],
x,
relational=False) == FiniteSet(0)
assert reduce_rational_inequalities([[Le(x**2, 0)]],
x,
relational=False) == FiniteSet(0)
assert reduce_rational_inequalities([[Lt(x**2, 0)]],
x,
relational=False) == S.EmptySet
assert reduce_rational_inequalities([[Ge(x**2, 0)]],
x,
relational=False) == Interval(
-oo, oo)
assert reduce_rational_inequalities(
[[Gt(x**2, 0)]], x, relational=False) == FiniteSet(0).complement
assert reduce_rational_inequalities(
[[Ne(x**2, 0)]], x, relational=False) == FiniteSet(0).complement
assert reduce_rational_inequalities([[Eq(x**2, 1)]],
x,
relational=False) == FiniteSet(
-1, 1)
assert reduce_rational_inequalities([[Le(x**2, 1)]],
x,
relational=False) == Interval(
-1, 1)
assert reduce_rational_inequalities([[Lt(x**2, 1)]],
x,
relational=False) == Interval(
-1, 1, True, True)
assert reduce_rational_inequalities([[Ge(x**2, 1)]],
x,
relational=False) == Union(
Interval(-oo, -1),
Interval(1, oo))
assert reduce_rational_inequalities([[Gt(x**2, 1)]],
x,
relational=False) == Interval(
-1, 1).complement
assert reduce_rational_inequalities([[Ne(x**2, 1)]],
x,
relational=False) == FiniteSet(
-1, 1).complement
assert reduce_rational_inequalities([[Eq(x**2, 1.0)]],
x,
relational=False) == FiniteSet(
-1.0, 1.0).evalf()
assert reduce_rational_inequalities([[Le(x**2, 1.0)]],
x,
relational=False) == Interval(
-1.0, 1.0)
assert reduce_rational_inequalities([[Lt(x**2, 1.0)]],
x,
relational=False) == Interval(
-1.0, 1.0, True, True)
assert reduce_rational_inequalities([[Ge(x**2, 1.0)]],
x,
relational=False) == Union(
Interval(-inf, -1.0),
Interval(1.0, inf))
assert reduce_rational_inequalities([[Gt(x**2, 1.0)]],
x,
relational=False) == Union(
Interval(-inf,
-1.0,
right_open=True),
Interval(1.0,
inf,
left_open=True))
assert reduce_rational_inequalities([[Ne(x**2, 1.0)]],
x,
relational=False) == FiniteSet(
-1.0, 1.0).complement
s = sqrt(2)
assert reduce_rational_inequalities(
[[Lt(x**2 - 1, 0), Gt(x**2 - 1, 0)]], x,
relational=False) == S.EmptySet
assert reduce_rational_inequalities(
[[Le(x**2 - 1, 0), Ge(x**2 - 1, 0)]], x,
relational=False) == FiniteSet(-1, 1)
assert reduce_rational_inequalities(
[[Le(x**2 - 2, 0), Ge(x**2 - 1, 0)]], x,
relational=False) == Union(Interval(-s, -1, False, False),
Interval(1, s, False, False))
assert reduce_rational_inequalities(
[[Le(x**2 - 2, 0), Gt(x**2 - 1, 0)]], x,
relational=False) == Union(Interval(-s, -1, False, True),
Interval(1, s, True, False))
assert reduce_rational_inequalities(
[[Lt(x**2 - 2, 0), Ge(x**2 - 1, 0)]], x,
relational=False) == Union(Interval(-s, -1, True, False),
Interval(1, s, False, True))
assert reduce_rational_inequalities(
[[Lt(x**2 - 2, 0), Gt(x**2 - 1, 0)]], x,
relational=False) == Union(Interval(-s, -1, True, True),
Interval(1, s, True, True))
assert reduce_rational_inequalities(
[[Lt(x**2 - 2, 0), Ne(x**2 - 1, 0)]], x,
relational=False) == Union(Interval(-s, -1, True, True),
Interval(-1, 1, True, True),
Interval(1, s, True, True))
def build_piecewise_matrix(sympy_obj, cur_exponents, low_temp, high_temp, output_matrix, symbol_matrix, param_symbols):
if sympy_obj == v.T:
sympy_obj = Mul(1.0, v.T)
elif sympy_obj == v.P:
sympy_obj = Mul(1.0, v.P)
if isinstance(sympy_obj, (Float, Integer, Rational)) or \
(isinstance(sympy_obj, (log, exp)) and isinstance(sympy_obj.args[0], (Float, Integer, Rational))):
result = float(sympy_obj)
if result != 0.0:
output_matrix.append([low_temp, high_temp] + list(cur_exponents) + [result])
elif isinstance(sympy_obj, Piecewise):
piece_args = [i for i in sympy_obj.args if i.expr != S.Zero]
intervals = [to_interval(i.cond) for i in piece_args]
if (len(intervals) > 1) and Intersection(intervals) != EmptySet():
raise ValueError('Overlapping intervals cannot be represented: {}'.format(intervals))
if not isinstance(Union(intervals), Interval):
raise ValueError('Piecewise intervals must be continuous')
if not all([arg.cond.free_symbols == {v.T} for arg in piece_args]):
raise ValueError('Only temperature-dependent piecewise conditions are supported')
exprs = [arg.expr for arg in piece_args]
for expr, invl in zip(exprs, intervals):
lowlim = invl.args[0] if invl.args[0] > low_temp else low_temp
highlim = invl.args[1] if invl.args[1] < high_temp else high_temp
if highlim < lowlim:
continue
build_piecewise_matrix(expr, cur_exponents, float(lowlim), float(highlim), output_matrix, symbol_matrix, param_symbols)
elif isinstance(sympy_obj, Symbol):
if sympy_obj in param_symbols:
symbol_matrix.append([low_temp, high_temp] + list(cur_exponents) + [param_symbols.index(sympy_obj)])
else:
warnings.warn('Setting undefined symbol {0} to zero'.format(sympy_obj))
elif isinstance(sympy_obj, Add):
sympy_obj = sympy_obj.expand()
for arg in sympy_obj.args:
build_piecewise_matrix(arg, cur_exponents, low_temp, high_temp, output_matrix, symbol_matrix, param_symbols)
elif isinstance(sympy_obj, Mul):
new_exponents = np.array(cur_exponents)
remaining_argument = S.One
num_piecewise = sum(isinstance(x, Piecewise) for x in sympy_obj.args)
if num_piecewise == 1:
collected_argument = S.One
piecewise_elem = None
for arg in sympy_obj.args:
if isinstance(arg, Piecewise):
piecewise_elem = arg
elif isinstance(arg, (Float, Integer, Rational)):
collected_argument *= float(arg)
else:
collected_argument *= arg
remaining_argument = Piecewise(*[(collected_argument * expr, cond) for expr, cond in piecewise_elem.args])
else:
for arg in sympy_obj.args:
if isinstance(arg, Pow):
if arg.base == v.T:
new_exponents[1] += int(arg.exp)
elif arg.base == v.P:
new_exponents[0] += int(arg.exp)
else:
raise NotImplementedError
elif arg == v.T:
new_exponents[1] += 1
elif arg == v.P:
new_exponents[0] += 1
elif arg == sympy_log(v.T):
new_exponents[3] += 1
elif arg == sympy_log(v.P):
new_exponents[2] += 1
else:
remaining_argument *= arg
if not isinstance(remaining_argument, Mul):
build_piecewise_matrix(remaining_argument, new_exponents, low_temp, high_temp,
output_matrix, symbol_matrix, param_symbols)
else:
raise NotImplementedError(sympy_obj, type(sympy_obj))
else:
raise NotImplementedError
def test_latex_union():
assert latex(Union(Interval(0, 1), Interval(2, 3))) == \
r"\left[0, 1\right] \cup \left[2, 3\right]"
assert latex(Union(Interval(1, 1), Interval(2, 2), Interval(3, 4))) == \
r"\left\{1, 2\right\} \cup \left[3, 4\right]"
def test_Union_contains():
assert zoo not in Union(Interval.open(-oo, 0), Interval.open(0, oo))
def test_union():
assert Union(Interval(1, 2), Interval(2, 3)) == Interval(1, 3)
assert Union(Interval(1, 2), Interval(2, 3, True)) == Interval(1, 3)
assert Union(Interval(1, 3), Interval(2, 4)) == Interval(1, 4)
assert Union(Interval(1, 2), Interval(1, 3)) == Interval(1, 3)
assert Union(Interval(1, 3), Interval(1, 2)) == Interval(1, 3)
assert Union(Interval(1, 3, False, True), Interval(1, 2)) == \
Interval(1, 3, False, True)
assert Union(Interval(1, 3), Interval(1, 2, False, True)) == Interval(1, 3)
assert Union(Interval(1, 2, True), Interval(1, 3)) == Interval(1, 3)
assert Union(Interval(1, 2, True), Interval(1, 3,
True)) == Interval(1, 3, True)
assert Union(Interval(1, 2, True), Interval(1, 3, True, True)) == \
Interval(1, 3, True, True)
assert Union(Interval(1, 2, True, True), Interval(1, 3, True)) == \
Interval(1, 3, True)
assert Union(Interval(1, 3), Interval(2, 3)) == Interval(1, 3)
assert Union(Interval(1, 3, False, True), Interval(2, 3)) == \
Interval(1, 3)
assert Union(Interval(1, 2, False, True), Interval(2, 3, True)) != \
Interval(1, 3)
assert Union(Interval(1, 2), S.EmptySet) == Interval(1, 2)
assert Union(S.EmptySet) == S.EmptySet
assert Interval(1, 2).union(Interval(2, 3)) == \
Interval(1, 2) + Interval(2, 3)
assert Interval(1, 2).union(Interval(2, 3)) == Interval(1, 3)
assert Union(Set()) == Set()
raises(ValueError, "Union(1, 2, 3)")
def test_intersect1():
assert all(
S.Integers.intersection(i) is i for i in (S.Naturals, S.Naturals0))
assert all(
i.intersection(S.Integers) is i for i in (S.Naturals, S.Naturals0))
s = S.Naturals0
assert S.Naturals.intersection(s) is S.Naturals
assert s.intersection(S.Naturals) is S.Naturals
x = Symbol('x')
assert Interval(0, 2).intersect(Interval(1, 2)) == Interval(1, 2)
assert Interval(0, 2).intersect(Interval(1, 2, True)) == \
Interval(1, 2, True)
assert Interval(0, 2, True).intersect(Interval(1, 2)) == \
Interval(1, 2, False, False)
assert Interval(0, 2, True, True).intersect(Interval(1, 2)) == \
Interval(1, 2, False, True)
assert Interval(0, 2).intersect(Union(Interval(0, 1), Interval(2, 3))) == \
Union(Interval(0, 1), Interval(2, 2))
assert FiniteSet(1, 2).intersect(FiniteSet(1, 2, 3)) == FiniteSet(1, 2)
assert FiniteSet(1, 2, x).intersect(FiniteSet(x)) == FiniteSet(x)
assert FiniteSet('ham', 'eggs').intersect(FiniteSet('ham')) == \
FiniteSet('ham')
assert FiniteSet(1, 2, 3, 4, 5).intersect(S.EmptySet) == S.EmptySet
assert Interval(0, 5).intersect(FiniteSet(1, 3)) == FiniteSet(1, 3)
assert Interval(0, 1, True, True).intersect(FiniteSet(1)) == S.EmptySet
assert Union(Interval(0, 1), Interval(2, 3)).intersect(Interval(1, 2)) == \
Union(Interval(1, 1), Interval(2, 2))
assert Union(Interval(0, 1), Interval(2, 3)).intersect(Interval(0, 2)) == \
Union(Interval(0, 1), Interval(2, 2))
assert Union(Interval(0, 1), Interval(2, 3)).intersect(Interval(1, 2, True, True)) == \
S.EmptySet
assert Union(Interval(0, 1), Interval(2, 3)).intersect(S.EmptySet) == \
S.EmptySet
assert Union(Interval(0, 5), FiniteSet('ham')).intersect(FiniteSet(2, 3, 4, 5, 6)) == \
Union(FiniteSet(2, 3, 4, 5), Intersection(FiniteSet(6), Union(Interval(0, 5), FiniteSet('ham'))))
# issue 8217
assert Intersection(FiniteSet(x), FiniteSet(y)) == \
Intersection(FiniteSet(x), FiniteSet(y), evaluate=False)
assert FiniteSet(x).intersect(S.Reals) == \
Intersection(S.Reals, FiniteSet(x), evaluate=False)
# tests for the intersection alias
assert Interval(0, 5).intersection(FiniteSet(1, 3)) == FiniteSet(1, 3)
assert Interval(0, 1, True, True).intersection(FiniteSet(1)) == S.EmptySet
assert Union(Interval(0, 1), Interval(2, 3)).intersection(Interval(1, 2)) == \
Union(Interval(1, 1), Interval(2, 2))
def test_intersect1():
assert all(
S.Integers.intersection(i) is i for i in (S.Naturals, S.Naturals0))
assert all(
i.intersection(S.Integers) is i for i in (S.Naturals, S.Naturals0))
s = S.Naturals0
assert S.Naturals.intersection(s) is S.Naturals
assert s.intersection(S.Naturals) is S.Naturals
x = Symbol('x')
assert Interval(0, 2).intersect(Interval(1, 2)) == Interval(1, 2)
assert Interval(0, 2).intersect(Interval(1, 2, True)) == \
Interval(1, 2, True)
assert Interval(0, 2, True).intersect(Interval(1, 2)) == \
Interval(1, 2, False, False)
assert Interval(0, 2, True, True).intersect(Interval(1, 2)) == \
Interval(1, 2, False, True)
assert Interval(0, 2).intersect(Union(Interval(0, 1), Interval(2, 3))) == \
Union(Interval(0, 1), Interval(2, 2))
assert FiniteSet(1, 2).intersect(FiniteSet(1, 2, 3)) == FiniteSet(1, 2)
assert FiniteSet(1, 2, x).intersect(FiniteSet(x)) == FiniteSet(x)
assert FiniteSet('ham', 'eggs').intersect(FiniteSet('ham')) == \
FiniteSet('ham')
assert FiniteSet(1, 2, 3, 4, 5).intersect(S.EmptySet) == S.EmptySet
assert Interval(0, 5).intersect(FiniteSet(1, 3)) == FiniteSet(1, 3)
assert Interval(0, 1, True, True).intersect(FiniteSet(1)) == S.EmptySet
assert Union(Interval(0, 1), Interval(2, 3)).intersect(Interval(1, 2)) == \
Union(Interval(1, 1), Interval(2, 2))
assert Union(Interval(0, 1), Interval(2, 3)).intersect(Interval(0, 2)) == \
Union(Interval(0, 1), Interval(2, 2))
assert Union(Interval(0, 1), Interval(2, 3)).intersect(Interval(1, 2, True, True)) == \
S.EmptySet
assert Union(Interval(0, 1), Interval(2, 3)).intersect(S.EmptySet) == \
S.EmptySet
assert Union(Interval(0, 5), FiniteSet('ham')).intersect(FiniteSet(2, 3, 4, 5, 6)) == \
Intersection(FiniteSet(2, 3, 4, 5, 6), Union(FiniteSet('ham'), Interval(0, 5)))
assert Intersection(FiniteSet(1, 2, 3), Interval(2, x), Interval(3, y)) == \
Intersection(FiniteSet(3), Interval(2, x), Interval(3, y), evaluate=False)
assert Intersection(FiniteSet(1, 2), Interval(0, 3), Interval(x, y)) == \
Intersection({1, 2}, Interval(x, y), evaluate=False)
assert Intersection(FiniteSet(1, 2, 4), Interval(0, 3), Interval(x, y)) == \
Intersection({1, 2}, Interval(x, y), evaluate=False)
# XXX: Is the real=True necessary here?
# https://github.com/sympy/sympy/issues/17532
m, n = symbols('m, n', real=True)
assert Intersection(FiniteSet(m), FiniteSet(m, n), Interval(m, m+1)) == \
FiniteSet(m)
# issue 8217
assert Intersection(FiniteSet(x), FiniteSet(y)) == \
Intersection(FiniteSet(x), FiniteSet(y), evaluate=False)
assert FiniteSet(x).intersect(S.Reals) == \
Intersection(S.Reals, FiniteSet(x), evaluate=False)
# tests for the intersection alias
assert Interval(0, 5).intersection(FiniteSet(1, 3)) == FiniteSet(1, 3)
assert Interval(0, 1, True, True).intersection(FiniteSet(1)) == S.EmptySet
assert Union(Interval(0, 1), Interval(2, 3)).intersection(Interval(1, 2)) == \
Union(Interval(1, 1), Interval(2, 2))
def union(data): # return interval, use .start/end to obtain num
""" Union of a list of intervals e.g. [(1,2),(3,4)] """
intervals = [Interval(begin, end) for (begin, end) in data]
u = Union(*intervals)
return [list(u.args[:2])] if isinstance(u, Interval) \
else list(u.args)
fields = dict()
intervals_for_union = []
while True:
line = f.readline()
m = pat1.match(line)
if m:
field = m.groups()[0]
a1, b1, a2, b2 = map(int, m.groups()[1:])
intervals_for_union.append(Interval(a1, b1))
intervals_for_union.append(Interval(a2, b2))
field_intvl = MyInterval(a1, b1, a2, b2)
fields[field] = field_intvl
else:
break
u = Union(*intervals_for_union)
# your ticket
f.readline()
your_ticket = list(map(int, f.readline().split(",")))
f.readline()
f.readline()
# get nearby tickets and find answer to part 1
nearby_tickets = []
rejected_value_sum = 0
while True:
line = f.readline()
if not line:
break
def test_solve_univariate_inequality():
assert isolve(x**2 >= 4,
x, relational=False) == Union(Interval(-oo, -2),
Interval(2, oo))
assert isolve(x**2 >= 4, x) == Or(And(Le(2, x), Lt(x, oo)),
And(Le(x, -2), Lt(-oo, x)))
assert isolve((x - 1)*(x - 2)*(x - 3) >= 0, x, relational=False) == \
Union(Interval(1, 2), Interval(3, oo))
assert isolve((x - 1)*(x - 2)*(x - 3) >= 0, x) == \
Or(And(Le(1, x), Le(x, 2)), And(Le(3, x), Lt(x, oo)))
assert isolve((x - 1)*(x - 2)*(x - 4) < 0, x, domain = FiniteSet(0, 3)) == \
Or(Eq(x, 0), Eq(x, 3))
# issue 2785:
assert isolve(x**3 - 2*x - 1 > 0, x, relational=False) == \
Union(Interval(-1, -sqrt(5)/2 + S(1)/2, True, True),
Interval(S(1)/2 + sqrt(5)/2, oo, True, True))
# issue 2794:
assert isolve(x**3 - x**2 + x - 1 > 0, x, relational=False) == \
Interval(1, oo, True)
#issue 13105
assert isolve((x + I) * (x + 2 * I) < 0, x) == Eq(x, 0)
assert isolve(((x - 1) * (x - 2) + I) * ((x - 1) * (x - 2) + 2 * I) < 0,
x) == Or(Eq(x, 1), Eq(x, 2))
assert isolve(
(((x - 1) * (x - 2) + I) * ((x - 1) * (x - 2) + 2 * I)) / (x - 2) > 0,
x) == Eq(x, 1)
raises(ValueError, lambda: isolve((x**2 - 3 * x * I + 2) / x < 0, x))
# numerical testing in valid() is needed
assert isolve(x**7 - x - 2 > 0, x) == \
And(rootof(x**7 - x - 2, 0) < x, x < oo)
# handle numerator and denominator; although these would be handled as
# rational inequalities, these test confirm that the right thing is done
# when the domain is EX (e.g. when 2 is replaced with sqrt(2))
assert isolve(1 / (x - 2) > 0, x) == And(S(2) < x, x < oo)
den = ((x - 1) * (x - 2)).expand()
assert isolve((x - 1)/den <= 0, x) == \
Or(And(-oo < x, x < 1), And(S(1) < x, x < 2))
n = Dummy('n')
raises(NotImplementedError,
lambda: isolve(Abs(x) <= n, x, relational=False))
c1 = Dummy("c1", positive=True)
raises(NotImplementedError, lambda: isolve(n / c1 < 0, c1))
n = Dummy('n', negative=True)
assert isolve(n / c1 > -2, c1) == (-n / 2 < c1)
assert isolve(n / c1 < 0, c1) == True
assert isolve(n / c1 > 0, c1) == False
zero = cos(1)**2 + sin(1)**2 - 1
raises(NotImplementedError, lambda: isolve(x**2 < zero, x))
raises(NotImplementedError, lambda: isolve(x**2 < zero * I, x))
raises(NotImplementedError, lambda: isolve(1 / (x - y) < 2, x))
raises(NotImplementedError, lambda: isolve(1 / (x - y) < 0, x))
raises(ValueError, lambda: isolve(x - I < 0, x))
zero = x**2 + x - x * (x + 1)
assert isolve(zero < 0, x, relational=False) is S.EmptySet
assert isolve(zero <= 0, x, relational=False) is S.Reals
# make sure iter_solutions gets a default value
raises(NotImplementedError,
lambda: isolve(Eq(cos(x)**2 + sin(x)**2, 1), x))
def probability(self, condition, given_condition=None, evaluate=True, **kwargs):
"""
Handles probability queries for Markov process.
Parameters
==========
condition: Relational
given_condition: Relational/And
Returns
=======
Probability
If the information is not sufficient.
Expr
In all other cases.
Note
====
Any information passed at the time of query overrides
any information passed at the time of object creation like
transition probabilities, state space.
Pass the transition matrix using TransitionMatrixOf,
generator matrix using GeneratorMatrixOf and state space
using StochasticStateSpaceOf in given_condition using & or And.
"""
check, mat, state_space, new_given_condition = \
self._preprocess(given_condition, evaluate)
if check:
return Probability(condition, new_given_condition)
if isinstance(self, ContinuousMarkovChain):
trans_probs = self.transition_probabilities(mat)
elif isinstance(self, DiscreteMarkovChain):
trans_probs = mat
if isinstance(condition, Relational):
rv, states = (list(condition.atoms(RandomIndexedSymbol))[0], condition.as_set())
if isinstance(new_given_condition, And):
gcs = new_given_condition.args
else:
gcs = (new_given_condition, )
grvs = new_given_condition.atoms(RandomIndexedSymbol)
min_key_rv = None
for grv in grvs:
if grv.key <= rv.key:
min_key_rv = grv
if min_key_rv == None:
return Probability(condition)
prob, gstate = dict(), None
for gc in gcs:
if gc.has(min_key_rv):
if gc.has(Probability):
p, gp = (gc.rhs, gc.lhs) if isinstance(gc.lhs, Probability) \
else (gc.lhs, gc.rhs)
gr = gp.args[0]
gset = Intersection(gr.as_set(), state_space)
gstate = list(gset)[0]
prob[gset] = p
else:
_, gstate = (gc.lhs.key, gc.rhs) if isinstance(gc.lhs, RandomIndexedSymbol) \
else (gc.rhs.key, gc.lhs)
if any((k not in self.index_set) for k in (rv.key, min_key_rv.key)):
raise IndexError("The timestamps of the process are not in it's index set.")
states = Intersection(states, state_space)
for state in Union(states, FiniteSet(gstate)):
if Ge(state, mat.shape[0]) == True:
raise IndexError("No information is available for (%s, %s) in "
"transition probabilities of shape, (%s, %s). "
"State space is zero indexed."
%(gstate, state, mat.shape[0], mat.shape[1]))
if prob:
gstates = Union(*prob.keys())
if len(gstates) == 1:
gstate = list(gstates)[0]
gprob = list(prob.values())[0]
prob[gstates] = gprob
elif len(gstates) == len(state_space) - 1:
gstate = list(state_space - gstates)[0]
gprob = S.One - sum(prob.values())
prob[state_space - gstates] = gprob
else:
raise ValueError("Conflicting information.")
else:
gprob = S.One
if min_key_rv == rv:
return sum([prob[FiniteSet(state)] for state in states])
if isinstance(self, ContinuousMarkovChain):
return gprob * sum([trans_probs(rv.key - min_key_rv.key).__getitem__((gstate, state))
for state in states])
if isinstance(self, DiscreteMarkovChain):
return gprob * sum([(trans_probs**(rv.key - min_key_rv.key)).__getitem__((gstate, state))
for state in states])
if isinstance(condition, Not):
expr = condition.args[0]
return S.One - self.probability(expr, given_condition, evaluate, **kwargs)
if isinstance(condition, And):
compute_later, state2cond, conds = [], dict(), condition.args
for expr in conds:
if isinstance(expr, Relational):
ris = list(expr.atoms(RandomIndexedSymbol))[0]
if state2cond.get(ris, None) is None:
state2cond[ris] = S.true
state2cond[ris] &= expr
else:
compute_later.append(expr)
ris = []
for ri in state2cond:
ris.append(ri)
cset = Intersection(state2cond[ri].as_set(), state_space)
if len(cset) == 0:
return S.Zero
state2cond[ri] = cset.as_relational(ri)
sorted_ris = sorted(ris, key=lambda ri: ri.key)
prod = self.probability(state2cond[sorted_ris[0]], given_condition, evaluate, **kwargs)
for i in range(1, len(sorted_ris)):
ri, prev_ri = sorted_ris[i], sorted_ris[i-1]
if not isinstance(state2cond[ri], Eq):
raise ValueError("The process is in multiple states at %s, unable to determine the probability."%(ri))
mat_of = TransitionMatrixOf(self, mat) if isinstance(self, DiscreteMarkovChain) else GeneratorMatrixOf(self, mat)
prod *= self.probability(state2cond[ri], state2cond[prev_ri]
& mat_of
& StochasticStateSpaceOf(self, state_space),
evaluate, **kwargs)
for expr in compute_later:
prod *= self.probability(expr, given_condition, evaluate, **kwargs)
return prod
if isinstance(condition, Or):
return sum([self.probability(expr, given_condition, evaluate, **kwargs)
for expr in condition.args])
raise NotImplementedError("Mechanism for handling (%s, %s) queries hasn't been "
"implemented yet."%(expr, condition))
def test_union():
assert Union(Interval(1, 2), Interval(2, 3)) == Interval(1, 3)
assert Union(Interval(1, 2), Interval(2, 3, True)) == Interval(1, 3)
assert Union(Interval(1, 3), Interval(2, 4)) == Interval(1, 4)
assert Union(Interval(1, 2), Interval(1, 3)) == Interval(1, 3)
assert Union(Interval(1, 3), Interval(1, 2)) == Interval(1, 3)
assert Union(Interval(1, 3, False, True), Interval(1, 2)) == \
Interval(1, 3, False, True)
assert Union(Interval(1, 3), Interval(1, 2, False, True)) == Interval(1, 3)
assert Union(Interval(1, 2, True), Interval(1, 3)) == Interval(1, 3)
assert Union(Interval(1, 2, True), Interval(1, 3, True)) == \
Interval(1, 3, True)
assert Union(Interval(1, 2, True), Interval(1, 3, True, True)) == \
Interval(1, 3, True, True)
assert Union(Interval(1, 2, True, True), Interval(1, 3, True)) == \
Interval(1, 3, True)
assert Union(Interval(1, 3), Interval(2, 3)) == Interval(1, 3)
assert Union(Interval(1, 3, False, True), Interval(2, 3)) == \
Interval(1, 3)
assert Union(Interval(1, 2, False, True), Interval(2, 3, True)) != \
Interval(1, 3)
assert Union(Interval(1, 2), S.EmptySet) == Interval(1, 2)
assert Union(S.EmptySet) == S.EmptySet
assert Union(Interval(0, 1), [FiniteSet(1.0/n) for n in range(1, 10)]) == \
Interval(0, 1)
assert Interval(1, 2).union(Interval(2, 3)) == \
Interval(1, 2) + Interval(2, 3)
assert Interval(1, 2).union(Interval(2, 3)) == Interval(1, 3)
assert Union(Set()) == Set()
assert FiniteSet(1) + FiniteSet(2) + FiniteSet(3) == FiniteSet(1, 2, 3)
assert FiniteSet('ham') + FiniteSet('eggs') == FiniteSet('ham', 'eggs')
assert FiniteSet(1, 2, 3) + S.EmptySet == FiniteSet(1, 2, 3)
assert FiniteSet(1, 2, 3) & FiniteSet(2, 3, 4) == FiniteSet(2, 3)
assert FiniteSet(1, 2, 3) | FiniteSet(2, 3, 4) == FiniteSet(1, 2, 3, 4)
x = Symbol("x")
y = Symbol("y")
z = Symbol("z")
assert S.EmptySet | FiniteSet(x, FiniteSet(y, z)) == \
FiniteSet(x, FiniteSet(y, z))
# Test that Intervals and FiniteSets play nicely
assert Interval(1, 3) + FiniteSet(2) == Interval(1, 3)
assert Interval(1, 3, True, True) + FiniteSet(3) == \
Interval(1, 3, True, False)
X = Interval(1, 3) + FiniteSet(5)
Y = Interval(1, 2) + FiniteSet(3)
XandY = X.intersect(Y)
assert 2 in X and 3 in X and 3 in XandY
assert XandY.is_subset(X) and XandY.is_subset(Y)
raises(TypeError, lambda: Union(1, 2, 3))
assert X.is_iterable is False
# issue 7843
assert Union(S.EmptySet,
FiniteSet(-sqrt(-I),
sqrt(-I))) == FiniteSet(-sqrt(-I), sqrt(-I))
def test_invert_real():
x = Dummy(real=True)
n = Symbol('n')
minus_n = Intersection(Interval(-oo, 0), FiniteSet(-n))
plus_n = Intersection(Interval(0, oo), FiniteSet(n))
assert solveset(abs(x) - n, x, S.Reals) == Union(minus_n, plus_n)
n = Symbol('n', real=True)
assert invert_real(x + 3, y, x) == (x, FiniteSet(y - 3))
assert invert_real(x * 3, y, x) == (x, FiniteSet(y / 3))
assert invert_real(exp(x), y, x) == (x, FiniteSet(log(y)))
assert invert_real(exp(3 * x), y, x) == (x, FiniteSet(log(y) / 3))
assert invert_real(exp(x + 3), y, x) == (x, FiniteSet(log(y) - 3))
assert invert_real(exp(x) + 3, y, x) == (x, FiniteSet(log(y - 3)))
assert invert_real(exp(x) * 3, y, x) == (x, FiniteSet(log(y / 3)))
assert invert_real(log(x), y, x) == (x, FiniteSet(exp(y)))
assert invert_real(log(3 * x), y, x) == (x, FiniteSet(exp(y) / 3))
assert invert_real(log(x + 3), y, x) == (x, FiniteSet(exp(y) - 3))
minus_y = Intersection(Interval(-oo, 0), FiniteSet(-y))
plus_y = Intersection(Interval(0, oo), FiniteSet(y))
assert invert_real(Abs(x), y, x) == (x, Union(minus_y, plus_y))
assert invert_real(2**x, y, x) == (x, FiniteSet(log(y) / log(2)))
assert invert_real(2**exp(x), y, x) == (x, FiniteSet(log(log(y) / log(2))))
assert invert_real(x**2, y, x) == (x, FiniteSet(sqrt(y), -sqrt(y)))
assert invert_real(x**Rational(1, 2), y, x) == (x, FiniteSet(y**2))
raises(ValueError, lambda: invert_real(x, x, x))
raises(ValueError, lambda: invert_real(x**pi, y, x))
raises(ValueError, lambda: invert_real(S.One, y, x))
assert invert_real(x**31 + x, y, x) == (x**31 + x, FiniteSet(y))
y_1 = Intersection(Interval(-1, oo), FiniteSet(y - 1))
y_2 = Intersection(Interval(-oo, -1), FiniteSet(-y - 1))
assert invert_real(Abs(x**31 + x + 1), y,
x) == (x**31 + x, Union(y_1, y_2))
assert invert_real(sin(x), y, x) == \
(x, imageset(Lambda(n, n*pi + (-1)**n*asin(y)), S.Integers))
assert invert_real(sin(exp(x)), y, x) == \
(x, imageset(Lambda(n, log((-1)**n*asin(y) + n*pi)), S.Integers))
assert invert_real(csc(x), y, x) == \
(x, imageset(Lambda(n, n*pi + (-1)**n*acsc(y)), S.Integers))
assert invert_real(csc(exp(x)), y, x) == \
(x, imageset(Lambda(n, log((-1)**n*acsc(y) + n*pi)), S.Integers))
assert invert_real(cos(x), y, x) == \
(x, Union(imageset(Lambda(n, 2*n*pi + acos(y)), S.Integers), \
imageset(Lambda(n, 2*n*pi - acos(y)), S.Integers)))
assert invert_real(cos(exp(x)), y, x) == \
(x, Union(imageset(Lambda(n, log(2*n*pi + acos(y))), S.Integers), \
imageset(Lambda(n, log(2*n*pi - acos(y))), S.Integers)))
assert invert_real(sec(x), y, x) == \
(x, Union(imageset(Lambda(n, 2*n*pi + asec(y)), S.Integers), \
imageset(Lambda(n, 2*n*pi - asec(y)), S.Integers)))
assert invert_real(sec(exp(x)), y, x) == \
(x, Union(imageset(Lambda(n, log(2*n*pi + asec(y))), S.Integers), \
imageset(Lambda(n, log(2*n*pi - asec(y))), S.Integers)))
assert invert_real(tan(x), y, x) == \
(x, imageset(Lambda(n, n*pi + atan(y)), S.Integers))
assert invert_real(tan(exp(x)), y, x) == \
(x, imageset(Lambda(n, log(n*pi + atan(y))), S.Integers))
assert invert_real(cot(x), y, x) == \
(x, imageset(Lambda(n, n*pi + acot(y)), S.Integers))
assert invert_real(cot(exp(x)), y, x) == \
(x, imageset(Lambda(n, log(n*pi + acot(y))), S.Integers))
assert invert_real(tan(tan(x)), y, x) == \
(tan(x), imageset(Lambda(n, n*pi + atan(y)), S.Integers))
x = Symbol('x', positive=True)
assert invert_real(x**pi, y, x) == (x, FiniteSet(y**(1 / pi)))
# Test for ``set_h`` containing information about the domain
n = Dummy('n')
x = Symbol('x')
h1 = Intersection(Interval(-3, oo), FiniteSet(a + b - 3),
imageset(Lambda(n, -n + a - 3), Interval(-oo, 0)))
h2 = Intersection(Interval(-oo, -3), FiniteSet(-a + b - 3),
imageset(Lambda(n, n - a - 3), Interval(0, oo)))
h3 = Intersection(Interval(-3, oo), FiniteSet(a - b - 3),
imageset(Lambda(n, -n + a - 3), Interval(0, oo)))
h4 = Intersection(Interval(-oo, -3), FiniteSet(-a - b - 3),
imageset(Lambda(n, n - a - 3), Interval(-oo, 0)))
assert invert_real(Abs(Abs(x + 3) - a) - b, 0,
x) == (x, Union(h1, h2, h3, h4))
def test_union_boundary_of_joining_sets():
""" Testing the boundary of unions is a hard problem """
assert Union(Interval(0, 10), Interval(10, 15), evaluate=False).boundary \
== FiniteSet(0, 15)
def compare(goldstandard, comparison):
"""
Report on what proportion of the gold standard corpus is
covered by the given annotations.
Evaluation
- exact - 0/1 an exact match on interval (1)
- partial - 0/1 partially detected (counts as miss)
False positives
- proportion of string incorrectly labelled as PHI (excluding white space)
- or proportion of labelled text beyond true labels
"""
group_names = ['document_id']
cols = ['document_id', 'annotation_id', 'start', 'stop', 'entity']
# stack gold standard and annotations into the same dataframe
comparison['annotation_id'] = comparison['annotator']
df = pd.concat(
[goldstandard[cols], comparison[cols]], ignore_index=True, axis=0
)
# delineate gold standard from annotation
df['source'] = 'gs'
df.loc[goldstandard.shape[0]:, 'source'] = 'ann'
# performance is list of lists
# index, document_id, exact, partial, missed, start, stop
# if partial, start/stop denote the missed section
# otherwise, they encompass the entire entity
performance = list()
n_groups = df[group_names].drop_duplicates().shape[0]
# iterate through each document
for grp_idx, grp in tqdm(df.groupby(group_names), total=n_groups):
idxG = grp['source'] == 'gs'
# create right-open intervals
cmp_intervals = [
[x[0], x[1], False, True]
for x in grp.loc[~idxG, ['start', 'stop']].values
]
cmp_intervals = [Interval(*c) for c in cmp_intervals]
cmp_intervals = Union(*cmp_intervals)
for idx, row in grp.loc[idxG, :].iterrows():
# indices are right open
i = Interval(row['start'], row['stop'], False, True)
overlap = i.intersect(cmp_intervals)
mismatch = i - overlap
# exact match
if mismatch.is_EmptySet:
span = '{} {}'.format(row['start'], row['stop'])
performance.append(
[grp_idx, row['annotation_id'], 1, 0, 0, span]
)
# partial match
else:
# no match
if mismatch == i:
span = '{} {}'.format(row['start'], row['stop'])
performance.append(
[grp_idx, row['annotation_id'], 0, 0, 1, span]
)
else:
if type(mismatch) is Union:
# we have non-continuous segments in our mismatch
span = []
for m in mismatch.args:
m = adjust_interval(m)
span.append('{} {}'.format(m.left, m.right))
# brat format: non-contiguous segments are delimited by ';'
span = ';'.join(span)
else:
mismatch = adjust_interval(mismatch)
span = '{} {}'.format(mismatch.left, mismatch.right)
performance.append(
[grp_idx, row['annotation_id'], 0, 1, 0, span]
)
# convert back to a dataframe with same index as gs
performance = pd.DataFrame.from_records(
performance,
columns=[
'document_id', 'annotation_id', 'exact', 'partial', 'missed', 'span'
]
)
return performance
