class Type_B_Interval_III(object):
def __init__(self):
self.set_str = ""
self.interval = FiniteSet()
self.val1 = None
self.val2 = None
self.left_border = True
self.right_border = True
self.interval_rep = 0
self.val_lst = []
def generate_interval(self, A, OP):
if OP == '\setminus':
if len(A.interval) == 1:
self.interval_rep = 1
self.val1 = choice([A.val_lst[0], -oo, oo])
if self.val1 == -oo or self.val1 == oo:
self.val2 = A.val_lst[0]
else:
self.val2 = choice([-oo, oo])
else:
self.interval_rep = 0
self.val1 = choice(A.val_lst)
self.val2 = self.val1
self.left_border = choice([True, False])
self.left_border = choice([True, False])
elif OP == '\cap':
self.interval_rep = 0
if len(A.val_lst) == 1:
if randint(0, 1) == 0:
self.val1 = randint(-25, A.val_lst[0])
self.val2 = A.val_lst[0] + randint(0, 2)
else:
self.val1 = A.val_lst[-1]-randint(0, 2)
self.val2 = randint(A.val_lst[-1], 25)
else:
if randint(0, 1) == 0:
self.val1 = randint(-25, A.val_lst[1])
self.val2 = A.val_lst[1] + randint(0, 2)
else:
self.val1 = A.val_lst[-1] - randint(0, 2)
self.val2 = randint(A.val_lst[-1], 25)
else:
self.interval_rep = 2
tmp_lst = [-5, -4, -3, -2, -1, 1, 2, 3, 4, 5]
tmp_lst.extend(A.val_lst)
for i in range(0, randint(1, 5)):
self.val_lst.append(choice(tmp_lst))
if self.interval_rep == 0:
self.interval = Interval(self.val1, self.val2, self.left_border, self.right_border)
self.set_str += "\{r \ | \ r \in \mathbb{R} \wedge \ "+str(self.val1)
self.set_str += '<' if self.left_border == True else '\leq'
self.set_str += ' \ r'
self.set_str += '<' if self.right_border == True else '\leq'
self.set_str += str(self.val2)
self.set_str += '\}'
if isinstance(self.interval, EmptySet):
self.interval = FiniteSet(self.val1)
self.set_str = '\{'+str(self.val1)+'\}'
elif self.interval_rep == 1:
self.interval = Interval(self.val1, self.val2, self.left_border, self.right_border)
self.set_str += "\{r \ | \ r \in \mathbb{R} \wedge \ r"
if self.val1 == -oo or self.val1 == oo:
if self.val1 == -oo:
self.set_str += '<' if self.left_border == True else '\leq'
else:
self.set_str += '>' if self.left_border == True else '\geq'
#if self.val1 == oo:
# self.set_str += '<' if self.left_border == True else '\leq'
#else:
# self.set_str += '>' if self.left_border == True else '\geq'
self.set_str += str(self.val2)+'\}'
else:
if self.val2 == -oo:
self.set_str += '<' if self.left_border == True else '\leq'
else:
self.set_str += '>' if self.left_border == True else '\geq'
#if self.val2 == oo:
# self.set_str += '<' if self.left_border == True else '\leq'
#else:
# self.set_str += '>' if self.left_border == True else '\geq'
self.set_str += str(self.val1)+'\}'
else:
for i in range(len(self.val_lst)):
self.interval = self.interval.union(FiniteSet(self.val_lst[i]))
self.set_str = '\{'+str(self.interval)+'\}'
def inequation_to_interval(inequation):
"""
Devuelve un intervalo a partir de una inequación
Parte del supuesto de que de un lado de la inecuación
se encuentra "x", sin operaciones.
"""
args = inequation.args
less = [LessThan, StrictLessThan]
greater = [GreaterThan, StrictGreaterThan]
if inequation.__class__ in greater + less: # [StrictGreaterThan, GreaterThan, StrictLessThan, LessThan]
inequation = _adapt(inequation)
args = inequation.args
a = args[0]
b = args[1]
if inequation.__class__ in greater:
if inequation.__class__ == StrictGreaterThan:
# Ejemplo: x > b
# Intervalo: (b, +oo)
return Interval.open(b, oo)
elif inequation.__class__ == GreaterThan:
# Ejemplo: x >= b
# Intervalo: [b, +oo)
return Interval(b, oo) # Cerrado por izquierda
elif inequation.__class__ in less:
if inequation.__class__ == StrictLessThan:
# Ejemplo: x < b
# Intervalo: (-oo, b)
return Interval.open(-oo, b)
elif inequation.__class__ == LessThan:
# Ejemplo: x <= b
# Intervalo: (-oo, b]
return Interval(-oo, b) # Cerrado por derecha
elif inequation.__class__ == And:
# El primer valor en args siempre es una inequación
_args = []
for arg in args:
_args.append(_adapt(arg))
args = _args
d = {1: [], 2: []}
for arg in args:
# FIXME: Y si hay otro And o un Or ?
if arg.__class__ in less:
d[1].append(inequation_to_interval(arg))
elif arg.__class__ in greater:
d[2].append(inequation_to_interval(arg))
if d[1]:
__less = True
_less = d[1][0]
for _i in d[1][1:]:
_less = Interval.union(_less, _i)
else:
__less = False
_less = EmptySet()
if d[2]:
__greater = True
_greater = d[2][0]
for _i in d[2][1:]:
_greater = Interval.union(_greater, _i)
else:
__greater = False
_greater = EmptySet()
if __greater and __less:
return _less.intersect(_greater)
elif __less and not __greater:
return _less
elif __greater and not __less:
return _greater
elif inequation.__class__ == Or:
interval = inequation_to_interval(args[0])
for arg in args[1:]:
interval = Union(interval, inequation_to_interval(arg))
return interval
elif inequation.__class__ == BooleanTrue:
# Por ejemplo: 4 > 2, todos los x pertenecientes
# a los reales cumplen esta inecuación
return REALS
elif inequation.__class__ == BooleanFalse:
# Por ejemplo: 2 > 4, ningún x perteneciente a los
# reales cumple con esta inecuación
return EmptySet()
else:
print inequation, inequation.__class__
def create_ui_set(self, X):
result = None
nums = []
allowed = "-0123456789{},()[]o"
if not all(c in allowed for c in X):
return False
if len(X) < 3 and X != '{}':
return False
if (X[0] == '(' or X[0] == '[') and (X[-1] == ')' or X[-1] == ']'):
nums = re.findall("[-\d]+", X)
if '-' in nums:
nums.remove('-')
if len(nums) == 1:
if '-oo' in X or 'oo' in X:
if '-oo' in X:
nums.append(nums[0])
nums[0] = -oo
elif 'oo' in X:
nums.append(oo)
else:
return False
if len(nums) != 2:
return False
commata = re.findall(",", X)
if len(commata) != 1:
return False
for i in range(len(X)):
if X[i] == ',' and not (((X[i-1].isdigit() or X[i+1].isdigit()) or (X[i-1] == 'o' or X[i+1] == 'o'))):
return False
left = True if X[0] == '(' else False
right = True if X[-1] == ')' else False
if oo in nums or -oo in nums:
if oo in nums:
result = Interval(int(nums[0]), oo, left, right)
return result
else:
result = Interval(-oo, int(nums[1]), left, right)
return result
else:
if nums[0] <= nums[1]:
result = Interval(int(nums[0]), int(nums[1]), left, right)
return result
else:
return False
elif X[0] == '{' and X[-1] == '}':
if len(X) == 2:
return EmptySet()
else:
nums = re.findall("[-\d]+", X)
if len(re.findall(",", X)) != len(nums)-1:
return False
num_count = 0
for i in range(len(nums)):
if X[i] == ',' and not X.index(nums[num_count]) < i and X[i+1] == ',':
return False
num_count += 1
result = FiniteSet()
for i in range(len(nums)):
result = result.union(FiniteSet(int(nums[i])))
return result
else:
return False
