def gm2_strategy(kurtosis, b=2): '''Use sympy to solve for "a" in Proposition 2 numerically.''' # sym.init_printing(use_unicode=True) # # ^required if symbolic output is desired. a = sym.symbols('a') K = kurtosis / 3.0 # Use equation from Prop. 2 LHS = (K - (b**4)) / ((a**4) - (b**4)) RHS = (1 - (b**2)) / ((a**2) - (b**2)) a_solved = sym.solveset(sym.Eq(LHS, RHS), a, domain=sym.S.Reals) # ... expect negative and positve real solutions # provided in sympy's FiniteSet format. if a_solved == sym.S.EmptySet: # ^when no feasible solution was found in domain. # Do not accept imaginary solutions. raise OverflowError("Extreme kurtosis: Retry using larger b.") # ^dies when kurtosis > 12 and b=2, for example. # SPX returns since 1957 have kurtosis around 31.6 # which is very high, requiring b>3.4 for feasiblity. else: # But a>0 by construction, so extract the positive real number: a_positive = max(list(a_solved)) return a_positive
def inverse_laplace_transform(expr, s, t, **assumptions): """Calculate inverse Laplace transform of X(s) and return x(t). The unilateral Laplace transform cannot determine x(t) for t < 0 unless given additional information in the way of assumptions. The assumptions are: dc -- x(t) = constant so X(s) must have the form constant / s causal -- x(t) = 0 for t < 0. ac -- x(t) = A cos(a * t) + B * sin(b * t) """ if expr.is_Equality: return sym.Eq(inverse_laplace_transform(expr.args[0], s, t, **assumptions), inverse_laplace_transform(expr.args[1], s, t, **assumptions)) if expr.has(t): raise ValueError('Cannot inverse Laplace transform for expression %s that depends on %s' % (expr, t)) const, cresult, uresult = inverse_laplace_transform1(expr, s, t, **assumptions) return inverse_laplace_make(t, const, cresult, uresult, **assumptions)
def print_Chain(self, rule): with self.new_step(), self.new_u_vars() as (u, du): self.append("Sea {}.".format( self.format_math(sympy.Eq(u, rule.inner)))) self.print_rule(replace_u_var(rule.substep, rule.u_var, u)) with self.new_step(): if isinstance(rule.innerstep, FunctionRule): self.append( "Entonces, aplicando la regla de la cadena. Multipicamos por {}:" .format( self.format_math( sympy.Derivative(rule.inner, rule.symbol)))) self.append(self.format_math_display(diff(rule))) else: self.append( "Entonces, aplicando la regla de la cadena. Multipicamos por {}:" .format( self.format_math( sympy.Derivative(rule.inner, rule.symbol)))) with self.new_level(): self.print_rule(rule.innerstep) self.append("El resultado de la regla de la cadena:") self.append(self.format_math_display(diff(rule)))
def convert_relation(rel): if rel.expr(): return convert_expr(rel.expr()) lh = convert_relation(rel.relation(0)) rh = convert_relation(rel.relation(1)) if rel.LT(): return sympy.StrictLessThan(lh, rh, evaluate=False) elif rel.LTE(): return sympy.LessThan(lh, rh, evaluate=False) elif rel.GT(): return sympy.StrictGreaterThan(lh, rh, evaluate=False) elif rel.GTE(): return sympy.GreaterThan(lh, rh, evaluate=False) elif rel.EQUAL(): return sympy.Eq(lh, rh, evaluate=False) elif rel.ASSIGNMENT(): # !Use Global variances variances[lh] = rh var[str(lh)] = rh return rh elif rel.UNEQUAL(): return sympy.Ne(lh, rh, evaluate=False)
def get_transfer_functions(t, x_vec, u_vec, equations_of_motion): s = sp.symbols('s') X_vec = np.array([sp.Function(x.name.capitalize())(s) for x in x_vec[::2]]) U_vec = np.array([sp.Function(u.name.capitalize())(s) for u in u_vec]) laplace_tf = {} for x, X in zip(x_vec[::2], X_vec): laplace_tf[x] = X laplace_tf[sp.diff(x)] = s * X laplace_tf[sp.diff(x, (t, 2))] = s**2 * X for u, U in zip(u_vec, U_vec): laplace_tf[u] = U laplace_equations = [ sp.Eq(sp.diff(x, t), eq).subs(laplace_tf) for x, eq in zip(x_vec[1::2], equations_of_motion[1::2]) ] result = sp.solve(laplace_equations, list( X_vec)) # need to convert to list because sympy doesn't support numpy laplace_transforms = [sp.simplify(result[X]) for X in X_vec] return s, X_vec, U_vec, laplace_transforms
def validator(user_answer): try: # pass user_answer = user_answer.lower() user_answer = user_answer.replace(' ', '') user_answer = user_answer.replace('f(x)', 'y') user_answer = user_answer.replace('^', '**') lhs, rhs = user_answer.split('=') lhs = parse_expr(lhs, transformations=transformations) rhs = parse_expr(rhs, transformations=transformations) user_answer = sy.Eq(lhs, rhs) y = sy.Symbol('y') user_answer = sy.solve(user_answer, y)[0] lc = get_coeff(user_answer) if lc == 1: fmt_lc = '' elif lc == -1: fmt_lc = '-' else: fmt_lc = sy.latex(lc) expr = user_answer/lc except: raise SyntaxError
def __add_terms(self, var, left_side, right_side): #Add random x**2 term at both sides if random.randint(1, 100) < self.prob_moreterms: coeficient = get_random_number(self.maxcoef, [ 0, ]) left_side += coeficient * var**2 right_side += coeficient * var**2 #Add random x term at both sides if random.randint(1, 100) < self.prob_moreterms: coeficient = get_random_number(self.maxcoef, [ 0, ]) left_side += coeficient * var right_side += coeficient * var #Add random independent term at both sides if random.randint(1, 100) < self.prob_moreterms: coeficient = get_random_number(self.maxcoef, [ 0, ]) left_side += coeficient right_side += coeficient #Multiply both side by a number if random.randint(1, 100) < self.prob_mult: coeficient = get_random_number(self.maxcoef, [ 0, ]) left_side = coeficient * left_side right_side = coeficient * right_side left_side = sympy.expand(left_side) right_side = sympy.expand(right_side) return sympy.Eq(left_side, right_side)
def get_transfer_function(hardware_major_version, solve_for=None, Zs=None): ''' Parameters ---------- hardware_major_version : int Major version of control board hardware *(1 or 2)*. solve_for : str, optional Rearrange equality with ``solve_for`` symbol as LHS. Zs : list List of impedance (i.e., ``Z``) to substitute with resistive and capacitive terms. By default, all ``Z`` terms are substituted with corresponding ``R`` and ``C`` values. Returns ------- sympy.Equality Feedback measurement circuit symbolic transfer function for specified control board hardware version. Note ---- This function is memoized, to improve performance for repeated calls with the same arguments. ''' xfer_func = z_transfer_functions()[hardware_major_version] symbols = OrderedDict([(s.name, s) for s in xfer_func.atoms(sp.Symbol)]) if Zs is None: Zs = [s for s in symbols if s != solve_for and s.startswith('Z')] H = rc_transfer_function(xfer_func, Zs) if solve_for is None: return H symbols = OrderedDict([(s.name, s) for s in H.atoms(sp.Symbol)]) solve_for_symbol = symbols[solve_for] solved = sp.Eq(solve_for_symbol, sp.solve(H, solve_for_symbol)[0]) return solved
def to_explicit_odes(self, skip_output=False): amount_funcs = sympy.Matrix( [sympy.Function(amt.name)(self.t) for amt in self.amounts]) derivatives = sympy.Matrix( [sympy.Derivative(fn, self.t) for fn in amount_funcs]) inputs = self.zero_order_inputs a = self.compartmental_matrix @ amount_funcs + inputs eqs = [sympy.Eq(lhs, rhs) for lhs, rhs in zip(derivatives, a)] ics = {} output = self.find_output() for node in self._g.nodes: if skip_output and node == output: continue if node.dose is not None and isinstance(node.dose, Bolus): if node.lag_time: time = node.lag_time else: time = 0 ics[sympy.Function(node.amount.name)(time)] = node.dose.amount else: ics[sympy.Function(node.amount.name)(0)] = sympy.Integer(0) if skip_output: eqs = eqs[:-1] return eqs, ics
def diff_dynsys(self, k): """Compute derivatives of the dynamical system and substitute with ODEs. Parameters ---------- k : int Order of the derivative Returns ------- two dimensional list(equations) """ dynsys = self.ode2dynsys() diff = [] diff_out = [dynsys] substitutes = [] l = len(dynsys) idx = 0 for i in range(l): substitutes.append((dynsys[idx].lhs, dynsys[idx].rhs)) idx += 1 for i in range(1, k): idx = 0 for j in range(l): diff.append( sp.Eq( sp.diff(dynsys[idx].lhs, self.t, i), sp.diff(diff_out[i - 1][idx].rhs, self.t).subs(substitutes), )) idx += 1 diff_out.append(diff) diff = [] return diff_out
def getDeviceXY_old(antenna, d): x, y = sym.symbols('x,y', real=True) eq = sym.Eq((antenna.x - x)**2 + (antenna.y - y)**2, d**2) sol = sym.solve((eq), (x, y)) ra = np.arange(4, 8) all_y = [] for i in range(len(sol)): f = sym.lambdify(y, sol[i][0], "numpy") all_y = list(set(all_y) | set(f(ra)[~np.isnan(f(ra))])) #all_y = [round(num, 5) for num in all_y] df = pd.DataFrame(columns=['x', 'y']) for i in range(len(sol)): for elem in all_y: if 0 < elem < 16: res = sol[i][0].evalf(subs={y: elem}) if isinstance(res, sym.Float): if 0 < res < 5: df = df.append({ "x": float(res), "y": elem }, ignore_index=True) return df
def all_equations(self) -> Set[sympy.Eq]: """ Returns a set of equations for all rules currently found. """ def get_function(comb_class) -> sympy.Function: return comb_class.get_function(self.classdb.get_label) eqs = set() for rule in self.all_rules(): try: eq = rule.get_equation(get_function) except NotImplementedError: logger.info( "can't find generating function for %s." " The comb class is:\n%s", get_function(rule.comb_class), rule.comb_class, ) eq = sympy.Eq( get_function(rule.comb_class), sympy.Function("NOTIMPLEMENTED")(sympy.var("x")), ) eqs.add(eq) return eqs
def construct_eqn(eqn, is_eq, rationalize): """ Construct equation with sympy. Rationalize it if flag is set to True. is_eq is True for DAIs and Actions NOTE: sympy.sympify(eqn) converts eqn into a type that can be used inside SymPy """ try: if is_eq: eqn_split = eqn.split('=') lhs, rhs = eqn_split[0], eqn_split[1] #print (lhs, rhs) eqn = sympy.Eq(sympy.sympify(lhs), sympy.sympify(rhs)) else: eqn = sympy.sympify(eqn) if type(eqn) is bool: return eqn except: Session.write("ERROR: Invalid expression.\n") return None if rationalize: eqn = SymEq.rationalize(eqn) return eqn
def symbolicSol(fList): z = sympy.symbols('z', complex = True) string = '' for o in range(0, len(fList)): if fList[o] > 0: string = string + ' + ' + str(fList[o]) + '*z**' + str(o) elif fList[o] < 0: string = string + ' - ' + str(fList[o])[1:] + '*z**' + str(o) else: continue expr = parse_expr(string) sol = sympy.solve(sympy.Eq(expr, 0), domain = sympy.S.Complexes) return [s.evalf() for s in sol]
def format(self, form='A y = b', invert=False): """Forms can be: A y = b b = A y Ainv b = y y = Ainv b If `invert` is True, the A matrix is inverted.""" if form == 'A y = b': return expr(sym.Eq(sym.MatMul(self.A, self.y), self.b), evaluate=False) elif form == 'b = A y': return expr(sym.Eq(self.b, sym.MatMul(self.A, self.y)), evaluate=False) elif form in ('y = Ainv b', 'default'): if invert: return expr( sym.Eq(self.y, sym.MatMul(self.Ainv, self.b), evaluate=False)) return expr( sym.Eq(self.y, sym.MatMul(sym.Pow(self.A, -1), self.b), evaluate=False)) elif form == 'Ainv b = y': if invert: return expr( sym.Eq(sym.MatMul(self.Ainv, self.b), self.y, evaluate=False)) return expr( sym.Eq(sym.MatMul(sym.Pow(self.A, -1), self.b), self.y, evaluate=False)) else: raise ValueError('Unknown form %s' % form)
def test_F(): "Hazony example 5.2.2" s = symbols('s') print("test_F") Z = (s**2 + s + 1) / (s**2 + 2 * s + 2) print(f"Z: {Z}") min_r = (3 - sympy.sqrt(2)) / 4 Z1 = ratsimp(Z - min_r) print(f"Z1: {Z1}") #plot_real_part( sympy.lambdify(s, Z1, "numpy")) Y1 = ratsimp(1 / Z - 1) print(f"Y1: {Y1}") C = Cascade.Shunt(1) Z2 = ratsimp(1 / Y1 - s) print(f"Z2: {Z2}") C = C.hit(Cascade.Series(s)) Y3 = ratsimp(1 / Z2 - s - 1) print(f"Y3: {Y3}") Ytotal = C.hit(Cascade.Shunt(1).hit( Cascade.Shunt(s))).terminate_with_admittance(0) assert sympy.Eq(0, ratsimp(1 / Ytotal - Z)) assert sympy.Eq(1, ratsimp(Ytotal * Z)) Ytotal = C.hit(Cascade.Shunt(s)).terminate_with_admittance(1) assert sympy.Eq(0, ratsimp(1 / Ytotal - Z)) assert sympy.Eq(1, ratsimp(Ytotal * Z)) Ytotal = C.terminate_with_admittance(1 + s) assert sympy.Eq(0, ratsimp(1 / Ytotal - Z)) assert sympy.Eq(1, ratsimp(Ytotal * Z))
def FocalLossFormulas(): x, y, gamma = sp.symbols('x y gamma') p = sp.exp(x) / (1 + sp.exp(x)) display(sp.Eq(sp.S('p'), p)) L_plus = (1 - p)**gamma * sp.log(p) L_minus = p**gamma * sp.log(1 - p) display(sp.Eq(sp.S('L_plus'), L_plus)) display(sp.Eq(sp.S('L_minus'), L_minus)) L = -y * L_plus - (1 - y) * L_minus display(sp.Eq(sp.S('L'), L)) der1 = sp.diff(L, x) display(sp.Eq(sp.S('L__der1'), der1)) der2 = sp.diff(der1, x) display(sp.Eq(sp.S('L__der2'), der2)) return der1, der2
def test_more_equations_than_symbols(self): system = EquationsSystem() system.add_figure_symbols('figure', ['x1', 'y1', 'x2', 'y2']) f_ = system.get_symbols('figure') f_x1, f_y1, f_x2, f_y2 = f_['x1'], f_['y1'], f_['x2'], f_['y2'] values = {'figure': {'x1': 5.0, 'y1': 6.0, 'x2': 10.0, 'y2': 2.0}} # Fix start fixed_f_1 = [sympy.Eq(f_x1, 0.0), sympy.Eq(f_y1, 0.0)] system.add_restriction_equations('fixed_f_1', fixed_f_1) result = system.solve(values) values['figure'].update(result['figure']) # Fix end fixed_f_2 = [sympy.Eq(f_x2, 1.0), sympy.Eq(f_y2, 1.0)] system.add_restriction_equations('fixed_f_2', fixed_f_2) result = system.solve(values) values['figure'].update(result['figure']) # Try fix incorrect length fixed_length_incorrect = [ sympy.Eq((f_x2 - f_x1)**2 + (f_y2 - f_y1)**2, 10**2) ] system.add_restriction_equations('fixed_length_incorrect', fixed_length_incorrect) with pytest.raises(MoreEquationsThanSymbolsError): system.solve(values) system.remove_restriction_equations('fixed_length_incorrect') # Try fix correct length fixed_length_correct = [ sympy.Eq((f_x2 - f_x1)**2 + (f_y2 - f_y1)**2, 5**2) ] system.add_restriction_equations('fixed_length_correct', fixed_length_correct) with pytest.raises(MoreEquationsThanSymbolsError): system.solve(values) system.remove_restriction_equations('fixed_length_correct')
def test_equation_field(): x, y = sympy.symbols("x y") with sympy.evaluate(False): test.equation = "3 * x + 5 = 4" assert test.equation == sympy.Eq(3 * x + 5, 4) test.equation = "3 * x + 5" assert test.equation == sympy.Eq(3 * x + 5, 0) test.equation = 3 * x + 5 assert test.equation == sympy.Eq(3 * x + 5, 0) test.equation = "2 x + 3 y = y = x + y" assert test.equation == (sympy.Eq(2 * x + 3 * y, y), sympy.Eq(y, x + y)) # If evaluate=True, Eq(1 / x) is False test.equation = "1 / x" assert test.equation == sympy.Eq(1 / x, 0) with pytest.raises(TypeError): test.equation = False with pytest.raises(ValueError): test.equation = "3 x = **"
import sympy tempprom = 37 tempamb = 15 temphdesp = 33.9 tempinit = 34.5 t, k = sympy.symbols('t k') y = sympy.Function('y') f = k * (y(t) - tempamb) sympy.Eq(y(t).diff(t), f) edo_sol = sympy.dsolve(y(t).diff(t) - f) ics = {y(0): tempinit} C_eq = sympy.Eq(edo_sol.lhs.subs(t, 0).subs(ics), edo_sol.rhs.subs(t, 0)) C = sympy.solve(C_eq)[0] eq = sympy.Eq(y(t), C * sympy.E**(k * t) + tempamb) ics = {y(1): temphdesp} k_eq = sympy.Eq(eq.lhs.subs(t, 1).subs(ics), eq.rhs.subs(t, 1)) kn = round(sympy.solve(k_eq)[0], 4) hmuerte = sympy.Eq(tempprom, C * sympy.E**(kn * t) + tempamb) t = round(sympy.solve(hmuerte)[0], 2)
#This labels all the "nodes" in the system. Each node is a sympy variable that will be solved #Variables to be used in the calculation. x, y, f = sym.symbols('x y f') x0, y0, y1, x1, phi0, phix, phiy = sym.symbols( 'x_0 y_0 y_1 x_1 phi_0 phi_x phi_y') phixx, phiyy = sym.symbols('phi_xx phi_yy') x2, y2 = sym.symbols('x2 y2') trial_function = (1 - x**2) * (1 - y**2) #2. Set up The Element Parameters ax, bx, ay, by, c = sym.symbols('a_x b_x a_y b_y c') #This creates the template element by approximating it as a plane. eq1 = sym.Eq(phi0, ax * x0**2 + bx * x0 + ay * y0**2 + by * y0 + c) eq2 = sym.Eq(phix, ax * x1**2 + bx * x1 + ay * y0**2 + by * y0 + c) eq3 = sym.Eq(phixx, ax * x2**2 + bx * x2 + ay * y0**2 + by * y0 + c) eq4 = sym.Eq(phiy, ax * x0**2 + bx * x0 + ay * y1**2 + by * y1 + c) eq5 = sym.Eq(phiyy, ax * x0**2 + bx * x0 + ay * y2**2 + by * y2 + c) result = sym.nonlinsolve([eq1, eq2, eq3, eq4, eq5], [ax, ay, bx, by, c]) # print(sym.latex(result)) phi_final = result.args[0][0] * x**2 + result.args[0][1] * y**2 + result.args[ 0][2] * x + result.args[0][3] * y + result.args[0][4] phi_solve_vars = [phi0, phix, phixx, phiy, phiyy] phi_poly = sym.Poly(phi_final, phi_solve_vars) # print(sym.latex(phi_poly.as_expr()))
#!/usr/bin/python3 import sympy as sym a,b,c = sym.symbols("a b c") x = sym.Symbol("x") eq = sym.Eq(a * x**2 + b * x + c) print(eq) roots = sym.solve(eq, x) print(roots)
# importando modulos necesarios import matplotlib import matplotlib.pyplot as plt import numpy as np import sympy from scipy import integrate # imprimir con notación matemática. sympy.init_printing(use_latex='mathjax') x = sympy.Symbol('x') y = sympy.Function('y') # definiendo la ecuación eq = 1 # Condición inicial ics = {y(2): 1} # Resolviendo la ecuación edo_sol = sympy.dsolve(y(x).diff(x) - eq) edo_sol # Sustituyendo condiciones iniciales C_eq = sympy.Eq(edo_sol.lhs.subs(x, 0).subs(ics), edo_sol.rhs.subs(x, 0)) C_eq sympy.solve(C_eq)
# %% N_t theta_t # %% #sp.series(theta_t, x=N, x0=1, n=3) print(sp.latex(sp.series(N_t, x=theta, x0=0, n=5))) # %% x = sp.symbols('x') sp.series(sp.sqrt(1-x), x=x, x0=0, n=4) # %% i = 1.336 g = 2.689e-5 print((i-1)/2/g/i) # %% %matplotlib qt sp.plot_implicit(sp.Eq((index-1)/gamma/index/2, 5000), (index, 1, 2), (gamma, 2e-5, 4e-5)) w
c = complex(-0.7, 0.27015) def f(z, c): try: num = 1 den = 1 - npy.cos(0.1 * z)**2 f = num / den + c except (OverflowError, ZeroDivisionError): f = 100 + c return f # Converting to latex exp = sym.Eq(FZ, (1) / (1 - sym.cos(Z)**2) + C) # Write the latex expression to file sym.preview(exp, viewer='file', filename='latex.png') perdone = 0 # Draw the set for x in range(w): # Progress if ((x / w) * 100) > perdone: print(perdone, '% completed') if (perdone % 10 == 0): print('Elapsed time: ', round(time.time() - start_time), 'seconds') bitmap.convert("RGB").save( 'C:/Users/qntmn/OneDrive/Python/Fractals/Progress/CurrentProgress' + str(perdone) + '.png')
#plot_1.extend(plot_2) #plot_1.show() expression_1 = sp.sin(sp.sin(2 * x + y)) - 1.6 * x expression_2 = x**2 + 2 * y**2 - 1 function_1 = sp.lambdify((x, y), expression_1, 'numpy') function_2 = sp.lambdify((x, y), expression_2, 'numpy') a_x = -1 b_x = 1 a_y = -1 b_y = 1 plot_1 = sp.plotting.plot_implicit(sp.Eq(expression_1, 0), (x, a_x, b_x), (y, a_y, b_y)) plot_2 = sp.plotting.plot_implicit(sp.Eq(expression_2, 0), (x, a_x, b_x), (y, a_y, b_y)) plot_1.extend(plot_2) plot_1.show() x_0 = -0.6 y_0 = -0.8 def jacobian(expression_1, expression_2, x_0, y_0): x, y = sp.symbols('x y') j = np.empty((2, 2), dtype=float) j[0][0] = sp.diff(expression_1, x).subs([(x, x_0), (y, y_0)]).evalf()
# %% import sympy as sp x3, y3, z3, x2, y2, z2 = sp.symbols('x3 y3 z3 x2 y2 z2', real=True) E, Em = sp.symbols('E Em', real=True, positive=True) # %% eq = sp.Eq( Em, E + sp.sqrt(x3**2 + y3**2 + (-E - z2)**2) + sp.sqrt(x2**2 + y2**2 + z2**2)) # %% from sympy import S sols = sp.solve(eq, z2, domain=S.Reals) # %% vect = sp.Matrix([ E, x2, y2, sp.simplify(sols[0].subs(x3, -x2).subs(y3, -y2)), -x2, -y2, -E - sp.simplify(sols[0].subs(x3, -x2).subs(y3, -y2)) ]) coords = [E, x2, y2] def numerical_vect(Enum, x2num, y2num, Emaxnum=1): z2num = sols[0].subs(x3, -x2).subs(y3, -y2).subs(E, Enum).subs(x2, x2num).subs(
h = h_0 + t objective = (alpha.T * h - t.T * C * t)[0, 0] constraint = sy.simplify(sy.expand((h.T * V * h)[0, 0])) utility = sy.simplify(objective - lam * constraint) print_expression("utility", utility) diff_system = [ sy.simplify(sy.diff(utility, t_0)), sy.simplify(sy.diff(utility, t_1)) ] print_expression("system", diff_system) t_solutions = sy.linsolve(diff_system, [t_0, t_1]) # Prepare a 4 degree polynome solution a_0, a_1, a_2, a_3, a_4 = sy.symbols("a_0 a_1 a_2 a_3 a_4") eq = sy.Eq( a_4 * (lam**4) + a_3 * (lam**3) + a_2 * (lam**2) + a_1 * (lam**1) + a_0, 0) # TODO: do only real numbers sy.Reals (raises an excception now when evaluating objective) polynome_solutions = sy.solveset(eq, lam) eq = eq.subs([(a_4, 1), (a_3, 0), (a_2, 0), (a_1, 0), (a_0, -1)]) print_expression("eq", eq.subs([(a_4, 1), (a_3, 0), (a_2, 0), (a_1, 0), (a_0, -1)])) print_expression("polynome_solutions", polynome_solutions) candidates = [] max_objective_result = None for sol in t_solutions: sol_vector = sy.Matrix([[sy.simplify(sol[0])], [sy.simplify(sol[1])]]) print_expression("t solution", sol_vector) variance = sy.simplify((sol_vector.T * V * sol_vector)[0, 0]) print_expression("variance", variance)
def assertEqual1(self, first, second, msg=None): if sympy.Eq(first, second): return raise self.failureException(msg=msg)
C1, C2, C3, C4 = sp.symbols('C1, C2, C3, C4') # Constantes de integración q = 0 # %%Se calcula la matrix de rigidez K = sp.zeros(4) V = sp.integrate(q, x) + C1 # se integran las ec. diferenciales M = sp.integrate(V, x) + C2 # de la viga de Euler-Bernoulli t = (sp.integrate(M, x) + C3) / EI w = sp.integrate(t, x) + C4 for i in range(4): sol = sp.solve( [ sp.Eq(w.subs(x, 0), int(i == 0)), # Condiciones de frontera sp.Eq(t.subs(x, 0), int(i == 1)), sp.Eq(w.subs(x, L), int(i == 2)), sp.Eq(t.subs(x, L), int(i == 3)) ], [C1, C2, C3, C4]) constantes = [(C1, sol[C1]), (C2, sol[C2]), (C3, sol[C3]), (C4, sol[C4])] K[:, i] = [ +V.subs(constantes).subs(x, 0), # Y1 se evaluan las -M.subs(constantes).subs(x, 0), # M1 reacciones verticales -V.subs(constantes).subs(x, L), # Y2 y los momentos en los +M.subs(constantes).subs(x, L) ] # M2 apoyos