def get_expressions(): """ Create symoblic expressions for the system. Returns: Expressions for theta_dd_1 and theta_dd_2. """ s = 'l_1 theta_dd_1 m_1 m_2 l_2 theta_dd_2 theta_1 theta_2 theta_d_2 theta_d_1 g' l_1, theta_dd_1, m_1, m_2, l_2, theta_dd_2, theta_1, theta_2, theta_d_2, theta_d_1, g = sympy.symbols(s) expr1 = l_1 * theta_dd_1 * (m_1 + m_2) + m_2 * l_2 * (theta_dd_2 * sympy.cos(theta_1 - theta_2) + theta_d_2 ** 2 * sympy.sin(theta_1 - theta_2)) + (m_1 + m_2) * g * sympy.sin(theta_1) expr2 = m_2 * l_2 * theta_dd_2 + m_2 * l_1 * (theta_dd_1 * sympy.cos(theta_1 - theta_2) - theta_d_1 ** 2 * sympy.sin(theta_1 - theta_2)) + m_2 * g * sympy.sin(theta_2) theta_dd_1_expr = sympy.solveset(expr1, theta_dd_1).args[0] theta_dd_2_eval = sympy.solveset(expr2.subs(theta_dd_1, theta_dd_1_expr), theta_dd_2).args[0] theta_dd_2_expr = sympy.solveset(expr2, theta_dd_2).args[0] theta_dd_1_eval = sympy.solveset(expr1.subs(theta_dd_2, theta_dd_2_expr), theta_dd_1).args[0] res1 = sympy.simplify(theta_dd_1_eval) res2 = sympy.simplify(theta_dd_2_eval) sympy.init_printing() print(res1, res2, sep='\n\n') return res1, res2
def eval(cls, *args): assert len(args) in cls.nargs depen = args[:] indep = None while len(depen) > 0: search = [] for var in depen: if isinstance(var, Symbol): indep = var search = [] break elif isinstance(var, Real): continue else: search.extend(var.args) depen = search if indep is not None: res = solveset(cls._relation(*args), indep, domain=S.Reals) else: res = solveset(cls._relation(*args), domain=S.Reals) if isinstance(res, EmptySet): return S.Zero else: return S.One
def StrTabVarSimple(classe): u = rd.randint(0, 2) if classe == "Seconde": u = -1 v = rd.randint(0, 2) if u == -1: if v == 0: A = IdRemarq() S1 = StrFexpr(A) expr = A if v == 1: A = racinepib() * AxPb() S1 = StrFexpr(A) expr = A if v == 2: A = IdRemarq() expr = sp.sqrt(A) S1 = StrFexpr(expr) deriv = sp.diff(expr, x) [a, b] = fraction(deriv) resultat = solveset(a >= 0, domain=S.Reals) if u == 0: expr = AxPbCarreDur() + sgnnbre() + AxPb() S1 = StrFexpr(expr) if u == 1: expr = AxPb() * AxPb() S1 = StrFexpr(expr) if u == 2: expr = AxPbCubeDur() S1 = StrFexpr(expr) if (u != -1 or v != 2): deriv = sp.diff(expr, x) resultat = solveset(deriv >= 0, domain=S.Reals) return [S1, sp.latex(resultat), sp.latex(deriv)]
def hello_world(): x, y = symbols('x y') eq1, eq2 = getSimpleEq2(x, y) res: FiniteSet = solve(eq1, eq2, x, y) val_x = tuple(res)[0][0] val_y = tuple(res)[0][1] eq = mml('<mfenced open="{" close=""><mtable>' + mathml(eq1, printer="presentation") + mathml(eq2, printer="presentation") + "</mtable></mfenced>") sol1 = solveset(eq1, x) sol1f = tuple(sol1)[0] or 1 int1 = 0 sol2 = solveset(eq2, y) sol2f = tuple(sol2)[0] or 1 int2 = 0 return render_template('2eq.html', eq=eq, eq1=str(sol1f), eq2=str(sol2f), int1=int1, int2=int2, val_x=show_val(val_x), val_y=show_val(val_y))
def solve_function(self): """ O metodo determina a solucao da funcao """ #http://docs.sympy.org/latest/modules/solvers/solvers.html #http://docs.sympy.org/latest/modules/solvers/solveset.html try: funcao = self.string_function % (self.dic_coefficients) self.solve = solveset(funcao, x) self.solve_real = solveset(funcao, x, domain=S.Reals) except Exception as error: print('Function Error: ', error)
def FaireCorrection(self): if self.type == "D\\'eveloppement": self.corr = self.expr.expand() if self.type == "In\\'equation": self.corr = solveset(self.res >= 0, domain=S.Reals) if self.type == "Equation": self.corr = solveset(self.expr, domain=S.Reals) if self.type == "Tableaux de Variation": self.der = sp.together( sp.expand(sp.together(sp.diff(self.expr, x)))) self.Df = solveset(self.CheckDomaine >= 0, domain=S.Reals) [a, b] = fraction(self.der) self.res = solveset(a >= 0, domain=self.Df)
def StrTabVarDur(classe): u = rd.randint(0, 2) if classe == "Seconde": u = 0 if classe == "Terminale": u = rd.randint(3, 4) v = rd.randint(0, 2) if u == 0: expr = racine() * AxPbCubeDur() if classe == "Seconde": a = rd.randint(1, 9) * racinepib() b = rd.randint(1, 8) * racinepib() expr = (a * x + b)**3 S1 = StrFexpr(expr) if u == 1: expr = AxPb() * racine() * AxPbCarreDur() S1 = StrFexpr(expr) if u == 2: expr = AxPbCarreDur() / AxPb() S1 = StrFexpr(expr) if u == 3: # Exponentielle if v == 0: expr = sp.exp(AxPbCarre() / AxPb()) [S1, deriv, resultat] = AnalyseExpo(expr) if v == 1: expr = sp.exp(AxPb() * racinepib() * AxPbCarreDur()) [S1, deriv, resultat] = AnalyseExpo(expr) if v == 2: expr = AxPb() * sp.exp(AxPb()) [S1, deriv, resultat] = AnalyseExpo(expr) if u == 4: # Logarithme if v == 0: A = AxPbCarre() / AxPb() Df = sp.solveset(A > 0, domain=S.Reals) expr = sp.ln(A) [S1, deriv, resultat] = AnalyseLog(expr, Df) if v == 1: A = AxPb() expr = AxPbCube() + sp.ln(A) Df = sp.solveset(A > 0, domain=S.Reals) [S1, deriv, resultat] = AnalyseLog(expr, Df) if v == 2: A = AxPb() expr = sp.ln(A) / A Df = sp.solveset(A > 0, domain=S.Reals) [S1, deriv, resultat] = AnalyseLog(expr, Df) if classe != "Terminale": deriv = sp.diff(expr, x) resultat = solveset(deriv >= 0, domain=S.Reals) return [S1, sp.latex(resultat), sp.latex(deriv)]
def plot_vecfield( self, sp=None, small_v=False, S=1.0, norm_mag=True, idx_x=0, idx_y=1, ): # assume that stimulation is stim_func evaluated at 0 I_app = self.stim_func(0) # assert that the model has only two variables if self.sys_N != 2: raise Exception( 'Invalid model! need two dimensions to plot vector field') if sp is None: sp = (np.arange(-100, 100, 10), np.arange(-100, 100, 10)) # creating grid (X, Y) = np.meshgrid(*sp) # vector valued fctn u = self.model_funcs[idx_x](X, Y, I_app) v = self.model_funcs[idx_y](Y, Y, I_app) # magnitude r = np.sqrt(u**2.0 + v**2.0) # normalization of u,v u = u / r v = v / r # r = np.full(len(r), 1) if norm_mag: r = r / r # plot nullclines nlc_expr_X = sym.solveset(self.model_exprs[idx_x], self.lst_vars[idx_y]) nlc_expr_Y = sym.solveset(self.model_exprs[idx_y], self.lst_vars[idx_y]) nlc_func_X = sym.lambdify(nlc_expr_X) nlc_func_Y = sym.lambdify(nlc_expr_Y) plt.plot(sp[0], nlc_func_X(sp[0]), 'b-') plt.plot(sp[1], nlc_func_Y(sp[1]), 'b-') plt.quiver(X, Y, u, v, r, pivot="mid")
def solveset_it(expression, solve_for, equals_to=0): ''' Syntax for solveset: sympy.solveset(sympy.Eq(expression,equals_to, solve_for, domain=S.Complexes) or if expr = expression - equals_to: sympy.solveset(expr,solve_for,domain=S.Reals) or simply: sympy.solveset(expr,solve_for) ''' if equals_to == 0: return solveset(expression, solve_for) else: return solveset(Eq(expression, equals_to), solve_for)
def calcSumA1(): while True: try: snIn = input("Sn = ") nIn = input("n = ") rIn = input("r = ") expr = (Sn * (1 - r)) / (1 - (r**n)) - A1 expr = expr.subs(Sn, snIn) expr = expr.subs(n, nIn) expr = expr.subs(r, rIn) expr = solveset(expr, A1) print("\nResults:") print("A1 = ", snIn, " * (1 -", rIn, ") / (1 - (", rIn, "**", nIn, "))", sep='') print("A1 =", str(expr)) closer = str( input("\nEnter 1 to exit.\n" "Press any key to continue.\n")) if (closer == '1'): return except: print("Invalid Character")
def solve(equation): x = symbols('X') solutions = solveset(equation, x, domain=S.Reals).evalf() if isinstance(solutions, Interval): return 0 else: return list(solutions)[0]
def __init__(self,start,end,gama,delta,formula=lineType[0]): self.formula=formula # delta应力 self.delta=delta #gama 比载 self.gama=gama self.h=end.z-start.z self.theta_y=math.atan((start.y-end.y)/(end.x-start.x)) #L悬链线在2D情况下的实际x轴长度 self.L=(end.x-start.x)/math.cos(self.theta_y) #Lv悬链线在xoz平面投影的x轴长度 self.Lv=(end.x-start.x) self.t=self.delta/self.gama #beta用于斜抛线方程 self.beta=math.atan(self.h/self.L) ## self.Loa2=self.L/2-delta/gama*math.sin(self.beta) #Loa真实长度 if self.formula=="Catenary": #利用公式解Loa x=Symbol('x') ans=solveset(sh(x)-self.h/2/self.t/sh(self.L/2/self.t),domain=S.Reals) self.Loa=self.L/2-self.t*ans.args[0] # self.Loa=(self.L/2-(self.t)*sh(self.h/2/self.t/sh(self.L/2/self.t))) if self.formula=="Parabola": self.Loa=self.L/2-self.delta/self.gama*math.sin(self.beta) print('Loa: ',self.Loa) ## print('Loa2:',self.Loa2) #Arch_y架构侧点的y坐标,用于calculat_yzs函数 self.Arch_y=start.y
def evaluate(c, N, P): solutions, x = sp.symbols("solutions x") str_expr = get_equations_in_str(c, N, P) expr = sp.sympify(str_expr) solutions = sp.solveset(sp.Eq(expr), x) return solutions
def curve_normalize(old_curve: ParametricCurve, new_var=Symbol('s', real=True)): from sympy import S, solveset, Eq from sympy import integrate from silkpy.sympy_utility import norm drdt = norm(old_curve.exprs.diff(old_curve.sym(0))) new_var_in_old = integrate(drdt, old_curve.sym(0)).simplify() solset = solveset(Eq(new_var, new_var_in_old), old_curve.sym(0), domain=S.Reals).simplify() try: if len(solset) != 1: raise RuntimeError( f"We have not yet succedded in inverse s(t) into t(s).\ It found these solutions: {solset}.\ Users need to choose from them or deduce manually, and then set it by obj.param_norm(s_symbol, t_expressed_by_s" ) except: raise RuntimeError( f"We have not yet succedded in inverse s(t) into t(s). Try the curve_param_transform function instead and set the transform relation manually." ) else: old_var_in_new = next(iter(solset)) return ParametricCurve((new_var, new_var_in_old.subs(old_curve.sym(0), old_curve.sym_limit(0)[0]), new_var_in_old.subs(old_curve.sym(0), old_curve.sym_limit(0)[1])), old_curve.exprs.subs(old_curve.sym(0), old_var_in_new))
def MENUMODE(questionType): expr = questionType print(sympy.latex(expr)) ANS = sympy.solveset(expr) print( "1 is add, 2 is subtract, 3 is add multiples of X, and 4 is subtract multiples of X, 5 and 6 are divide and multiply, and 7 is to solve" ) CHOICE = int(input()) if CHOICE == 1: n = ADD(expr) MENUMODE(n) elif CHOICE == 2: n = SUBTRACT(expr) MENUMODE(n) elif CHOICE == 3: n = ADDX(expr) MENUMODE(n) elif CHOICE == 4: n = SUBTRACTX(expr) MENUMODE(n) elif CHOICE == 5: n = Divide(expr) MENUMODE(n) elif CHOICE == 6: n = Multiply(expr) MENUMODE(n) elif CHOICE == 7: ANSWER(expr)
def remove_nonzero_factors(eqn, reduce_monomials=False, atom_bounds=None): if eqn == 0: return eqn result = 1 domains = {} for atom in [a for a in eqn.atoms() if a.is_symbol]: if atom_bounds and atom in atom_bounds: domains[atom] = sp.Interval(*atom_bounds[atom]) else: domains[atom] = sp.Reals for factor in sp.factor(sp.cancel(eqn)).args: if isinstance(factor, sp.Pow) and factor.args[1] < 0: continue if reduce_monomials: atoms = [a for a in factor.atoms() if a.is_symbol] if len(atoms) == 1: a, = atoms solve_set = sp.solveset(factor, domain=domains[a]) if not solve_set: continue result *= factor return result
def calcDefr2(): while True: try: anIn = input("An = ") a1In = input("A1 = ") nIn = int(input("n = ")) expr = (An / A1)**(1 / (n - 1)) - r expr = expr.subs(An, anIn) expr = expr.subs(A1, a1In) expr = expr.subs(n, nIn) expr = solveset(expr, r) print("\nResults:") print("r = (", anIn, " / ", a1In, ")**(1 / (", nIn, " - 1))", sep='') print("r =", str(expr)) closer = str( input("\nEnter 1 to exit.\n" "Press any key to continue.\n")) if (closer == '1'): return except: print("Invalid Character")
def integral_func(expre1, expre2): expre = '{}-({})'.format(expre1, expre2) a_b = solveset(Eq(expre, 0), x) result = integrate(expre1, (x, *a_b)) - integrate(expre2, (x, *a_b)) return result
def twin_function_expr(self, value): if not value: self.twin_function = None self.twin_inverse_function = None self._twin_function_expr = "" self._twin_inverse_sympy = None return expr = sympy.sympify(value) if len(expr.free_symbols) > 1: raise ValueError("The expression must contain only one variable.") elif len(expr.free_symbols) == 0: raise ValueError("The expression must contain one variable, " "it contains none.") x = tuple(expr.free_symbols)[0] self.twin_function = lambdify(x, expr.evalf()) self._twin_function_expr = value if not self.twin_inverse_function: y = sympy.Symbol(x.name + "2") try: inv = sympy.solveset(sympy.Eq(y, expr), x) self._twin_inverse_sympy = lambdify(y, inv) self._twin_inverse_function = None except BaseException: # Not all may have a suitable solution. self._twin_inverse_function = None self._twin_inverse_sympy = None _logger.warning( "The function {} is not invertible. Setting the value of " "{} will raise an AttributeError unless you set manually " "``twin_inverse_function_expr``. Otherwise, set the " "value of its twin parameter instead.".format(value, self))
def symbol_calc_fz_jac_square_taylor(n): fx1sq, v = symbol_calc_2d_taylor(n, x_taylor="x1sq", order=3, x1_neg=True, slope="slope", Iext1="Iext1")[1:] fx1sq = fx1sq.tolist() fz, vz = symbol_eqtn_fz(n, zmode=array("lin"), z_pos=True, model="2d")[1:] fz = fz.tolist() v.update(vz) del vz x1 = [] #dfx1z = [] for iv in range(n): x1.append(list(solveset(fx1sq[iv], v["x1"][iv]))[0]) #dfx1z.append(x1[iv].diff(v["z"][iv])) for iv in range(n): for jv in range(n): fz[iv] = fz[iv].subs(v["x1"][jv], x1[jv]) fz_jac = Matrix(fz).jacobian(Matrix([v["z"]])) # for iv in range(n): # for jv in range(n): # fz_jac[iv, jv].simplify().collect(dfx1z[jv]) fz_jac = Array(fz_jac) fz_jac_lambda = lambdify([v["z"], v["y1"], v["Iext1"], v["K"], v["w"], v["a"], v["b"], v["tau1"], v["tau0"], v["x_taylor"]], fz_jac, 'numpy') return fz_jac_lambda, fz_jac, v
def gm2_strategy(kurtosis, b=2): '''Use sympy to solve for "a" in Proposition 2 numerically. >>> round( gm2_strategy(7, 2), 4 ) 0.7454 ''' # 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 :-) system.die("Extreme kurtosis: argument b should be increased.") # ^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 solver_rate_from_compounded_df(dis_factor, daycount_factors): rate = sy.Symbol('rate') fv = sy.Symbol('fv') #df = sy.Symbol('df') dcfs = daycount_factors #df = dis_factor for d in range(len(dcfs)): if d == 0: fv = (1 + (rate * 0.01 * dcfs[d])) else: fv = fv * (1 + (rate * 0.01 * dcfs[d])) fv = dis_factor * fv - 1 #solved_rates = sy.solve(fv,rate) solved_rates = sy.solveset(fv, rate, domain=sy.S.Reals) new_rates = [] #print('solved_rates==> ',solved_rates, type(solved_rates),list(solved_rates)) solved_rates = list(solved_rates) for i in range(len(solved_rates)): try: float(solved_rates[i]) except: continue new_rates.append(solved_rates[i]) new_rates = list(filter(lambda x: x > 0, new_rates)) return new_rates
def sympy_solver(expr): # Sympy is buggy and slow. Use Transforms. symbols = get_symbols(expr) if len(symbols) != 1: raise ValueError('Expression "%s" needs exactly one symbol.' % (expr, )) if isinstance(expr, Relational): result = sympy.solveset(expr, domain=sympy.Reals) elif isinstance(expr, sympy.Or): subexprs = expr.args intervals = [sympy_solver(e) for e in subexprs] result = sympy.Union(*intervals) elif isinstance(expr, sympy.And): subexprs = expr.args intervals = [sympy_solver(e) for e in subexprs] result = sympy.Intersection(*intervals) elif isinstance(expr, sympy.Not): (notexpr, ) = expr.args interval = sympy_solver(notexpr) result = interval.complement(sympy.Reals) else: raise ValueError('Expression "%s" has unknown type.' % (expr, )) if isinstance(result, sympy.ConditionSet): raise ValueError('Expression "%s" is not invertible.' % (expr, )) return result
def calcDefr(): while True: try: an1In = input("An1 = ") an2In = input("An2 = ") n1In = int(input("n1 = ")) n2In = int(input("n2 = ")) nIn = n1In - n2In expr = (An1 / An2)**(1 / n) - (r**n)**(1 / n) expr = expr.subs(An1, an1In) expr = expr.subs(An2, an2In) expr = expr.subs(n, nIn) print("\nResults: Restart or press Ctrl+C if taking too long") expr = solveset(expr, r) print("r^(1/", nIn, ") = (", an1In, " / ", an2In, ")^(1/", nIn, ")", sep='') print("r =", str(expr)) closer = str( input("\nEnter 1 to exit.\n" "Press any key to continue.\n")) if (closer == '1'): return except: print("Invalid Character")
def sympy_can_colide(a, b): ap, av, aa = a bp, bv, ba = b t = sympy.symbols('t', integer=True) a_exs = [ p + v * t + (a * t * (t + 1)) / 2 for (p, v, a) in zip(ap, av, aa) ] b_exs = [ p + v * t + (a * t * (t + 1)) / 2 for (p, v, a) in zip(bp, bv, ba) ] # exs = [sympy.Eq(ax, bx) for ax, bx in zip(a_exs, b_exs)] # print(sympy.solveset(exs, t, domain=sympy.S.Integers)) doms = [] dom = sympy.Integers for ax, bx in zip(a_exs, b_exs): w = sympy.Eq(ax, bx) sl = sympy.solveset(w, t, domain=sympy.S.Integers) dom = dom.intersect(sl) if dom == sympy.EmptySet: return None if dom != sympy.EmptySet: # print(a) # print(b) # print(dom) return dom return None
def find_solve_with_hybrid_method(func, a, b, x0, eps): x_k = x0 count = 0 # exact_solution = 0 i = 0 solutions = solveset(func) # while i < len(solutions): # if a < solutions.args[i] < b: # exact_solution = solutions.args[i] # i += 1 while True: x_k1 = x_k - (func.subs(x, x_k)) / ((diff(func, x)).subs(x, x_k)) while True: count += 1 if abs(func.subs(x, x_k1)) < abs(func.subs(x, x_k)): break else: x_k_temp = x_k x_k = x_k1 x_k1 = (x_k1 + x_k_temp) / 2 if abs(x_k - x_k1) <= eps: break x_k = x_k1 print("ГИБРИДНЫЙ МЕТОД") print("Найденный корень x* = " + str(x_k1)) print("Невязка f(x*) = " + str(func.subs(x, x_k1))) print("Кол-во итераций = " + str(count))
def eq_solver(): #Generate solutions here. eq_str = request.args.get('eq', 0) if not eq_str: return render_template('/projects/eq_solver.html') #Simplify expression (if necessary) sympy_eq_str = eq_str.replace('^', '**') try: simplified_expr = str(simplify(sympy_eq_str)).replace('**', '^') except: simplified_expr = eq_str #Calculate zeros + complex solutions expr = parse_expr( sympy_eq_str, transformations=(standard_transformations + (implicit_multiplication_application, ))) try: simplified_expr = str(simplify(expr)).replace('**', '^').replace('*', '') except: simplified_expr = eq_str sols = list(solveset(expr, Symbol('x'))) complex_sols = [complex(sol) for sol in sols if not sol.is_real] sols = [float(sol) for sol in sols if sol.is_real] return render_template('/projects/eq_solver.html', zeros=sols, complex_sols=complex_sols, eq=simplified_expr, submit="Yes")
def test_solveset(): x = Symbol('x') A = Matrix([[x, 2, x * x], [4, 5, x], [x, 8, 9]]) solns = solve(det(A), x) solns_set = list(solveset(det(A), x)) print(solns) print('\n') print(solns_set) print('\n\n\n') print((solns[0])) print('\n') print((solns_set[0])) soln_sub = solns[0].subs(x, 1) solnset_sub = solns_set[0].subs(x, 1) s1 = soln_sub.evalf() s1set = solnset_sub.evalf() s2set = solns_set[1].subs(x, 1).evalf() print(s1) print(s1set) print(s2set)
def gm2_strategy(kurtosis, b=2): '''Use sympy to solve for "a" in Proposition 2 numerically. >>> round( gm2_strategy(7, 2), 4 ) 0.7454 ''' # 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 :-) system.die("Extreme kurtosis: argument b should be increased.") # ^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 solve_for(self, sym, expr): ss = sy.solveset(expr, sym, domain=sy.S.Reals) try: ss = list(ss) except: pass return ss
def solve_d_geometric_eqn(self): cottheta = sy.symbols('c_theta', real=True, positive=True ) eq1 = self.raw_d_geometric_eqn(d, u,w,Q,theta).subs(sy.cot(theta),cottheta) d_geometric_solns = sy.solveset( eq1, d ) d_geometric_soln = sy.simplify(d_geometric_solns.args[1].subs( cottheta,1/sy.tan(theta))) return Eq(d,d_geometric_soln)
def _calc_optimal_C0(self, solution, start, end): ret_val = C0 anal_sol = -1 / x if C0 in solution.free_symbols: integrand = self._subs_solution(solution) # integrand = solution - anal_sol integrand *= integrand # integrand = integrand.subs({C0: -0.11077}) squared_residual = integrate(integrand, (x, start, end)) # print("total error is ", squared_residual) # assert False det_eq = squared_residual.diff(C0) print('squared res is ') print(det_eq) ans = solveset(det_eq, C0, domain=S.Reals) print("C0 opt vals are: ", ans) ISR_l = lambdify(C0, squared_residual) # print('min error is ', ISR_l(-0.0633790771568749)) # print('min error is ', ISR_l(-0.313647060539033)) # print('min error is ', ISR_l(-0.177974008726031)) assert False pass else: ham_error('HAM_ERROR_CRITICAL', 'CRITICAL__ASSERT_NOT_REACHED') return ret_val
def solve(self) -> Tuple[Rational, Rational, Rational]: x_expression = list( solveset(Eq(self.kernel.dH_dx, 0), self.kernel.x) )[0] y_expression = list( solveset(Eq(self.kernel.dH_dy, 0), self.kernel.y) )[0] y_expression_without_x = y_expression.subs( self.kernel.x, x_expression) y_solution = list( solveset( Eq(y_expression_without_x, self.kernel.y), self.kernel.y ) )[0] x_solution = x_expression.subs(self.kernel.y, y_solution) return x_solution, y_solution, self.kernel.get_value_at_point( x_solution, y_solution )
import sympy as sp if __name__ == "__main__": x, y, z = sp.symbols("x y z") """ [CLS]: 1 element polynomial of 2 degree, 1 equations """ roots = sp.solveset(x**2-x,x) print type(roots), roots #{0, 1} ==> <class 'sympy.sets.sets.FiniteSet'> roots = sp.solveset(x**2 > x**3,x, domain=sp.S.Reals) print type(roots), roots #(-oo, 0) U (0, 1) ==> <class 'sympy.sets.sets.Union'> """ [CLS]:3 elements polynomial of 1 degree, 2 equations """ roots = sp.linsolve([x + y + z - 1, x + y + 2*z - 3 ], (x, y, z)) print type(roots), roots #{(-y - 1, y, 2)} ==> <class 'sympy.sets.sets.FiniteSet'> """ A*x = b Form """ """ [CLS]: the last column is equation constant x + y + z = 1
import sympy as sy def mean(arr): return sum(arr) / len(arr) def std(arr): m = mean(arr) return sy.sqrt(sum((x - m)**sy.S(2) for x in arr) / len(arr)) if __name__ == '__main__': a = [1, 2, 3] n = sy.symbols('n') b = [1, 2, 3, n] target = std(a) curr = std(b) print max(sy.solveset(curr - target, n)).evalf()