def apply(self, m, b, evaluation):
'LinearSolve[m_, b_]'
matrix = matrix_data(m)
if matrix is None:
return evaluation.message('LinearSolve', 'matrix', m, 1)
if not b.has_form('List', None):
return
if len(b.leaves) != len(matrix):
return evaluation.message('LinearSolve', 'lslc')
system = [mm + [v] for mm, v in zip(matrix, b.leaves)]
system = to_sympy_matrix(system)
if system is None:
return evaluation.message('LinearSolve', 'matrix', b, 2)
syms = [
sympy.Dummy('LinearSolve_var%d' % k)
for k in range(system.cols - 1)
]
sol = sympy.solve_linear_system(system, *syms)
if sol:
# substitute 0 for variables that are not in result dictionary
free_vars = dict(
(sym, sympy.Integer(0)) for sym in syms if sym not in sol)
sol.update(free_vars)
sol = [(sol[sym] if sym in free_vars else sol[sym].subs(free_vars))
for sym in syms]
return from_sympy(sol)
else:
return evaluation.message('LinearSolve', 'nosol')
def apply(self, m, b, evaluation):
'LinearSolve[m_, b_]'
matrix = matrix_data(m)
if matrix is None:
return
if not b.has_form('List', None):
return
if len(b.leaves) != len(matrix):
return evaluation.message('LinearSolve', 'lslc')
system = [mm + [v] for mm, v in zip(matrix, b.leaves)]
system = to_sympy_matrix(system)
if system is None:
return
syms = [sympy.Dummy('LinearSolve_var%d' % k)
for k in range(system.cols - 1)]
sol = sympy.solve_linear_system(system, *syms)
if sol:
# substitute 0 for variables that are not in result dictionary
free_vars = dict((sym, sympy.Integer(
0)) for sym in syms if sym not in sol)
sol.update(free_vars)
sol = [(sol[sym] if sym in free_vars else sol[sym].subs(free_vars))
for sym in syms]
return from_sympy(sol)
else:
return evaluation.message('LinearSolve', 'nosol')
def __call__(self, equations, variables=None):
if variables is None:
variables = {}
# Get a representation of the ODE system in the form of
# dX/dt = M*X + B
varnames, matrix, constants = get_linear_system(equations)
# Make sure that the matrix M is constant, i.e. it only contains
# external variables or constant variables
t = Symbol('t', real=True, positive=True)
symbols = set.union(*(el.atoms() for el in matrix))
non_constant = _non_constant_symbols(symbols, variables, t)
if len(non_constant):
raise ValueError(('The coefficient matrix for the equations '
'contains the symbols %s, which are not '
'constant.') % str(non_constant))
# Check for time dependence
dt_var = variables.get('dt', None)
if dt_var is not None:
# This will raise an error if we meet the symbol "t" anywhere
# except as an argument of a locally constant function
for entry in itertools.chain(matrix, constants):
_check_for_locally_constant(entry, variables, dt_var.get_value(), t)
symbols = [Symbol(variable, real=True) for variable in varnames]
solution = sp.solve_linear_system(matrix.row_join(constants), *symbols)
b = sp.ImmutableMatrix([solution[symbol] for symbol in symbols]).transpose()
# Solve the system
dt = Symbol('dt', real=True, positive=True)
A = (matrix * dt).exp()
C = sp.ImmutableMatrix([A.dot(b)]) - b
_S = sp.MatrixSymbol('_S', len(varnames), 1)
updates = A * _S + C.transpose()
try:
# In sympy 0.7.3, we have to explicitly convert it to a single matrix
# In sympy 0.7.2, it is already a matrix (which doesn't have an
# is_explicit method)
updates = updates.as_explicit()
except AttributeError:
pass
# The solution contains _S[0, 0], _S[1, 0] etc. for the state variables,
# replace them with the state variable names
abstract_code = []
for idx, (variable, update) in enumerate(zip(varnames, updates)):
rhs = update
for row_idx, varname in enumerate(varnames):
rhs = rhs.subs(_S[row_idx, 0], varname)
# Do not overwrite the real state variables yet, the update step
# of other state variables might still need the original values
abstract_code.append('_' + variable + ' = ' + sympy_to_str(rhs))
# Update the state variables
for variable in varnames:
abstract_code.append('{variable} = _{variable}'.format(variable=variable))
return '\n'.join(abstract_code)
def find_balancing_weights(coalitions: list, var_name: str = ''):
'''
Parameter coalitions is a list of lists, each inner list representing a coalition of players.
Number of players is inferred depending on who participates in the coalitions
'''
coefficients = []
players = {}
matrices = []
for i, coalition in enumerate(coalitions):
coalition_name = '{0}{{{1}}}'.format(
var_name, ','.join([str(x) for x in coalition]))
coefficients.append(Symbol(coalition_name))
for player in coalition:
if player not in players:
players[player] = []
players[player].append(i)
for player, participating in players.items():
tmp = [0] * len(coalitions)
for coalition in participating:
tmp[coalition] = 1
tmp.append(1)
matrices.append(tmp)
system = Matrix(matrices)
return solve_linear_system(system, *coefficients)
def matrix_z(M_self, X, x_zero, matriz_um):
f_xis = M_self
n = 0
for x in range(0, X.shape[0]):
f_xis = f_xis.subs(X[n], x_zero[n])
n = n + 1
f_xis = -1 * f_xis
f_final = matriz_um.col_insert(X.shape[0], f_xis)
return solve_linear_system(f_final, *X)
def linear_solve(sparse_mat_rep, sub_cvector, length, fvars, iofvars, fvargen,
newfvars, vardict):
augmatrix = sympy.zeros(len(sub_cvector), length + 1)
for index, value in sparse_mat_rep.items():
augmatrix[index[0], index[1]] = value
for i, c in enumerate(sub_cvector):
augmatrix[i, -1] = c
if augmatrix.cols == 2 and augmatrix.rows == 1:
return {fvars[0]: augmatrix[0, 1] / augmatrix[0, 0]}
return sympy.solve_linear_system(augmatrix, *fvars)
def sytem_of_equations():
strVariables = str(request.args.get('variables'))
strVariables = strVariables.replace("[", "")
strVariables = strVariables.replace("\"", "")
strVariables = strVariables.replace("\'", "")
variables = strVariables.split(",")
strMatrix = str(request.args.get('matrix'))
strMatrix = strMatrix.replace("[", "")
strMatrix = strMatrix.replace("\"", "")
strMatrix = strMatrix.replace("\'", "")
matrix = strMatrix.split("]")
matrix.pop(len(matrix) - 1)
equations = [[]]
i = 0
for row in matrix:
for item in row.split(","):
equations[i].append(float(item))
i += 1
equations.append([])
equations.pop(len(equations) - 1)
print(equations)
if len(variables) == 2:
x, y = sp.symbols(variables)
system = Matrix((equations[0], equations[1]))
print(str(solve_linear_system(system, x, y)))
return (str(solve_linear_system(system, x, y)))
if len(variables) == 3:
x, y, z = sp.symbols(variables)
system = Matrix((equations[0], equations[1], equations[2]))
print(str(solve_linear_system(system, x, y, z)))
return (str(solve_linear_system(system, x, y, z)))
return "HUIH"
def calcAlignTrans(self, shape1, shape2):
"""
start = time.time()
coeffs = np.array( [
[ self.Xgen( shape2 ), - self.Ygen( shape2 ), self.Wgen(), 0],
[ self.Ygen( shape2 ), self.Xgen( shape2 ), 0, self.Wgen()],
[ self.Zgen( shape2 ), 0, self.Xgen( shape2 ), self.Ygen( shape2 )],
[ 0, self.Zgen( shape2 ), - self.Ygen( shape2 ), self.Xgen( shape2 )]
])
eqs = np.array([ self.Xgen(shape1) , self.Ygen(shape1), self.C1gen(shape1, shape2), self.C2gen(shape1, shape2) ] )
sol = np.linalg.solve( coeffs, eqs )
# d = ax = s cos 0
# e = ay = s sin 0
# f = tx
# g = ty
rot = [[ sol[0], - sol[1]],
[ sol[1], sol[0]] ]
t = [[ sol[2]],[sol[3]]]
"""
toSolve = Matrix([[
self.Xgen(shape2), -self.Ygen(shape2),
self.Wgen(), 0,
self.Xgen(shape1)
],
[
self.Ygen(shape2),
self.Xgen(shape2), 0,
self.Wgen(),
self.Ygen(shape1)
],
[
self.Zgen(shape2), 0,
self.Xgen(shape2),
self.Ygen(shape2),
self.C1gen(shape1, shape2)
],
[
0,
self.Zgen(shape2), -self.Ygen(shape2),
self.Xgen(shape2),
self.C2gen(shape1, shape2)
]])
sol = solve_linear_system(toSolve, d, e, f, g)
# d = ax = s cos 0
# e = ay = s sin 0
# f = tx
# g = ty
rot = [[sol[d], -sol[e]], [sol[e], sol[d]]]
t = [[sol[f]], [sol[g]]]
return {'rot': rot, 't': t}
def linear_solve(A, b):
'''solve linear equation Ax=b
return (tuple of number): a tuple of column element of x
A (list of list of number): A matrix
b (list of number): b vector
'''
vnames = sp.symbols(["a" + str(i) for i in range(len(b))])
result = sp.solve_linear_system(
sp.Matrix(A).row_join(sp.Matrix(b)), *vnames)
return tuple([result[item] for item in vnames])
def kusochno_linear():
n = len(x0)
systems = []
x, y = sympy.symbols("x, y")
for i in range(1, n):
system = sympy.Matrix(((x0[i - 1], 1, y0[i - 1]), (x0[i], 1, y0[i])))
solved = sympy.solve_linear_system(system, x, y)
systems.append(solved[x] * x + solved[y])
return systems
def build_formula(degree):
xs = [symbols('x' + str(i)) for i in range(degree+1)]
x = symbols('x')
m = Matrix([[letter**power for letter in xs + [x]] for power in range(degree + 1)])
factors = [symbols('f' + str(i)) for i in range(degree+1)]
solutions = solve_linear_system(m, *factors)
ys = [symbols('y' + str(i)) for i in range(degree+1)]
final = sum(solutions[factors[i]] * ys[i] for i in range(degree + 1))
return final
def Main():
#Read("spec.in")
#Read("spec_warp_simpler.in")
#Read("spec_warpPerspective.in")
Read("spec_rotate.in")
if False:
[(c_name, c_code), (h_name, c_header)] = codegen([("xdst", eqList[0]),
("ydst", eqList[1])],
"C",
"test",
header=False,
empty=False)
print("c_code = %s" % c_code)
print("eqList = %s" % str(eqList))
resEqSysMat = eqs2matrix(eqs=eqList,
unknownSymbols=(xdst, ydst),
augment=True)
print("resEqSysMat = %s" % str(resEqSysMat))
from sympy import Matrix, solve_linear_system
res = solve_linear_system(resEqSysMat, xdst, ydst)
print("The result is (xdst, ydst) = %s" % str(res))
print("res[xdst] = %s" % str(res[xdst]))
print("res[ydst] = %s" % str(res[ydst]))
#sympy.simplify.cse_main.cse(res[xdst], res[ydst])
expListWithBoundedVars = cse([res[xdst], res[ydst]])
print("After performing CSE, we have: %s" % str(expListWithBoundedVars))
print("expListWithBoundedVars[0] (the bounded vars) = %s" %
str(expListWithBoundedVars[0]))
print("expListWithBoundedVars[1][0] = %s" %
str(expListWithBoundedVars[1][0]))
eFinal = []
for e in expListWithBoundedVars[0]:
eFinal.append((str(e[0]), e[1]))
#expListWithBoundedVars[0] + \
expListWithBoundedVars = eFinal + \
[("xdst", expListWithBoundedVars[1][0])] + \
[("ydst", expListWithBoundedVars[1][1])]
print("expListWithBoundedVars = %s" % str(expListWithBoundedVars))
[(c_name, c_code), (h_name, c_header)] = codegen(expListWithBoundedVars,
"C",
"final_test",
header=False,
empty=False)
print("c_code = %s" % c_code)
def quadratic(x1, y1, x2, y2, dist):
''''y = ax + b so will solve it using the sympy module
example >>> system = Matrix(( (1, 4, 2), (-2, 1, 14)))
>>> solve_linear_system(system, x, y)
{x: -6, y: 2}
now solve distance: d**2 = (x3-x1)**2 + (y3-y1)**2 =>
x3**2 - 2*x1x3 + (x1**2 - d**2 / (a**2 +1)) :a from y = ax + b'''
if x1 != x2:
system = Matrix(((x1, 1, y1), (x2, 1, y2)))
d = solve_linear_system(system, x, y)
z = float(d[x])
w = float(d[y])
a = 1
b = -2 * x1
c = x1**2 - (dist**2 / (z**2 + 1))
diak = b**2 - (4 * a * c)
if x1 < x2:
if (x1 <= ((-b + math.sqrt(diak)) / (2 * a)) <= x2):
x3 = ((-b + math.sqrt(diak)) / (2 * a))
else:
x3 = ((-b - math.sqrt(diak)) / (2 * a))
y3 = z * x3 + w
if (distance(x3, y3, x2, y2) <= dist):
return (x2, y2)
else:
return (x3, y3)
elif x2 < x1:
if (x2 <= ((-b + math.sqrt(diak)) / (2 * a)) <= x1):
x3 = ((-b + math.sqrt(diak)) / (2 * a))
else:
x3 = ((-b - math.sqrt(diak)) / (2 * a))
y3 = z * x3 + w
if (distance(x3, y3, x2, y2) <= dist):
return (x2, y2)
else:
return (x3, y3)
elif x1 == x2:
if y1 < y2:
y3 = y1 + dist
if (distance(x2, y3, x2, y2) <= dist):
return (x2, y2)
else:
return (x2, y3)
else:
y3 = y1 - dist
if (distance(x2, y3, x2, y2) <= dist):
return (x2, y2)
else:
return (x2, y3)
def algebraSolver(self):
#x = 0
#y = 0
#eq1 = sp.Function('eq1')
#eq2 = sp.Function('eq2')
#eq1 = Eq(2*x - y,-4)
#eq2 = Eq(3*x - y,-2)
x,y = sp.symbols('x y')
row1 = [2, -2, -4]
row2 = [6, -8, -2]
system = Matrix((row1,row2))
print(solve_linear_system(system,x,y))
def associated1ps(monomials,boundary=None, dim=4): #generates the normalized 1-PS from a list of monomials.
monomials_copy=list(monomials)
if(len(monomials_copy)>0):
m0=monomials_copy[0]
monomial_list=[m0-m for m in monomials_copy]
else:
monomial_list=[]
#observe that the previous line also adds the zero vector, but it does not change the code.
#we add the monomial in the centre, which is equivalent to saying that lambda is in SL(n,C).
monomial_list.append(Monomial([1 for x in range(dim)]))
#We add the boundary components:
if boundary!=None:
for x in boundary:
monomial_list.append(x)
n_mon=len(monomial_list);
#building the general matrix
#first we put the first component with negative value and reverse the monomials
#to assure that this one becomes the solution vector b, i.e. Ax=-y[0]. This is equivalent to
#making sure that solution_1=1
mon_reversed=[]
for x in monomial_list:
y=list(x)
y[0]=-y[0]
y.reverse()
mon_reversed=mon_reversed+y
extended=Matrix(n_mon, dim, mon_reversed)
variables=list(symbols('x0:%d'%n_mon))
#finding solutions
system_solution=solve_linear_system(extended, *variables, rational=True)
if system_solution==None:
return None
#finding least common denominator
val=system_solution.values()
for x in val:
if not isinstance(x,Rational):
return None
denominators=[x.q for x in val if x.p!=0]
lcm=Jlcm(denominators)
if not lcm:
return None
#clearing solutions
solution=[int(x*lcm) for x in val]
solution.append(lcm)
solution.reverse()
return solution
def solve(f1, f2, x, y):
soln = Matrix((fila1, fila2)) # declarar matriz sympy
possiblesoln = possibleValues(solve_linear_system(
soln, x, y)) # resolver sistema de ecuaciones para encontrar la
# interseccion entre restricciones, verificar que el punto cumple y se mete en la variable possiblesoln como una
# posible solucion al problema
produccionMax = 0
# probar que la solucion sea la indicada para maximizar la funcion objetivo
if possiblesoln[0] > produccionMax and possiblesoln[
1] in arrayPuntosCandidatos:
produccionMax = possiblesoln[0]
puntoMax = possiblesoln[1]
# se devuelve el punto que maximiza
return puntoMax
def lin_solve_eqns(eqns, vars):
"""
takes a list of equation objects
creates a system matrix of and calls sp.solve
"""
n = len(eqns)
vars = list(vars) # if its a vector
m = len(vars)
rows = [get_coeff_row(eq, vars) for eq in eqns]
sysmatrix = sp.Matrix(rows)
sol = sp.solve_linear_system(sysmatrix, *vars)
return sol
def lin_solve_eqns(eqns, vars):
"""
takes a list of equation objects
creates a system matrix of and calls sp.solve
"""
n = len(eqns)
vars = list(vars) # if its a vector
m = len(vars)
rows = [get_coeff_row(eq, vars) for eq in eqns]
sysmatrix = sp.Matrix(rows)
sol = sp.solve_linear_system(sysmatrix, *vars)
return sol
def kusochno_kvadrat():
n = len(x0)
if n % 2 != 0:
m = int(n / 2) + 1
else:
m = int(n / 2)
x, y, z = sympy.symbols("x, y, z")
systems = []
for k in range(1, m):
full_matrix = []
for i in range(0, n - 2):
full_matrix.append(
[x0[2 * k - i]**2, x0[2 * k - i], 1, y0[2 * k - i]])
full_matrix = sympy.Matrix(full_matrix)
solution = sympy.solve_linear_system(full_matrix, x, y, z)
systems.append(solution[x] * x**2 + solution[y] * x + solution[z])
return systems
def Main():
#Read("spec.in")
#Read("spec_warp_simpler.in")
#Read("spec_warpPerspective.in")
Read("spec_rotate.in")
if False:
[(c_name, c_code), (h_name, c_header)] = codegen(
[("xdst", eqList[0]), ("ydst", eqList[1])], "C", "test", header=False, empty=False)
print("c_code = %s" % c_code)
print("eqList = %s" % str(eqList))
resEqSysMat = eqs2matrix(eqs=eqList, unknownSymbols=(xdst, ydst), augment=True)
print("resEqSysMat = %s" % str(resEqSysMat))
from sympy import Matrix, solve_linear_system
res = solve_linear_system(resEqSysMat, xdst, ydst)
print("The result is (xdst, ydst) = %s" % str(res))
print("res[xdst] = %s" % str(res[xdst]))
print("res[ydst] = %s" % str(res[ydst]))
#sympy.simplify.cse_main.cse(res[xdst], res[ydst])
expListWithBoundedVars = cse([res[xdst], res[ydst]])
print("After performing CSE, we have: %s" % str(expListWithBoundedVars))
print("expListWithBoundedVars[0] (the bounded vars) = %s" % str(expListWithBoundedVars[0]))
print("expListWithBoundedVars[1][0] = %s" % str(expListWithBoundedVars[1][0]))
eFinal = []
for e in expListWithBoundedVars[0]:
eFinal.append( (str(e[0]), e[1]) )
#expListWithBoundedVars[0] + \
expListWithBoundedVars = eFinal + \
[("xdst", expListWithBoundedVars[1][0])] + \
[("ydst", expListWithBoundedVars[1][1])]
print("expListWithBoundedVars = %s" % str(expListWithBoundedVars))
[(c_name, c_code), (h_name, c_header)] = codegen(
expListWithBoundedVars, "C", "final_test", header=False, empty=False)
print("c_code = %s" % c_code)
def calcAlignTrans( self, shape1, shape2 ):
"""
start = time.time()
coeffs = np.array( [
[ self.Xgen( shape2 ), - self.Ygen( shape2 ), self.Wgen(), 0],
[ self.Ygen( shape2 ), self.Xgen( shape2 ), 0, self.Wgen()],
[ self.Zgen( shape2 ), 0, self.Xgen( shape2 ), self.Ygen( shape2 )],
[ 0, self.Zgen( shape2 ), - self.Ygen( shape2 ), self.Xgen( shape2 )]
])
eqs = np.array([ self.Xgen(shape1) , self.Ygen(shape1), self.C1gen(shape1, shape2), self.C2gen(shape1, shape2) ] )
sol = np.linalg.solve( coeffs, eqs )
# d = ax = s cos 0
# e = ay = s sin 0
# f = tx
# g = ty
rot = [[ sol[0], - sol[1]],
[ sol[1], sol[0]] ]
t = [[ sol[2]],[sol[3]]]
"""
toSolve = Matrix( [
[ self.Xgen( shape2 ), - self.Ygen( shape2 ), self.Wgen(), 0, self.Xgen(shape1) ],
[ self.Ygen( shape2 ), self.Xgen( shape2 ), 0, self.Wgen(), self.Ygen(shape1) ],
[ self.Zgen( shape2 ), 0, self.Xgen( shape2 ), self.Ygen( shape2 ), self.C1gen(shape1, shape2) ],
[ 0, self.Zgen( shape2 ), - self.Ygen( shape2 ), self.Xgen( shape2 ), self.C2gen(shape1, shape2)]
])
sol = solve_linear_system( toSolve, d, e, f, g)
# d = ax = s cos 0
# e = ay = s sin 0
# f = tx
# g = ty
rot = [[ sol[d], - sol[e]],
[ sol[e], sol[d]] ]
t = [[ sol[f]],[sol[g]]]
return { 'rot': rot, 't':t}
def compute_proba(matrix):
eqs = []
syms = []
lastline = []
for i in range(len(matrix)-1): #we want to avoid overdetermination
line = []
for j in range(len(matrix)):
#print "value for i: %i" % i
if (i==j):
line.append(matrix[j][i]-1.0)
else:
line.append(matrix[j][i])
# We are summing in the form a1 p1 + ... + an pn = 0
line.append(0)
syms.append(Symbol("p%i" % i))
eqs.append(line)
lastline.append(1)
syms.append(Symbol("p%i" % (len(matrix)-1)))
lastline.append(1)
lastline.append(1)
eqs.append(lastline)
#print syms
#print eqs
return solve_linear_system(Matrix(eqs),*syms)
def ritz_method(number_of_points):
data = get_data(False)
k, q, f,a,b, alpha, beta, gamma, delta = (data[i] for i in ('k', 'q', 'f','a','b','alpha', 'beta', 'gamma', 'delta'))
phi = get_basis(alpha, beta, gamma, delta, a, b, number_of_points)
# phi = [x**i for i in range(number_of_points)]
beta = -beta* 1.0 / alpha * k.subs(x, a)
delta = delta*1.0/ gamma * k.subs(x, b)
g = lambda u, v: (integrate(k * u.diff(x) * v.diff(x) + q * u * v, (x, a,b))
+ beta * u.subs(x, a) * v.subs(x, a) + delta * u.subs(x, b) * v.subs(x, b) )
l = lambda u: integrate(f * u, (x, a, b))
c = [Symbol('c' + repr(i)) for i in range(number_of_points)]
system = []
for j in range(number_of_points):
system.append([g(phi[i], phi[j]) for i in range(number_of_points)])
system[-1].append(l(phi[j]))
solution = solve_linear_system(Matrix(system), *c)
print(solution.items());
# for j in range(number_of_points):
# system.append(sum([c[i] * g(phi[i], phi[j]) for i in range(number_of_points)]) - l(phi[j]))
# solution = solve(system)
u = sum([c[i] * phi[i] for i in range(number_of_points)])
u = u.subs(solution.items())
return u
def makeQSSA(system, enzyme='E', variable='P'):
r'''Calculate quasi steady-state equation from set of ODEs
This function calculates the quasi steady-state equation for the
variable of interest
Parameters
-----------
system : dict
dict containing system of equation describing the reactions.
enzyme : string
All enzyme forms have to start with the same letters, e.g. 'E' or
'E_'. This allows the algorithm to select the enzyme forms, otherwise
a reduction is not possible.
variable: string
Which rate equation has to be used to replace the enzyme forms with
the QSSA.
Returns
---------
QSSA_var : sympy equation
Symbolic sympy equation of variable which obeys the QSSA.
Notes
------
The idea for the calculations is based on [1]_, where the system is
first transformed in its canonical form.
References
-----------
.. [1] Ishikawa, H., Maeda, T., Hikita, H., Miyatake, K., The
computerized derivation of rate equations for enzyme reactions on
the basis of the pseudo-steady-state assumption and the
rapid-equilibrium assumption (1988), Biochem J., 251, 175-181
Examples
---------
>>> from biointense.utilities import makeQSSA
>>> system = {'dE': '-k1*E*S + k2*ES + kcat*ES',
'dES': 'k1*E*S - k2*ES - kcat*ES',
'dS': '-k1*E*S + k2*ES',
'dP': 'kcat*ES'}
>>> makeQSSA(system, enzyme='E', variable='P')
'En0*S*k1*kcat/(S*k1 + k2 + kcat)'
'''
# Make state var
state_var = [i[1:] for i in system.keys() if i[0] == 'd']
# Run _getCoefficients to get filtered rate equations
coeff_matrix, enzyme_forms, enzyme_equations = _getCoefficients(
system, state_var, enzyme)
# Add row with ones to set the sum of all enzymes equal to En0
coeff_matrix = coeff_matrix.col_join(sympy.ones(1, c=len(enzyme_forms)))
# Make row matrix with zeros (QSSA!), but replace last element with
# En0 for fixing total som of enzymes
QSSA_matrix = sympy.zeros(coeff_matrix.shape[0], c=1)
QSSA_matrix[-1] = sympy.sympify('En0')
# Add column with outputs to coeff_matrix
linear_system = coeff_matrix.row_join(QSSA_matrix)
# Find QSSE by using linear solver (throw away one line (system is
# closed!)) list should be passed as *args, therefore * before list
QSSE_enz = sympy.solve_linear_system(linear_system[1:, :],
*list(enzyme_forms))
# Replace enzyme forms by its QSSE in rate equation of variable of interest
QSSE_var = sympy.sympify(system['d' + variable], _clash)
for enz in enzyme_forms:
QSSE_var = QSSE_var.replace(enz, QSSE_enz[enz])
# To simplify output expand all terms (=remove brackets) and afterwards
# simplify the equation
QSSE_var = sympy.simplify(sympy.expand(QSSE_var))
return QSSE_var
def template_16(self, a, b, c):
m = sympy.symbols('x')
n = sympy.symbols('y')
system = sympy.Matrix(((a, a, b), (1, -1, c)))
return sympy.solve_linear_system(system, m, n)
def template_15(self, a, b, c, d):
m = sympy.symbols('x')
n = sympy.symbols('y')
system = sympy.Matrix(((a, -b, c), (1, 1, d)))
return sympy.solve_linear_system(system, m, n)
def balance(eq):
list_of_elements = []
compounds = eq.split("=") # splits the equation into its left and right
lhs = compounds[0] # left hand side
rhs = compounds[1] # right hand side
l_compounds = lhs.split("+") # splits the left hand side into compounds
r_compounds = rhs.split(
"+") # splits the right hand side into its compounds
l_list = []
r_list = []
for k in range(len(l_compounds)):
l_list.append(elements_dictionary(l_compounds[k]))
molecule = l_compounds[k]
elements = re.findall(r'[A-Z][a-z]?[\d]?', molecule)
for e in elements:
if re.search(r'[A-Z][a-z]?$', e):
list_of_elements.append(e) # If e is an element
else:
e = re.sub(
r'(\w+)\d+', r'\1', e
) # Removes the number, then adds the element alone to the list
list_of_elements.append(e)
list_of_elements = list(set(list_of_elements)) # Removes duplicates
for k in range(len(r_compounds)):
r_list.append(elements_dictionary(r_compounds[k]))
a = int(len(list_of_elements)) # Number of elements
b = int(len(l_compounds) + len(r_compounds)) # Number of terms
M = np.zeros((a, b + 1)) # Dimensions of the augmented matrix
for i in range(len(list_of_elements)):
e = list_of_elements[i]
for j in range(len(l_list) + len(r_list)):
if (j < len(l_list)):
if e in l_list[j].keys():
atoms = (l_list[j])[e]
M[i][
j] = atoms # Sets the corresponding entry of the matrix
else:
if e in r_list[j - len(l_list)].keys():
atoms = -(r_list[j - len(l_list)])[e]
M[i][
j] = atoms # Sets the corresponding entry of the matrix
M = M.astype(int) # Converts the matrix to be of integers
a, b, c, d, e, f, g, h, i, j, k, l, m, n = sp.symbols(
"a,b,c,d,e,f,g,h,i,j,k,l,m,n")
variables = [a, b, c, d, e, f, g, h, i, j, k, m, n]
solution = sp.solve_linear_system(sp.Matrix(M), a, b, c, d, e, f, g, h, i,
j, k, m, n)
variables_used = []
for v in variables:
if v in solution.keys():
variables_used.append(
v) # If the variable has been used, append it to the list
last_variable = variables[len(
variables_used)] # Identifies the last variable used
coeffs = []
for v in variables_used:
coeffs.append(solution[v] / last_variable)
coeffs.append(1) # The last coefficient is set to 1 by default
fractions = []
for i in range(len(coeffs) - 1):
f = coeffs[i].subs(last_variable,
1) # To remove the variables from the coefficients
fractions.append(Fraction(str(f)).limit_denominator())
fractions.append(Fraction(1)) # Appends the last 1
denominators = []
for fraction in fractions:
denominators.append(fraction.denominator)
denominators = list(set(denominators)) # Removes duplicates
product = sp.lcm(denominators) # Finds the LCM
new_coeffs = []
for fraction in fractions:
new_coeffs.append(
int(fraction.numerator * product / fraction.denominator)
) # Multiplies by the LCM to remove fractions
positive_coeffs = []
for c in new_coeffs:
if c < 0:
c = c * -1 # Removes negatives
positive_coeffs.append(str(c))
else:
positive_coeffs.append(str(c))
if positive_coeffs[0] == "1":
balanced = l_compounds[0] # Initiates the result string
else:
balanced = positive_coeffs[0] + l_compounds[0]
for i in range(len(l_compounds)):
if positive_coeffs[i] == "1":
string = "" # If the coefficient is 1, then add nothing
else:
string = positive_coeffs[i]
if i != 0:
balanced += "+" + string + l_compounds[i]
balanced += "=" # Now for the right side
for i in range(len(r_compounds)):
if positive_coeffs[i + len(l_compounds)] == "1":
string = ""
else:
string = positive_coeffs[i + len(l_compounds)]
if i == 0:
balanced += string + r_compounds[i]
else:
balanced += "+" + string + r_compounds[i]
return balanced
def __call__(self, equations, variables=None, method_options=None):
method_options = extract_method_options(method_options,
{'simplify': True})
if equations.is_stochastic:
raise UnsupportedEquationsException('Cannot solve stochastic '
'equations with this state '
'updater.')
if variables is None:
variables = {}
# Get a representation of the ODE system in the form of
# dX/dt = M*X + B
varnames, matrix, constants = get_linear_system(equations, variables)
# No differential equations, nothing to do (this occurs sometimes in the
# test suite where the whole model is nothing more than something like
# 'v : 1')
if matrix.shape == (0, 0):
return ''
# Make sure that the matrix M is constant, i.e. it only contains
# external variables or constant variables
t = Symbol('t', real=True, positive=True)
# Check for time dependence
dt_value = variables['dt'].get_value()[0] if 'dt' in variables else None
# This will raise an error if we meet the symbol "t" anywhere
# except as an argument of a locally constant function
for entry in itertools.chain(matrix, constants):
if not is_constant_over_dt(entry, variables, dt_value):
raise UnsupportedEquationsException(
('Expression "{}" is not guaranteed to be constant over a '
'time step').format(sympy_to_str(entry)))
symbols = [Symbol(variable, real=True) for variable in varnames]
solution = sp.solve_linear_system(matrix.row_join(constants), *symbols)
if solution is None or set(symbols) != set(solution.keys()):
raise UnsupportedEquationsException('Cannot solve the given '
'equations with this '
'stateupdater.')
b = sp.ImmutableMatrix([solution[symbol] for symbol in symbols])
# Solve the system
dt = Symbol('dt', real=True, positive=True)
try:
A = (matrix * dt).exp()
except NotImplementedError:
raise UnsupportedEquationsException('Cannot solve the given '
'equations with this '
'stateupdater.')
if method_options['simplify']:
A = A.applyfunc(lambda x:
sp.factor_terms(sp.cancel(sp.signsimp(x))))
C = sp.ImmutableMatrix(A * b) - b
_S = sp.MatrixSymbol('_S', len(varnames), 1)
updates = A * _S + C
updates = updates.as_explicit()
# The solution contains _S[0, 0], _S[1, 0] etc. for the state variables,
# replace them with the state variable names
abstract_code = []
for idx, (variable, update) in enumerate(zip(varnames, updates)):
rhs = update
if rhs.has(I, re, im):
raise UnsupportedEquationsException('The solution to the linear system '
'contains complex values '
'which is currently not implemented.')
for row_idx, varname in enumerate(varnames):
rhs = rhs.subs(_S[row_idx, 0], varname)
# Do not overwrite the real state variables yet, the update step
# of other state variables might still need the original values
abstract_code.append('_' + variable + ' = ' + sympy_to_str(rhs))
# Update the state variables
for variable in varnames:
abstract_code.append('{variable} = _{variable}'.format(variable=variable))
return '\n'.join(abstract_code)
def timeit_linsolve_trivial():
solve_linear_system(M, *S)
print(" System of 2 Linear Equations ")
print("====================================================")
print(" ")
eq1 = sp.Function('eq1')
eq2 = sp.Function('eq2')
x, y = sp.symbols('x y')
print("Equation 1")
a = float(input("Coefficent of x:"))
b = float(input("Coefficent of y:"))
c = float(input("Coefficent of constant:"))
print("Equation 2")
d = float(input("Coefficent of x:"))
e = float(input("Coefficent of y:"))
f = float(input("Coefficent of constant:"))
eq1 = sp.Eq(a * x + b * y, c)
eq2 = sp.Eq(d * x + e * y, f)
print(eq1)
print(eq2)
row1 = [a, b, c]
row2 = [d, e, f]
print(row1)
print(row2)
system = sp.Matrix((row1, row2))
print(sp.solve_linear_system(system, x, y))
# 求解Bellman期望方程
v_hungry, v_full = symbols('v_hungry v_full')
q_hungry_eat, q_hungry_none, q_full_eat, q_full_none = symbols('q_hungry_eat q_hungry_none q_full_eat q_full_none')
alpha, beta, x, y, gamma = symbols('alpha beta x y gamma')
system = sympy.Matrix((
(1, 0, x-1, -x, 0, 0, 0),
(0, 1, 0, 0, -y, y-1, 0),
(-gamma, 0, 1, 0, 0, 0, -2),
((alpha-1)*gamma, -alpha*gamma, 0, 1, 0, 0, 4*alpha-3),
(-beta*gamma, (beta-1)*gamma, 0, 0, 1, 0, -4*beta+2),
(0, -gamma, 0, 0, 0, 1, 1)
))
re = sympy.solve_linear_system(system,v_hungry,v_full,q_hungry_none,q_hungry_eat,q_full_none,q_full_eat)
for i in re:
print(re[i])
print('--- BellMan optimization ---')
# 求解Bellman最优方程
sympy.init_printing()
alpha, beta, gamma = symbols('alpha beta gamma')
v_hungry, v_full = symbols('v_hungry v_full')
q_hungry_eat, q_hungry_none,q_full_eat, q_full_none = symbols('q_hungry_eat, q_hungry_none,q_full_eat, q_full_none')
xy_tuples = ((0,0), (1,0), (0,1), (1,1))
for x,y in xy_tuples: # 分类讨论
def solution(self):
"""Solves the system if it has a single solution. Returns a dictionary mapping symbol to solution value."""
return sp.solve_linear_system(self._matrix, *self.unknowns)
import gym
import scipy
from sympy import symbols
v_hungry, v_full = symbols('v_hungry v_full')
q_hungry_eat, q_hungry_none, q_full_eat, q_full_none = \
symbols('q_hungry_eat q_hungry_none q_full_eat q_full_none')
alpha, beta, gamma = symbols('alpha beta gamma')
x, y = symbols('x y')
system = sympy.Matrix(
((1, 0, x - 1, -x, 0, 0, 0), (0, 1, 0, 0, -y, y - 1, 0), (-gamma, 0, 1, 0,
0, 0, -2),
((alpha - 1) * gamma, -alpha * gamma, 0, 1, 0, 0,
4 * alpha - 3), (-beta * gamma, (beta - 1) * gamma, 0, 0, 1, 0,
-4 * beta + 2), (0, -gamma, 0, 0, 0, 1, 1)))
sympy.solve_linear_system(system, v_hungry, v_full, q_hungry_none,
q_hungry_eat, q_full_none, q_full_eat)
xy_tuples = ((0, 0), (1, 0), (0, 1), (1, 1))
for x, y in xy_tuples:
system = sympy.Matrix(
((1, 0, x - 1, -x, 0, 0, 0), (0, 1, 0, 0, -y, y - 1, 0), (-gamma, 0, 1,
0, 0, 0, -2),
((alpha - 1) * gamma, -alpha * gamma, 0, 1, 0, 0,
4 * alpha - 3), (-beta * gamma, (beta - 1) * gamma, 0, 0, 1, 0,
-4 * beta + 2), (0, -gamma, 0, 0, 0, 1, 1)))
result = sympy.solve_linear_system(system,
v_hungry,
v_full,
q_hungry_none,
q_hungry_eat,
q_full_none,
def __call__(self, equations, variables=None, method_options=None):
method_options = extract_method_options(method_options,
{'simplify': True})
if equations.is_stochastic:
raise UnsupportedEquationsException("Cannot solve stochastic "
"equations with this state "
"updater.")
if variables is None:
variables = {}
# Get a representation of the ODE system in the form of
# dX/dt = M*X + B
varnames, matrix, constants = get_linear_system(equations, variables)
# No differential equations, nothing to do (this occurs sometimes in the
# test suite where the whole model is nothing more than something like
# 'v : 1')
if matrix.shape == (0, 0):
return ''
# Make sure that the matrix M is constant, i.e. it only contains
# external variables or constant variables
# Check for time dependence
dt_value = variables['dt'].get_value(
)[0] if 'dt' in variables else None
# This will raise an error if we meet the symbol "t" anywhere
# except as an argument of a locally constant function
for entry in itertools.chain(matrix, constants):
if not is_constant_over_dt(entry, variables, dt_value):
raise UnsupportedEquationsException(
f"Expression '{sympy_to_str(entry)}' is not guaranteed to be "
f"constant over a time step.")
symbols = [Symbol(variable, real=True) for variable in varnames]
solution = sp.solve_linear_system(matrix.row_join(constants), *symbols)
if solution is None or set(symbols) != set(solution.keys()):
raise UnsupportedEquationsException("Cannot solve the given "
"equations with this "
"stateupdater.")
b = sp.ImmutableMatrix([solution[symbol] for symbol in symbols])
# Solve the system
dt = Symbol('dt', real=True, positive=True)
try:
A = (matrix * dt).exp()
except NotImplementedError:
raise UnsupportedEquationsException("Cannot solve the given "
"equations with this "
"stateupdater.")
if method_options['simplify']:
A = A.applyfunc(
lambda x: sp.factor_terms(sp.cancel(sp.signsimp(x))))
C = sp.ImmutableMatrix(A * b) - b
_S = sp.MatrixSymbol('_S', len(varnames), 1)
updates = A * _S + C
updates = updates.as_explicit()
# The solution contains _S[0, 0], _S[1, 0] etc. for the state variables,
# replace them with the state variable names
abstract_code = []
for idx, (variable, update) in enumerate(zip(varnames, updates)):
rhs = update
if rhs.has(I, re, im):
raise UnsupportedEquationsException(
"The solution to the linear system "
"contains complex values "
"which is currently not implemented.")
for row_idx, varname in enumerate(varnames):
rhs = rhs.subs(_S[row_idx, 0], varname)
# Do not overwrite the real state variables yet, the update step
# of other state variables might still need the original values
abstract_code.append(f"_{variable} = {sympy_to_str(rhs)}")
# Update the state variables
for variable in varnames:
abstract_code.append(f"{variable} = _{variable}")
return '\n'.join(abstract_code)
def __call__(self, equations, variables=None):
if variables is None:
variables = {}
# Get a representation of the ODE system in the form of
# dX/dt = M*X + B
varnames, matrix, constants = get_linear_system(equations)
# Make sure that the matrix M is constant, i.e. it only contains
# external variables or constant variables
symbols = set.union(*(el.atoms() for el in matrix))
non_constant = _non_constant_symbols(symbols, variables)
if len(non_constant):
raise ValueError(('The coefficient matrix for the equations '
'contains the symbols %s, which are not '
'constant.') % str(non_constant))
symbols = [Symbol(variable, real=True) for variable in varnames]
solution = sp.solve_linear_system(matrix.row_join(constants), *symbols)
b = sp.ImmutableMatrix([solution[symbol]
for symbol in symbols]).transpose()
# Solve the system
dt = Symbol('dt', real=True, positive=True)
A = (matrix * dt).exp()
C = sp.ImmutableMatrix([A.dot(b)]) - b
_S = sp.MatrixSymbol('_S', len(varnames), 1)
updates = A * _S + C.transpose()
try:
# In sympy 0.7.3, we have to explicitly convert it to a single matrix
# In sympy 0.7.2, it is already a matrix (which doesn't have an
# is_explicit method)
updates = updates.as_explicit()
except AttributeError:
pass
# The solution contains _S[0, 0], _S[1, 0] etc. for the state variables,
# replace them with the state variable names
abstract_code = []
for idx, (variable, update) in enumerate(zip(varnames, updates)):
rhs = update.subs(_S[idx, 0], variable)
identifiers = get_identifiers(sympy_to_str(rhs))
for identifier in identifiers:
if identifier in variables:
var = variables[identifier]
if var is None:
print identifier, variables
if var.scalar and var.constant:
float_val = var.get_value()
rhs = rhs.xreplace(
{Symbol(identifier, real=True): Float(float_val)})
# Do not overwrite the real state variables yet, the update step
# of other state variables might still need the original values
abstract_code.append('_' + variable + ' = ' + sympy_to_str(rhs))
# Update the state variables
for variable in varnames:
abstract_code.append(
'{variable} = _{variable}'.format(variable=variable))
return '\n'.join(abstract_code)
from sympy import symbols, Matrix, solve_linear_system
from sympy.abc import x, y
S2 = Matrix((
# x1, x2, x3 ... x6
(0.0, 0.0, 1.0, 2.0, 0.0, 2.0), # [L]
(1.0, 0.0, 0.0, 1.0, 0.0, 1.0), # [M]
(0.0, -1.0, 0.0, -2.0, 1.0, 0.00) # [T]
))
x1, x2, x3, x4, x5, x6 = symbols('x1 x2 x3 x4 x5 x6')
solve_linear_system(S2, x1, x2, x3, x4, x5, x6)
def template_12(self, a, b):
m = sympy.symbols('x')
n = sympy.symbols('y')
system = sympy.Matrix(((1, 1, a), (1, -1, b)))
return sympy.solve_linear_system(system, m, n)
def balance(eq):
M = getmatrix(eq)
lefteq = re.split("=", eq)[0]
righteq = re.split("=", eq)[1]
left_compounds = re.split('\s*\+\s*', lefteq)
right_compounds = re.split('\s*\+\s*', righteq)
elements = []
for l_ele in left_compounds:
help_list = re.findall(r'([A-Z][a-z]{0,1})(\d*)', l_ele)
for ele in help_list:
if ele[0] not in elements:
elements.append(ele[0])
n = len(left_compounds) + len(right_compounds)
x = [parse_expr('x%d' % i) for i in range(n)]
x = sp.symbols('x0:%d' % n)
sols = sp.solve_linear_system(M, *x)
new_dict = {}
for i in x:
new_dict[i] = 1
# print new_dict
for key in sols:
if sols[key].args == ():
new_dict[key] = 1
else:
new_dict[key] = (sols[key]).args[0]
# remove fractions
final_list = []
for i in range(n):
final_list.append(sp.fraction(new_dict[x[i]])[1])
f = sp.lcm(final_list)
for key in new_dict:
new_dict[key] = new_dict[key] * f
# form the final output string
final_string = ""
for i in range(len(left_compounds)):
if new_dict[x[i]] == 1:
final_string += left_compounds[i]
else:
final_string += str(new_dict[x[i]]) + left_compounds[i]
if i != (len(left_compounds) - 1):
final_string += '+'
final_string += '='
for i in range(len(right_compounds)):
temp = len(left_compounds)
if new_dict[x[i + temp]] == 1:
final_string += right_compounds[i]
else:
final_string += str(new_dict[x[i + temp]]) + right_compounds[i]
if i != (len(right_compounds) - 1):
final_string += '+'
return final_string
def template_1(self, a, b, c, d, e, f):
m = sympy.symbols('x')
n = sympy.symbols('y')
system = sympy.Matrix(((a, b, c), (d, e, f)))
return sympy.solve_linear_system(system, m, n)
def timeit_linsolve_trivial():
solve_linear_system(M, *S)
def __call__(self, equations, variables=None, simplify=True):
if variables is None:
variables = {}
# Get a representation of the ODE system in the form of
# dX/dt = M*X + B
varnames, matrix, constants = get_linear_system(equations)
# No differential equations, nothing to do (this occurs sometimes in the
# test suite where the whole model is nothing more than something like
# 'v : 1')
if matrix.shape == (0, 0):
return ''
# Make sure that the matrix M is constant, i.e. it only contains
# external variables or constant variables
t = Symbol('t', real=True, positive=True)
# Check for time dependence
if 'dt' in variables:
dt_value = variables['dt'].get_value()[0]
# This will raise an error if we meet the symbol "t" anywhere
# except as an argument of a locally constant function
t = Symbol('t', real=True, positive=True)
for entry in itertools.chain(matrix, constants):
_check_for_locally_constant(entry, variables, dt_value, t)
symbols = [Symbol(variable, real=True) for variable in varnames]
solution = sp.solve_linear_system(matrix.row_join(constants), *symbols)
b = sp.ImmutableMatrix([solution[symbol] for symbol in symbols]).transpose()
# Solve the system
dt = Symbol('dt', real=True, positive=True)
A = (matrix * dt).exp()
if simplify:
A.simplify()
C = sp.ImmutableMatrix([A.dot(b)]) - b
_S = sp.MatrixSymbol('_S', len(varnames), 1)
# The use of .as_mutable() here is a workaround for a
# ``Transpose object does not have
updates = A * _S + C.transpose()
try:
# In sympy 0.7.3, we have to explicitly convert it to a single matrix
# In sympy 0.7.2, it is already a matrix (which doesn't have an
# is_explicit method)
updates = updates.as_explicit()
except AttributeError:
pass
# The solution contains _S[0, 0], _S[1, 0] etc. for the state variables,
# replace them with the state variable names
abstract_code = []
for idx, (variable, update) in enumerate(zip(varnames, updates)):
rhs = update
for row_idx, varname in enumerate(varnames):
rhs = rhs.subs(_S[row_idx, 0], varname)
# Do not overwrite the real state variables yet, the update step
# of other state variables might still need the original values
abstract_code.append('_' + variable + ' = ' + sympy_to_str(rhs))
# Update the state variables
for variable in varnames:
abstract_code.append('{variable} = _{variable}'.format(variable=variable))
return '\n'.join(abstract_code)
def compute_L(self):
"""
Compute L matrix of corrective solution:
it works differently for symmetric and non-symmetric sections
"""
nnode = len(self.g.nodes())
# TODO: can it be globally defined?
nodedict = dict(zip(self.g.nodes(), range(nnode)))
self.L = sympy.zeros(nnode, nnode - 3)
# define as many symbols as nodes
aa = sympy.symbols("a0:%d" % nnode)
self.expr = []
# symmetric sections
if any(self.is_symmetric):
# select list of symmetric nodes (y-axis symmetry is privileged)
if self.is_symmetric[0]:
act_nodes = self.symmetry[0]["nodes"]
else:
act_nodes = self.symmetry[1]["nodes"]
# assign a symbol to each node, for symmetric and antisymmetric loads
self.val = sympy.zeros(nnode, 2)
ai = 0
a_sym = []
a_asym = []
for nc in act_nodes:
# node on axis (zero for antisymmetric, symbol fo symmetric)
if nc[0] != nc[1]:
# antisymmetric
self.val[nodedict[nc[0]], 1] = aa[ai]
self.val[nodedict[nc[1]], 1] = -aa[ai]
a_asym.append(aa[ai])
ai += 1
# symmetric
self.val[nodedict[nc[0]], 0] = aa[ai]
self.val[nodedict[nc[1]], 0] = aa[ai]
a_sym.append(aa[ai])
ai += 1
# write an equation for Rz = 0 (only symmetric)
self.expr.append(sum(self.val[:, 0]))
# write and equation for Mx = 0 (only symmetric)
self.expr.append(sum([self.val[nodedict[ni], 0] * self.g.node[ni]["pos"][1] for ni in self.g.nodes()]))
# write an equation for My = 0 (only antisymmetric)
self.expr.append(sum([self.val[nodedict[ni], 1] * self.g.node[ni]["pos"][0] for ni in self.g.nodes()]))
# write a system of equation for Rz = 0 and Mx = 0
self.system1 = sympy.zeros(len(a_sym) + 1, 2)
for k in range(2):
dd = sympy.poly(self.expr[k], a_sym)
for ii, ai in enumerate(a_sym):
self.system1[ii, k] = dd.coeff_monomial(ai)
# self.system1[0:len(a_sym),k] = dd.coeffs()
# solve the first underdetermined system
self.sol1 = sympy.solve_linear_system(self.system1.T, *a_sym)
# write a system (actually only a single equation) for My = 0
self.system2 = sympy.zeros(len(a_asym) + 1, 1)
dd = sympy.poly(self.expr[2], a_asym)
for ii, ai in enumerate(a_asym):
self.system2[ii, 0] = dd.coeff_monomial(ai)
# self.system2[0:len(a_asym),0] = dd.coeffs()
# solve second underdetermined system
self.sol2 = sympy.solve_linear_system(self.system2.T, *a_asym)
# search for free variables
free_var = [[ai for ai in a_sym if ai not in self.sol1], [ai for ai in a_asym if ai not in self.sol2]]
# buld lists of combinations of free variables
self.free = [[], []]
# for each set of equations (symmetric and antisymmetric)
# write every possible combination of free variables (a single 1 and the rest 0)
for kk in range(2):
for snum, sym in enumerate(free_var[kk]):
self.free[kk].append([])
for snum1, sym1 in enumerate(free_var[kk]):
if snum == snum1:
self.free[kk][snum].append((sym1, 1))
else:
self.free[kk][snum].append((sym1, 0))
# solution list of symmetric component
self.symm_sol_list = []
# assign every possible set of free variables to the underdetermined system
for ns, ls in enumerate(self.free[0]):
self.symm_sol_list.append([(ai, self.sol1[ai].subs(ls)) for ai in self.sol1])
for li in ls:
self.symm_sol_list[ns].append(li)
# polulate L
for nsol, sol_list in enumerate(self.symm_sol_list):
self.L[:, nsol] = self.val[:, 0].subs(sol_list)
# solution list for antisymmetric component
self.asym_sol_list = []
# assign every possible set of free variables to the underdetermined system
for ns, ls in enumerate(self.free[1]):
self.asym_sol_list.append([(ai, self.sol2[ai].subs(ls)) for ai in self.sol2])
for li in ls:
self.asym_sol_list[ns].append(li)
# populate L
for nsol, sol_list in enumerate(self.asym_sol_list):
self.L[:, -1 - nsol] = self.val[:, 1].subs(sol_list)
# section is not symmetric
else:
# assign variables progressively
self.val = sympy.zeros(nnode, 1)
for kk in range(nnode):
self.val[kk] = aa[kk]
# write equations for Rz Mx My = 0
self.expr.append(sum(self.val))
self.expr.append(sum([self.val[nodedict[ni]] * self.g.node[ni]["pos"][1] for ni in self.g.nodes()]))
self.expr.append(sum([self.val[nodedict[ni]] * self.g.node[ni]["pos"][0] for ni in self.g.nodes()]))
# write a system of equations
self.system1 = sympy.zeros(len(aa) + 1, 3)
for k in range(3):
dd = sympy.poly(self.expr[k], aa)
for ii, ai in enumerate(aa):
self.system1[ii, k] = dd.coeff_monomial(ai)
# print(self.system1)
# solve the underdetermined system
self.sol1 = sympy.solve_linear_system(self.system1.T, *aa)
# search for free variables
free_var = [ai for ai in aa if ai not in self.sol1]
self.free = []
# find every possible combination of free variables (a single 1 and all zeros)
for snum, sym in enumerate(free_var):
self.free.append([])
for snum1, sym1 in enumerate(free_var):
if snum == snum1:
self.free[snum].append((sym1, 1))
else:
self.free[snum].append((sym1, 0))
# solution list
self.sol_list = []
# substitute each possible combination of free variables to others
for ns, ls in enumerate(self.free):
self.sol_list.append([(ai, self.sol1[ai].subs(ls)) for ai in self.sol1])
for li in ls:
self.sol_list[ns].append(li)
# polulate L
for nsol, sol_list in enumerate(self.sol_list):
self.L[:, nsol] = self.val[:, 0].subs(sol_list)
self.L = sympy.simplify(self.L)
# Solución gráfica.
x_vals = np.linspace(-5, 5, 50) # crea 50 valores entre 0 y 5
ax = dibuja_figura()
ax.set_xlim(-5, 5)
ax.set_ylim(-5, 5)
ax.grid()
ax.plot(x_vals, (1.2 * x_vals) / -2.2) # grafica 1.2x_1 - 2.2x_2 = 0
a = ax.plot(x_vals, (1.1 * x_vals) / 1.4) # grafica 1.1x_1 + 1.4x_2 = 0
# Sympy para resolver el sistema de ecuaciones lineales
a1, a2, a3 = sympy.symbols("a1, a2, a3")
A = sympy.Matrix(((3, 3, 3, 0), (2, 2, 2, 0), (2, 1, 0, 0), (3, 2, 1, 0)))
sympy.solve_linear_system(A, a1, a2, a3)
A = sympy.Matrix(((1, 1, 1, 0), (-2, 1, 1, 0), (-1, 2, 0, 0)))
sympy.solve_linear_system(A, a1, a2, a3)
# Calculando el rango con SymPy
A = sympy.Matrix([[1, 1, 1, 4], [1, 2, 1, 5], [1, 1, 1, 6]])
# Rango con SymPy
print A.rank()
# Calculando el rango con numpy
A = np.array([[1, 1, 2, 4], [1, 1, 2, 5], [1, 1, 2, 6]])
print np.linalg.matrix_rank(A)
# Determinante con sympy
