def test_sets():
x = Integer(2)
y = Integer(3)
x1 = sympy.Integer(2)
y1 = sympy.Integer(3)
assert Interval(x, y) == Interval(x1, y1)
assert Interval(x1, y) == Interval(x1, y1)
assert Interval(x, y)._sympy_() == sympy.Interval(x1, y1)
assert sympify(sympy.Interval(x1, y1)) == Interval(x, y)
assert sympify(sympy.EmptySet()) == EmptySet()
assert sympy.EmptySet() == EmptySet()._sympy_()
assert FiniteSet(x, y) == FiniteSet(x1, y1)
assert FiniteSet(x1, y) == FiniteSet(x1, y1)
assert FiniteSet(x, y)._sympy_() == sympy.FiniteSet(x1, y1)
assert sympify(sympy.FiniteSet(x1, y1)) == FiniteSet(x, y)
x = Interval(1, 2)
y = Interval(2, 3)
x1 = sympy.Interval(1, 2)
y1 = sympy.Interval(2, 3)
assert Union(x, y) == Union(x1, y1)
assert Union(x1, y) == Union(x1, y1)
assert Union(x, y)._sympy_() == sympy.Union(x1, y1)
assert sympify(sympy.Union(x1, y1)) == Union(x, y)
assert Complement(x, y) == Complement(x1, y1)
assert Complement(x1, y) == Complement(x1, y1)
assert Complement(x, y)._sympy_() == sympy.Complement(x1, y1)
assert sympify(sympy.Complement(x1, y1)) == Complement(x, y)
def str2finiteset(s, local_dict={}):
"""
Convert a latex string into a finite set.
"""
s = s.strip()
if s == "\\emptyset":
return EmptySet()
pattern = re.compile(r'^\\{(.*)\\}$')
if pattern.match(s) is not None:
elements = str2expr(pattern.match(s).group(1))
if type(elements) == tuple:
return sp.FiniteSet(*elements)
else:
return sp.FiniteSet(elements)
def str2interval(s, local_dict={}):
"""
Convert a latex string into an interval.
"""
s = s.strip()
s = s.replace("\emptyset", "EmptySet()")
s = s.replace("\R", "S.Reals")
s = s.replace("\infty", "oo")
pattern = re.compile(r'\\{(.*)\\}')
if pattern.search(s) is not None:
return sp.FiniteSet(str2expr(pattern.search(s).group(1)))
pattern = re.compile(r'\\lbrack(.*),(.*)\\rbrack')
if pattern.search(s) is not None:
return sp.Interval(str2expr(pattern.search(s).group(1)),
str2expr(pattern.search(s).group(2)))
pattern = re.compile(r'\\lbrack(.*),(.*)\\lbrack')
if pattern.search(s) is not None:
return sp.Interval.Ropen(str2expr(pattern.search(s).group(1)),
str2expr(pattern.search(s).group(2)))
pattern = re.compile(r'\\rbrack(.*),(.*)\\rbrack')
if pattern.search(s) is not None:
return sp.Interval.Lopen(str2expr(pattern.search(s).group(1)),
str2expr(pattern.search(s).group(2)))
pattern = re.compile(r'\\rbrack(.*),(.*)\\lbrack')
if pattern.search(s) is not None:
return sp.Interval.open(str2expr(pattern.search(s).group(1)),
str2expr(pattern.search(s).group(2)))
def transform_set(x, expr, sympy_set):
""" Transform a sympy_set by an expression
>>> x = sympy.Symbol('x')
>>> domain = sympy.Interval(-sympy.pi / 4, -sympy.pi / 6, False, True) | sympy.Interval(sympy.pi / 6, sympy.pi / 4, True, False)
>>> transform_set(x, -2 * x, domain)
[-pi/2, -pi/3) U (pi/3, pi/2]
"""
if isinstance(sympy_set, sympy.Union):
return sympy.Union(
transform_set(x, expr, arg) for arg in sympy_set.args)
if isinstance(sympy_set, sympy.Intersection):
return sympy.Intersection(
transform_set(x, expr, arg) for arg in sympy_set.args)
f = sympy.Lambda(x, expr)
if isinstance(sympy_set, sympy.Interval):
left, right = f(sympy_set.left), f(sympy_set.right)
if left < right:
new_left_open = sympy_set.left_open
new_right_open = sympy_set.right_open
else:
new_left_open = sympy_set.right_open
new_right_open = sympy_set.left_open
return sympy.Interval(sympy.Min(left, right), sympy.Max(left, right),
new_left_open, new_right_open)
if isinstance(sympy_set, sympy.FiniteSet):
return sympy.FiniteSet(list(map(f, sympy_set)))
def solve_rectangle_eqs(E, w, h, k):
n_rect_vars = E.shape[1]
# For a fully symbolic solution, uncomment next line and specify
# symbols in solver:
# w, h, k = sp.symbols('w h k')
N = n_rect_vars//2
dF = [0]*(3*N + 1)
size_avg = w*h/N
# c controls the relation between the two optimization criteria.
c = 0.
T = c*h*h
# Factor for size
Q = 1.
# Add symbols (widths, heights, lambdas)
W = sp.symbols('w:{}'.format(N), positive=True)
H = sp.symbols('h:{}'.format(N), positive=True)
L = sp.symbols('l:{}'.format(N + 1))
# Create the expressions
# dF/dw_i
for i in range(N):
dF[i] = 2*Q*H[i]*(W[i]*H[i] - size_avg)
dF[i] += 2*T*(W[i] - k*H[i])
for j in range(N + 1):
dF[i] += L[j]*E[j, i]
# dF/dh_i
for i in range(N):
dF[N + i] = 2*Q*W[i]*(W[i]*H[i] - size_avg)
dF[N + i] += -2*T*k*(W[i] - k*H[i])
for j in range(N + 1):
dF[N + i] += L[j]*E[j, N + i]
# dF/dl_j
for j in range(N + 1):
for i in range(N):
dF[2*N + j] += E[j, i]*W[i] + E[j, N + i]*H[i]
dF[2*N] += -w
dF[2*N + 1] += -h
# Solve the system
symbols = []
symbols.extend(W)
symbols.extend(H)
symbols.extend(L)
# 1. nonlinsolve() if Q != 0
# 2. linsolve() if Q == 0
# 3. solve() seems to work better than nonlinsolve(), but only if
# you run sp.solve(dF), not sp.solve(dF, symbols), which is weird.
# To use it, convert solution to return a FiniteSet.
# return sp.nonlinsolve(dF, symbols)
# return sp.linsolve(dF, symbols)
sol_dict = sp.solve(dF)
if len(sol_dict) > 1:
print('Warning: more than one solution')
mat = get_matrix_from_solution(N, sol_dict[0])
sol_ls = []
for i in range(N):
sol_ls.append(mat[0, i])
for i in range(N):
sol_ls.append(mat[1, i])
return sp.FiniteSet(tuple(sol_ls))
def test_sets():
x = Integer(2)
y = Integer(3)
x1 = sympy.Integer(2)
y1 = sympy.Integer(3)
assert Interval(x, y) == Interval(x1, y1)
assert Interval(x1, y) == Interval(x1, y1)
assert Interval(x, y)._sympy_() == sympy.Interval(x1, y1)
assert sympify(sympy.Interval(x1, y1)) == Interval(x, y)
assert sympify(sympy.S.EmptySet) == EmptySet()
assert sympy.S.EmptySet == EmptySet()._sympy_()
assert sympify(sympy.S.UniversalSet) == UniversalSet()
assert sympy.S.UniversalSet == UniversalSet()._sympy_()
assert sympify(sympy.S.Reals) == Reals()
assert sympy.S.Reals == Reals()._sympy_()
assert sympify(sympy.S.Rationals) == Rationals()
assert sympy.S.Rationals == Rationals()._sympy_()
assert sympify(sympy.S.Integers) == Integers()
assert sympy.S.Integers == Integers()._sympy_()
assert FiniteSet(x, y) == FiniteSet(x1, y1)
assert FiniteSet(x1, y) == FiniteSet(x1, y1)
assert FiniteSet(x, y)._sympy_() == sympy.FiniteSet(x1, y1)
assert sympify(sympy.FiniteSet(x1, y1)) == FiniteSet(x, y)
x = Interval(1, 2)
y = Interval(2, 3)
x1 = sympy.Interval(1, 2)
y1 = sympy.Interval(2, 3)
assert Union(x, y) == Union(x1, y1)
assert Union(x1, y) == Union(x1, y1)
assert Union(x, y)._sympy_() == sympy.Union(x1, y1)
assert sympify(sympy.Union(x1, y1)) == Union(x, y)
assert Complement(x, y) == Complement(x1, y1)
assert Complement(x1, y) == Complement(x1, y1)
assert Complement(x, y)._sympy_() == sympy.Complement(x1, y1)
assert sympify(sympy.Complement(x1, y1)) == Complement(x, y)
def meros(self, super, constraint): #部分集合の生成
emp = []
x = self.x
for i in super:
x = x.subs(x, i)
expr = eval(constraint)
if expr == True:
emp.append(i)
return sp.FiniteSet(*emp)
def maximal_domain(expr, domain=sympy.Interval(-oo, oo)):
''' Return the maximal domain of an expression.
>>> maximal_domain(sympy.log(x**2 - 1))
(-oo, -1) U (1, oo)
>>> maximal_domain(1 / (x**2 - 4))
(-oo, -2) U (-2, 2) U (2, oo)
>>> maximal_domain((x - 2) ** (sympy.Rational(3, 2)))
(2, oo)
'''
# 4 possible scenarios:
# 1. 1/(a) -- a != 0
# 2. sqrt(b) -- b > 0
# 3. log(c) -- c > 0
# 4. tan(d) -- d != the solutions of tan
for symbol in expr.free_symbols:
if symbol == x:
expr = expr.replace(x, sympy.Symbol('x', real=True))
else:
raise NotImplementedError('only x is currently supported - but that can be easily changed')
powers = expr.find(sympy.Pow)
# case 1
for power in powers:
if power.args[1] < 0:
denominator = power.args[0]
solution = sympy.solve(denominator)
domain &= -sympy.FiniteSet(solution)
# case 2
if isinstance(power.args[1], sympy.Rational):
if power.args[1].q % 2 != 0:
continue
sqrt_interior = power.args[0]
solution = sympy.solve(sqrt_interior > 0)
domain &= relation_to_interval(solution)
# case 3
logs = expr.find(sympy.log)
for log in logs:
interior = log.args[0]
solution = sympy.solve(interior > 0)
domain &= relation_to_interval(solution)
# case 4
if expr.find(sympy.tan) or expr.find(sympy.cot) or expr.find(sympy.sec) or expr.find(sympy.csc):
raise NotImplementedError('tan/cot/sec/csc are not supported')
return domain
def correct(self):
if not self.answer:
return False
# Prevent user from just copying the equation
for sol in self.answer:
if len(sol.atoms(sympy.Symbol)):
return False
solution = sympy.solveset(self.equation, self.x)
sol_count = len(solution.args)
return len(solution.intersect(
sympy.FiniteSet(*self.answer)).args) >= sol_count
def parameter_space(self):
"""The parameter space set
A fixed parameter will be constrained to one single value
and non-fixed parameters will be constrained to an interval
possibly open in one or both ends.
"""
if self.fix:
return sympy.FiniteSet(self.init)
else:
return sympy.Interval(self.lower, self.upper)
def __init__(self, *items, name='noName'):
'''
Init a relation object.
parameters:
items: 2-tuple list define the relation
name:this is an optional argument,you can give name to the relation
returns
a relation object
example:
Relation.setA(1,2,3)
r1 = Relation((1,2),(2,3),name = "simple relation')
'''
#if sympy.Eq(self.A,sympy.EmptySet):
# print('empty A')
# self.setA(1,2,3,4)
if len(items) == 0:
sympy.FiniteSet(('xxx', 'xxx'))
else:
sympy.FiniteSet(self, *items)
self.name = name
def __init__(self, part):
self.num_lines, self.num_marks = 3, 1
self._qp = copy.deepcopy(part._qp)
self._qp['domain'] = sympy.Interval(-sympy.oo, sympy.oo)
for piecewise_part in self._qp['equation'].args:
expr = piecewise_part[0]
self._qp['domain'] &= functions.maximal_domain(
expr, self._qp['domain'])
if expr.find(
sympy.Abs
): # an absolute value is not differentiable at its vertex
match = expr.match(coeff0 * sympy.Abs(coeff1 * x - coeff2) +
coeff3)
self._qp['domain'] -= sympy.FiniteSet(match[coeff2] /
match[coeff1])
# a piecewise function is not differentiable at the meeting points of the subparts (unless the same y-coordinate
# and the same derivative is approached from both sides, which it is guaranteed not to)
middle = self._qp['equation'].args[0].args[1].rhs
self._qp['domain'] -= sympy.FiniteSet(middle)
def closest(sample_args, count=None):
"""Ask for the closest to a given value in a list."""
sample_args = sample_args()
context = composition.Context()
entropy, sample_args = sample_args.peel()
if count is None:
count = random.randint(*_closest_count_range(entropy))
display_multichoice = random.choice([False, True])
if display_multichoice:
_mark_choice_letters_used(count, context)
entropy_target, entropy_list = entropy * np.random.dirichlet([1, count])
target = integer_or_rational_or_decimal(entropy_target)
while True:
value_entropies = entropy_list * np.random.dirichlet(np.ones(count))
value_entropies = np.maximum(1, value_entropies)
values = [
integer_or_rational_or_decimal(ent) for ent in value_entropies
]
differences = [abs(sympy.sympify(value) - target) for value in values]
if len(sympy.FiniteSet(
*differences)) == count: # all differences unique
break
target_and_entities = context.sample(sample_args, [target] + values)
target = target_and_entities[0]
entities = target_and_entities[1:]
min_difference = min(differences)
answer_index = differences.index(min_difference)
answer = entities[answer_index]
adjective = random.choice([
'terdekat',
])
if display_multichoice:
return _closest_multichoice_question(context=context,
entities=entities,
target=target,
adjective=adjective,
answer=answer)
else:
return _closest_in_list_question(context=context,
entities=entities,
target=target,
adjective=adjective,
answer=answer)
def setA(cls, *items):
"""
This is a class method. Set discourse
Parameters:
items: lists of elements of set
Returns:
no return
"""
cls.A = sympy.FiniteSet(*items)
cls.id2items = {}
num = 0
for i in cls.A:
cls.id2items[num] = i
num = num + 1
def concept_solution(request, concept_id):
"""
Retrieve, update or delete a code concept.
"""
# Functions of request.query_params: https://kite.com/python/docs/django.http.QueryDict
hypothesis_str = request.query_params.get('hypothesis')
goal_str = request.query_params.get('goal')
try:
concept = Concept.objects.get(pk=concept_id)
except Concept.DoesNotExist:
return Response(status=status.HTTP_404_NOT_FOUND)
local_vars = {}
for attribute in concept.attributes.get_queryset():
symbol = attribute.symbol
local_vars[symbol] = sympy.symbols(symbol)
equations = sympy.FiniteSet()
for eq in concept.equations.get_queryset():
equations += sympy.FiniteSet(sympy.sympify(eq.syntax,local_vars))
hypothesis = sympy.FiniteSet(*sympy.sympify(hypothesis_str, locals=local_vars))
goal = sympy.FiniteSet(*sympy.sympify(goal_str, locals=local_vars))
known, solution, giaThuyet = kernel.SuyDienTien(hypothesis, goal, TapDangThuc=equations)
return Response({
"hypothesis": hypothesis_str,
"goal": goal_str,
"solution": [{
step[0]:str(step[1]),
step[2]:str(step[3]),
step[4]:str(step[5])
} for step in solution]
})
def __call__(self, spec, instance):
args = dict(zip(self.parameters, instance.arguments))
args[_THISLOC] = sympy.Symbol(instance.name)
return self.__class__(
name=instance.name,
parameters=[],
variables=[v.subs(args) for v in self.variables],
constraints=[c.subs(args) for c in self.constraints],
rules=[r.subs(args) for r in self.rules],
labels=subs(
sympy.FiniteSet(self.name)
| self.labels
| instance.labels, args),
decl=self,
instance=instance,
specification=spec)
def _unique_values(entropy, only_integers=False, count=None):
"""Generates unique values."""
if count is None:
count = random.randint(*_sort_count_range(entropy))
if only_integers:
sampler = functools.partial(number.integer, signed=True)
else:
sampler = integer_or_rational_or_decimal
for _ in range(1000):
entropies = entropy * np.random.dirichlet(np.ones(count))
entropies = np.maximum(1, entropies)
values = [sampler(ent) for ent in entropies]
if len(sympy.FiniteSet(*values)) == len(values):
return values
raise ValueError(
'Could not generate {} unique values with entropy={}'.format(
count, entropy))
def parameter_space(self):
"""The parameter space set
A fixed parameter will be constrained to one single value
and non-fixed parameters will be constrained to an interval
possibly open in one or both ends.
Examples
--------
>>> import sympy
>>> from pharmpy import Parameter
>>> par = Parameter("x", 1, lower=0, upper=10)
>>> sympy.pprint(par.parameter_space)
[0, 10]
>>> par.fix = True
>>> sympy.pprint(par.parameter_space)
{1}
"""
if self.fix:
return sympy.FiniteSet(self.init)
else:
return sympy.Interval(self.lower, self.upper)
def olokliro(self, object=[]): #(全体)集合の生成
return sp.FiniteSet(*object)
def test_parameter_space():
p1 = Parameter('Y', 9, fix=True)
assert p1.parameter_space == sympy.FiniteSet(9)
p2 = Parameter('X', 10, lower=0, upper=15)
assert p2.parameter_space == sympy.Interval(0, 15)
def rand_finiteset(n, items, excluded_values=[]):
"""
Generate a random finite set.
"""
return sp.FiniteSet(*list_randitem_norep(n, items, excluded_values=[]))
def calculate_transitions(self, data : dict[list[float], list[float]], FixedTransitions=None, InitialGuessInterval= (0,10),LowerBoundTransitionRates = 1e-10,MaxTries=50 ) -> dict[sp.Symbol,float]:
if FixedTransitions is None:
FixedTransitions = {}
# Find the charactertic polynomial
cPoly = self.M.charpoly().expr
# Get the lambda symbol
lam = cPoly.free_symbols.difference(sp.FiniteSet(*self.Transitions)).pop()
# Substitute the lambdas for the known values and scale affected transition rates to the given value
filledLambdas = []
for Intensity in data.keys():
ExtraCPoly = copy.deepcopy(cPoly)
for i in range(len(Intensity)):
ExtraCPoly = ExtraCPoly.subs(zip(self.LightDependentTransitions[i], map(lambda x: Intensity[i] * x, self.LightDependentTransitions[i])))
filledLambdas += list(map(lambda x: ExtraCPoly.subs(lam, x), data[Intensity]))
# Store the actual symbol instead of reference in Fixed ks
for i in range(len(filledLambdas)):
filledLambdas[i] = filledLambdas[i].subs(FixedTransitions.items())
# Use set subtraction to get the symbols for which need to be solved
UnkownK = [k for k in self.Transitions if k not in FixedTransitions.keys()]
NumberOfUnkownTransitions = len(UnkownK)
# Export system to list of functions
def func(fun):
return lambda x: fun(*x)
NonlinearSystem = []
for exp in filledLambdas:
NonlinearSystem.append(func(sp.lambdify(UnkownK, exp)))
# Setup the variables needed to loop
Tries = 0
Rates = {"success": False, "active_mask": [-1]}
# Try and find a solution with new random starting points 10 times. a solution is reject if the bounds are active (active_mask) this means the solution is either on or lower than th given lower bound
while (((not (all([x == 0 for x in Rates['active_mask']]))) or (not Rates["success"])) and (Tries < MaxTries)):
Rates = opt.least_squares(fun=lambda num: list(map(lambda x: x(num), NonlinearSystem)),
x0=np.random.rand((NumberOfUnkownTransitions)) * (InitialGuessInterval[1] - InitialGuessInterval[0]) +InitialGuessInterval[0],
bounds=(LowerBoundTransitionRates, np.inf))
Tries += 1
# Print the solution if found otherwise error
if (Tries >= MaxTries):
# If we havenot find a solution throw an error and show the last Rates Object.
print(Rates)
raise RuntimeError("Could not solve for the transition rates in " + str(
MaxTries) + " tries with given constraints Not all in bounds was " + str(
(not (all([x == 0 for x in Rates['active_mask']])))))
print("Found transition rates in " + str(Tries) + " tries.")
# The k values are the value of x in the Rates object. These values are the free transition rates in order with the known transition rates removed
print(Rates)
# Setup list of the transition rates
self.TransitionRates = dict(zip(UnkownK, Rates['x'])) | FixedTransitions
print("Transitions : " + str(self.TransitionRates))
return self.TransitionRates
class Relation(sympy.FiniteSet):
"""
Define Relation class inherited from FinitSet.
@author hawksoft
"""
A = sympy.FiniteSet()
id2items = {}
@classmethod
def setA(cls, *items):
"""
This is a class method. Set discourse
Parameters:
items: lists of elements of set
Returns:
no return
"""
cls.A = sympy.FiniteSet(*items)
cls.id2items = {}
num = 0
for i in cls.A:
cls.id2items[num] = i
num = num + 1
@classmethod
def getUniversal(cls):
"""
This is a class method. Get the Universal Relation on the discourse.
Parameters:
none.
Returns:
Return the universal relation on discourse.
"""
temp = cls.A * cls.A
l = []
for i in temp:
l.append(i)
return Relation(*l, name='Universal Relation')
@classmethod
def getIdentity(cls):
"""
This is a class method. Get the Identity Relation on the discourse.
Parameters:
none.
Returns:
Return the identity relation on discourse.
"""
l = []
for i in range(0, len(cls.id2items)):
item = (cls.id2items[i], cls.id2items[i])
l.append(item)
return Relation(*l)
def __init__(self, *items, name='noName'):
'''
Init a relation object.
parameters:
items: 2-tuple list define the relation
name:this is an optional argument,you can give name to the relation
returns
a relation object
example:
Relation.setA(1,2,3)
r1 = Relation((1,2),(2,3),name = "simple relation')
'''
#if sympy.Eq(self.A,sympy.EmptySet):
# print('empty A')
# self.setA(1,2,3,4)
if len(items) == 0:
sympy.FiniteSet(('xxx', 'xxx'))
else:
sympy.FiniteSet(self, *items)
self.name = name
def drawGraphbyGraphviz(self):
'''
Draw relation graph by using graphviz package. Do not use it.
'''
g = gz.Graph(format='png')
for i in self.C:
g.node(str(i))
l = []
for i in self:
l.append(str(i[0]) + str(i[1]))
g.edges(l)
#print(g.source)
g.render('./test', view=True)
def drawDigraphbyGraphviz(self):
'''
Draw relation graph by using graphviz package. Do not use it.
'''
g = gz.Digraph(format='png')
for i in self.A:
g.node(str(i))
l = []
for i in self:
l.append(str(i[0]) + str(i[1]))
g.edges(l)
#print(g.source)
g.render('./test', view=True)
def showSet(self):
'''
This method show relation as a set
Parameters:
None.
Returns:
None.
'''
sympy.pprint(self)
def showGraph(self):
'''
This method show relation as a graph.
Parameters:
None.
Returns:
None.
'''
g = networkx.DiGraph()
listNode = [self.id2items[i] for i in self.id2items]
g.add_nodes_from(listNode)
listEdge = []
for i in range(len(self.id2items)):
for j in range(len(self.id2items)):
item = (self.id2items[i], self.id2items[j])
if self.contains(item) == True:
listEdge.append(item)
g.add_edges_from(listEdge)
plt.subplot(111)
networkx.draw(g, with_labels=True, font_weight='bold')
plt.show()
def showMatrix(self):
'''
This method show relation as a matrix.
Parameters:
None.
Returns:
None.
'''
self.toMatrix()
sympy.pprint(self.matrix)
def toMatrix(self):
if self.is_empty:
matrix = sympy.zeros(len(len(self.id2itmes), len(self.id2itmes)))
else:
mat = []
for i in range(0, len(self.id2items)):
line = []
for j in range(0, len(self.id2items)):
item = (self.id2items[i], self.id2items[j])
if self.contains(item) == True:
line.append(1)
else:
line.append(0)
mat.append(line)
self.matrix = sympy.Matrix(mat)
return self.matrix
def fromMatrix(self, matrix):
l = []
for i in range(0, len(self.id2items)):
rows = matrix.row(i)
for j in range(0, len(self.id2items)):
if rows[j] == 1:
item = (self.id2items[i], self.id2items[j])
l.append(item)
if len(l) == 0:
l.append(('xxx', 'xxx'))
return Relation(*l)
def __add__(self, adds):
'''
Return a new relation which is self union with adds.
'''
temp = self.union(adds)
l = []
for i in temp:
l.append(i)
if len(l) == 0:
l.append(('xxx', 'xxx'))
result = Relation(*l)
return result
def __sub__(self, subs):
'''
Return a new relation which is self sub subs.
'''
temp = sympy.Complement(self, subs)
l = []
for i in temp:
l.append(i)
if len(l) == 0:
l.append(('xxx', 'xxx'))
result = Relation(*l)
return result
def __pow__(self, num):
'''
Return a new relation which is self's power.
Parameters
num: the exponents
'''
mat = self.toMatrix()
if num == -1:
mat = mat.T
else:
mat = mat**num
return self.fromMatrix(mat)
def intersect(self, other):
temp = self.intersect(other)
print(temp)
l = []
for i in temp:
l.append(i)
if len(l) == 0:
l.append(('xxx', 'xxx'))
result = Relation(*l)
return result
def reflectiveClosure(self):
'''
Return the reflectiveClosure
'''
return self + self.getIdentity()
def symmetricClosure(self):
'''
Return the symmetricClosure
'''
return self + self**-1
def transitiveClosure(self):
'''
Return the transitiveClosure
'''
temp = self
for i in range(2, len(self.id2items)):
temp1 = temp**i
temp = temp + temp1
return temp
def symlabels (labels=None) :
if labels :
return sympy.FiniteSet(*(sympy.Symbol(l) if isinstance(l, str) else l
for l in labels))
else :
return sympy.EmptySet
def piecewise_one(self, expr):
return Piecewise(
(1, sympy.FiniteSet(*list(self.range)).contains(expr)), (0, True)
)
def piecewise_one(self, expr):
return Piecewise(
(1, sympy.FiniteSet(*self.values).contains(expr)), (0, True)
)
def polynomial_roots(value, sample_args, context=None):
"""E.g., "Solve 2*x**2 - 18 = 0."."""
del value # not currently used
# is_question = context is None
if context is None:
context = composition.Context()
entropy, sample_args = sample_args.peel()
scale_entropy = min(entropy / 2, 1)
roots = _sample_roots(entropy - scale_entropy)
solutions = sorted(list(sympy.FiniteSet(*roots)))
coeffs = _polynomial_coeffs_with_roots(roots, scale_entropy)
(polynomial_entity, ) = context.sample(sample_args,
[composition.Polynomial(coeffs)])
if random.choice([False, True]):
# Ask for explicit roots.
if len(solutions) == 1:
answer = solutions[0]
else:
answer = display.NumberList(solutions)
if polynomial_entity.has_expression():
equality = ops.Eq(polynomial_entity.expression, 0)
variable = polynomial_entity.polynomial_variables[0]
else:
variable = sympy.Symbol(context.pop())
equality = ops.Eq(polynomial_entity.handle.apply(variable), 0)
template = random.choice([
'Misalkan {equality}. Berapakah {variable}?',
'Misalkan {equality}. Hitung {variable}.',
'Misalkan {equality}. Berapakah {variable}?',
'Misalkan {equality}. Hitung {variable}.',
'Berapakah {variable} dalam {equality}?',
'Selesaikan {equality} untuk {variable}.',
'Temukan {variable} sehingga {equality}.',
'Temukan {variable}, mengingat {equality}.',
'Tentukan {variable} sehingga {equality}.',
'Tentukan {variable}, mengingat bahwa {equality}.',
'Selesaikan {equality}.'
])
return example.Problem(question=example.question(context,
template,
equality=equality,
variable=variable),
answer=answer)
else:
if polynomial_entity.has_expression():
expression = polynomial_entity.expression
variable = polynomial_entity.polynomial_variables[0]
else:
variable = sympy.Symbol(context.pop())
expression = polynomial_entity.handle.apply(variable)
factored = sympy.factor(
polynomials.coefficients_to_polynomial(coeffs, variable))
template = random.choice([
'Faktor dari {expression}.',
])
return example.Problem(question=example.question(
context, template, expression=expression),
answer=factored)
