def test_separatevars_advanced_factor(): x,y,z = symbols('x,y,z') assert separatevars(1 + log(x)*log(y) + log(x) + log(y)) == (log(x) + 1)*(log(y) + 1) assert separatevars(1 + x - log(z) - x*log(z) - exp(y)*log(z) - x*exp(y)*log(z) + x*exp(y) + exp(y)) == \ -((x + 1)*(log(z) - 1)*(exp(y) + 1)) x, y = symbols('x,y', positive=True) assert separatevars(1 + log(x**log(y)) + log(x*y)) == (log(x) + 1)*(log(y) + 1)
def test_separatevars_advanced_factor(): # If factor() is ever improved to factor non-symbolic expressions, this # should XPASS assert separatevars(1 + log(x)*log(y) + log(x) + log(y)) == (log(x) + 1)*(log(y) + 1) assert separatevars(1 + x - log(z) - x*log(z) - exp(y)*log(z) - \ x*exp(y)*log(z) + x*exp(y) + exp(y)) == \ (1 + x)*(1 - log(z))*(1 + exp(y)) x, y = symbols('xy', positive=True) assert separatevars(1 + log(x**log(y)) + log(x*y)) == (log(x) + 1)*(log(y) + 1)
def test_separatevars(): x,y,z,n = symbols('xyzn') assert separatevars(2*n*x*z+2*x*y*z) == 2*x*z*(n+y) assert separatevars(x*z+x*y*z) == x*z*(1+y) assert separatevars(pi*x*z+pi*x*y*z) == pi*x*z*(1+y) assert separatevars(x*y**2*sin(x) + x*sin(x)*sin(y)) == x*(sin(y) + y**2)*sin(x) assert separatevars(x*exp(x+y)+x*exp(x)) == x*(1 + exp(y))*exp(x) assert separatevars((x*(y+1))**z) == x**z*(1 + y)**z assert separatevars(1+x+y+x*y) == (x+1)*(y+1) assert separatevars(y / pi * exp(-(z - x) / cos(n))) == y * exp((x - z) / cos(n)) / pi # 1759 p=Symbol('p',positive=True) assert separatevars(sqrt(p**2 + x*p**2)) == p*sqrt(1 + x) assert separatevars(sqrt(y*(p**2 + x*p**2))) == p*sqrt(y)*sqrt(1 + x)
def test_separatevars(): x,y,z,n = symbols('xyzn') assert separatevars(2*n*x*z+2*x*y*z) == 2*x*z*(n+y) assert separatevars(x*z+x*y*z) == x*z*(1+y) assert separatevars(pi*x*z+pi*x*y*z) == pi*x*z*(1+y) assert separatevars(x*y**2*sin(x) + x*sin(x)*sin(y)) == x*(sin(y) + y**2)*sin(x) assert separatevars(x*exp(x+y)+x*exp(x)) == x*(1 + exp(y))*exp(x) assert separatevars((x*(y+1))**z) == x**z*(1 + y)**z assert separatevars(1+x+y+x*y) == (x+1)*(y+1)
def _banish(b, x, w, m): if x not in m.free_symbols: return Mul(Expect(b, Lambda(x, w)), m) if m.is_Mul: (w1, m) = unweight(m) separation = separatevars(w1, [x], dict=True) return separation['coeff'] * _banish(b, x, w * separation[x], m) if m.is_Add: return Add(*(_banish(b, x, w, term) for term in m.args)) if isinstance(m, Bind) and x not in m.before.free_symbols: return Bind(m.before, m.variable, _banish(b, x, w, m.after)) raise BanishFailure(x, m)
def _split(ms): ms = sp.sympify(ms) if isinstance(ms, Number): d = {'coeff': ms} elif len(ms.free_symbols) == 0: d = {'coeff': ms.evalf()} else: d = sp.separatevars(ms.factor(), dict=True) if d is None: raise RuntimeError('Could not split', ms) d = defaultdict(lambda: 1, {str(k): v for k, v in d.items()}) dc = d['coeff'] d['coeff'] = int(dc) if isinstance(dc, (sp.Integer, int)) else float(dc) return d
def alap(n): from sympy.integrals.transforms import inverse_laplace_transform from sympy import separatevars import sympy from sympy import simplify from sympy.parsing.sympy_parser import parse_expr x = sympy.Symbol("s", real=True) f = parse_expr(n) f = f.subs({parse_expr("s"): x}) f = inverse_laplace_transform(f, x, 't') f = separatevars(f, force=True) #print(f) f = simplify(f, measure=my_measure1, ratio=10) return str(f)
def _straighten(m, k): if m.is_Add: if add: return Add(*(_straighten(term, k) for term in m.args)) else: m = Add(*(_straighten(term, Ret) for term in m.args)) # fall through if m.is_zero: return S.Zero if isinstance(m, Ret): return k(m.value) if m.is_Mul: (w, m) = unweight(m) return w * _straighten(m, k) if isinstance(m, Bind): (x, after) = m.enter([k]) (w, afterk) = unweight(_straighten(after, k)) separation = separatevars(w, [x], dict=True) return separation['coeff'] * _straighten(m.before, Lambda(x, separation[x] * afterk)) if k == Ret: return m r = parameter(k, 'r') return Bind(m, r, k(r))
# module 3 Separation of Variables # part 1 Method of Substitution import sympy from sympy.abc import t print sympy.integrate(sympy.cos(t**2), t) print sympy.integrate(sympy.cos(t**2) * 2 * t, t) # ex1 from sympy.abc import x print sympy.integrate((4 * x) / (1 + 4 * x**2), x) # part 2 separable equations from sympy.abc import y f = -2 * t * y**2 print sympy.separatevars(f, symbols=(t, y)) print sympy.separatevars(y**3 + t**2, symbols=(t, y)) # ex2 print sympy.separatevars(t * y + t * y**2, symbols=(t, y)) print sympy.separatevars(t**2 * y + t * y**2, symbols=(t, y)) # ex3 # ex4 from sympy import Function, dsolve, Derivative y = Function('y') dsolve(Derivative(y(t), t) - 2 * t * (y(t))**2 - 3 * (y(t))**2, y(t))
def test_separatevars(): x, y, z, n = symbols('x,y,z,n') assert separatevars(2 * n * x * z + 2 * x * y * z) == 2 * x * z * (n + y) assert separatevars(x * z + x * y * z) == x * z * (1 + y) assert separatevars(pi * x * z + pi * x * y * z) == pi * x * z * (1 + y) assert separatevars(x*y**2*sin(x) + x*sin(x)*sin(y)) == \ x*(sin(y) + y**2)*sin(x) assert separatevars(x * exp(x + y) + x * exp(x)) == x * (1 + exp(y)) * exp(x) assert separatevars((x * (y + 1))**z).is_Pow # != x**z*(1 + y)**z assert separatevars(1 + x + y + x * y) == (x + 1) * (y + 1) assert separatevars(y/pi*exp(-(z - x)/cos(n))) == \ y*exp(x/cos(n))*exp(-z/cos(n))/pi assert separatevars((x + y) * (x - y) + y**2 + 2 * x + 1) == (x + 1)**2 # issue 4858 p = Symbol('p', positive=True) assert separatevars(sqrt(p**2 + x * p**2)) == p * sqrt(1 + x) assert separatevars(sqrt(y * (p**2 + x * p**2))) == p * sqrt(y * (1 + x)) assert separatevars(sqrt(y*(p**2 + x*p**2)), force=True) == \ p*sqrt(y)*sqrt(1 + x) # issue 4865 assert separatevars(sqrt(x * y)).is_Pow assert separatevars(sqrt(x * y), force=True) == sqrt(x) * sqrt(y) # issue 4957 # any type sequence for symbols is fine assert separatevars(((2*x + 2)*y), dict=True, symbols=()) == \ {'coeff': 1, x: 2*x + 2, y: y} # separable assert separatevars(((2*x + 2)*y), dict=True, symbols=[x]) == \ {'coeff': y, x: 2*x + 2} assert separatevars(((2*x + 2)*y), dict=True, symbols=[]) == \ {'coeff': 1, x: 2*x + 2, y: y} assert separatevars(((2*x + 2)*y), dict=True) == \ {'coeff': 1, x: 2*x + 2, y: y} assert separatevars(((2*x + 2)*y), dict=True, symbols=None) == \ {'coeff': y*(2*x + 2)} # not separable assert separatevars(3, dict=True) is None assert separatevars(2 * x + y, dict=True, symbols=()) is None assert separatevars(2 * x + y, dict=True) is None assert separatevars(2 * x + y, dict=True, symbols=None) == { 'coeff': 2 * x + y } # issue 4808 n, m = symbols('n,m', commutative=False) assert separatevars(m + n * m) == (1 + n) * m assert separatevars(x + x * n) == x * (1 + n) # issue 4910 f = Function('f') assert separatevars(f(x) + x * f(x)) == f(x) + x * f(x) # a noncommutable object present eq = x * (1 + hyper((), (), y * z)) assert separatevars(eq) == eq
def test_separatevars(): x, y, z, n = symbols('x,y,z,n') assert separatevars(2*n*x*z + 2*x*y*z) == 2*x*z*(n + y) assert separatevars(x*z + x*y*z) == x*z*(1 + y) assert separatevars(pi*x*z + pi*x*y*z) == pi*x*z*(1 + y) assert separatevars(x*y**2*sin(x) + x*sin(x)*sin(y)) == \ x*(sin(y) + y**2)*sin(x) assert separatevars(x*exp(x + y) + x*exp(x)) == x*(1 + exp(y))*exp(x) assert separatevars((x*(y + 1))**z).is_Pow # != x**z*(1 + y)**z assert separatevars(1 + x + y + x*y) == (x + 1)*(y + 1) assert separatevars(y/pi*exp(-(z - x)/cos(n))) == \ y*exp(x/cos(n))*exp(-z/cos(n))/pi assert separatevars((x + y)*(x - y) + y**2 + 2*x + 1) == (x + 1)**2 # issue 4858 p = Symbol('p', positive=True) assert separatevars(sqrt(p**2 + x*p**2)) == p*sqrt(1 + x) assert separatevars(sqrt(y*(p**2 + x*p**2))) == p*sqrt(y*(1 + x)) assert separatevars(sqrt(y*(p**2 + x*p**2)), force=True) == \ p*sqrt(y)*sqrt(1 + x) # issue 4865 assert separatevars(sqrt(x*y)).is_Pow assert separatevars(sqrt(x*y), force=True) == sqrt(x)*sqrt(y) # issue 4957 # any type sequence for symbols is fine assert separatevars(((2*x + 2)*y), dict=True, symbols=()) == \ {'coeff': 1, x: 2*x + 2, y: y} # separable assert separatevars(((2*x + 2)*y), dict=True, symbols=[x]) == \ {'coeff': y, x: 2*x + 2} assert separatevars(((2*x + 2)*y), dict=True, symbols=[]) == \ {'coeff': 1, x: 2*x + 2, y: y} assert separatevars(((2*x + 2)*y), dict=True) == \ {'coeff': 1, x: 2*x + 2, y: y} assert separatevars(((2*x + 2)*y), dict=True, symbols=None) == \ {'coeff': y*(2*x + 2)} # not separable assert separatevars(3, dict=True) is None assert separatevars(2*x + y, dict=True, symbols=()) is None assert separatevars(2*x + y, dict=True) is None assert separatevars(2*x + y, dict=True, symbols=None) == {'coeff': 2*x + y} # issue 4808 n, m = symbols('n,m', commutative=False) assert separatevars(m + n*m) == (1 + n)*m assert separatevars(x + x*n) == x*(1 + n) # issue 4910 f = Function('f') assert separatevars(f(x) + x*f(x)) == f(x) + x*f(x) # a noncommutable object present eq = x*(1 + hyper((), (), y*z)) assert separatevars(eq) == eq
def test_separatevars(): x, y, z, n = symbols('x,y,z,n') assert separatevars(2 * n * x * z + 2 * x * y * z) == 2 * x * z * (n + y) assert separatevars(x * z + x * y * z) == x * z * (1 + y) assert separatevars(pi * x * z + pi * x * y * z) == pi * x * z * (1 + y) assert separatevars(x * y**2 * sin(x) + x * sin(x) * sin(y)) == x * (sin(y) + y**2) * sin(x) assert separatevars(x * exp(x + y) + x * exp(x)) == x * (1 + exp(y)) * exp(x) assert separatevars((x * (y + 1))**z).is_Pow # != x**z*(1 + y)**z assert separatevars(1 + x + y + x * y) == (x + 1) * (y + 1) assert separatevars(y / pi * exp(-(z - x) / cos(n))) == y * exp( (x - z) / cos(n)) / pi # 1759 p = Symbol('p', positive=True) assert separatevars(sqrt(p**2 + x * p**2)) == p * sqrt(1 + x) assert separatevars(sqrt(y * (p**2 + x * p**2))) == p * sqrt(y * (1 + x)) assert separatevars(sqrt(y * (p**2 + x * p**2)), force=True) == p * sqrt(y) * sqrt(1 + x) # 1766 assert separatevars(sqrt(x * y)).is_Pow assert separatevars(sqrt(x * y), force=True) == sqrt(x) * sqrt(y) # 1858 # any type sequence for symbols is fine assert separatevars(((2 * x + 2) * y), dict=True, symbols=()) == { 'coeff': 2, x: x + 1, y: y } # separable assert separatevars(((2 * x + 2) * y), dict=True, symbols=[]) == { 'coeff': 2, x: x + 1, y: y } assert separatevars(((2 * x + 2) * y), dict=True) == { 'coeff': 2, x: x + 1, y: y } assert separatevars(((2 * x + 2) * y), dict=True, symbols=None) == { 'coeff': 2 * y * (x + 1) } # not separable assert separatevars(2 * x + y, dict=True, symbols=()) is None assert separatevars(2 * x + y, dict=True) is None assert separatevars(2 * x + y, dict=True, symbols=None) == { 'coeff': 2 * x + y }
display(p_s_mu) display(syp.nsimplify(p_dmu_mu)) display(pF) # %% F = -log(pF[0]) - C F = F.expand(force=True) F = F.collect(sigma_s) F = F.collect(Sigma_x) F = syp.nsimplify(F) display(F) # %% gd_mux = Eq(-diff("F", mux, evaluate=False), -syp.separatevars(diff(F, mux), force=True), evaluate=False) display(gd_mux) print(syp.latex(gd_mux)) # %% d_dmux = Eq(-diff("F", dmux, evaluate=False), -diff(F, dmux).simplify(), evaluate=False) display(d_dmux) print(syp.latex(d_dmux)) # %% a = symbols("a", real=True) sa = syp.Function("s")(a) F = F.subs(s, sa)
def get_order(fn): seper = sp.separatevars(fn,(v_xsnorm,v_ysnorm),dict=True) res = (seper[v_xsnorm] * seper[v_ysnorm]).subs(v_xsnorm,2).subs(v_ysnorm,2.0001) return res
print("Calculating Taylor expansion...") f_approx = Taylor_polynomial_sympy(f_exact, (v_xsnorm,v_ysnorm), (0,0), order) def get_order(fn): seper = sp.separatevars(fn,(v_xsnorm,v_ysnorm),dict=True) res = (seper[v_xsnorm] * seper[v_ysnorm]).subs(v_xsnorm,2).subs(v_ysnorm,2.0001) return res print("Sorting...") f_approx_sum = list(f_approx.args) f_approx_sum.sort(key=get_order) f_approx_all = [sp.separatevars(fn,(v_xsnorm,v_ysnorm),dict=True) for fn in f_approx_sum] print("Simplifying...") for i in range(len(f_approx_all)): f_approx_all[i][v_xsnorm] *= f_approx_all[i][v_ysnorm] f_approx_all[i][v_xsnorm] = sp.simplify(f_approx_all[i][v_xsnorm]) f_approx_all[i]["coeff"] = sp.simplify(f_approx_all[i]["coeff"]) print("Reducing...") for i in range(len(f_approx_all)): j = i while j<len(f_approx_all): if i!=j and i<len(f_approx_all) and j<len(f_approx_all): c = f_approx_all[j]["coeff"] / f_approx_all[i]["coeff"] if c.is_constant(): c = sp.simplify(c)
def test_separatevars(): x,y,z,n = symbols('x,y,z,n') assert separatevars(2*n*x*z+2*x*y*z) == 2*x*z*(n+y) assert separatevars(x*z+x*y*z) == x*z*(1+y) assert separatevars(pi*x*z+pi*x*y*z) == pi*x*z*(1+y) assert separatevars(x*y**2*sin(x) + x*sin(x)*sin(y)) == x*(sin(y) + y**2)*sin(x) assert separatevars(x*exp(x+y)+x*exp(x)) == x*(1 + exp(y))*exp(x) assert separatevars((x*(y+1))**z).is_Pow # != x**z*(1 + y)**z assert separatevars(1+x+y+x*y) == (x+1)*(y+1) assert separatevars(y / pi * exp(-(z - x) / cos(n))) == y * exp((x - z) / cos(n)) / pi # 1759 p=Symbol('p',positive=True) assert separatevars(sqrt(p**2 + x*p**2)) == p*sqrt(1 + x) assert separatevars(sqrt(y*(p**2 + x*p**2))) == p*sqrt(y*(1 + x)) assert separatevars(sqrt(y*(p**2 + x*p**2)), force=True) == p*sqrt(y)*sqrt(1 + x) # 1766 assert separatevars(sqrt(x*y)).is_Pow assert separatevars(sqrt(x*y), force=True) == sqrt(x)*sqrt(y) # 1858 # any type sequence for symbols is fine assert separatevars(((2*x+2)*y), dict=True, symbols=()) == {'coeff': 2, x: x + 1, y: y} # separable assert separatevars(((2*x+2)*y), dict=True, symbols=[]) == {'coeff': 2, x: x + 1, y: y} assert separatevars(((2*x+2)*y), dict=True) == {'coeff': 2, x: x + 1, y: y} assert separatevars(((2*x+2)*y), dict=True, symbols=None) == {'coeff': 2*y*(x + 1)} # not separable assert separatevars(2*x+y, dict=True, symbols=()) is None assert separatevars(2*x+y, dict=True) is None assert separatevars(2*x+y, dict=True, symbols=None) == {'coeff': 2*x + y}
def test_separatevars(): x, y, z, n = symbols("x,y,z,n") assert separatevars(2 * n * x * z + 2 * x * y * z) == 2 * x * z * (n + y) assert separatevars(x * z + x * y * z) == x * z * (1 + y) assert separatevars(pi * x * z + pi * x * y * z) == pi * x * z * (1 + y) assert separatevars(x * y**2 * sin(x) + x * sin(x) * sin(y)) == x * (sin(y) + y**2) * sin(x) assert separatevars(x * exp(x + y) + x * exp(x)) == x * (1 + exp(y)) * exp(x) assert separatevars((x * (y + 1))**z).is_Pow # != x**z*(1 + y)**z assert separatevars(1 + x + y + x * y) == (x + 1) * (y + 1) assert (separatevars(y / pi * exp(-(z - x) / cos(n))) == y * exp(x / cos(n)) * exp(-z / cos(n)) / pi) assert separatevars((x + y) * (x - y) + y**2 + 2 * x + 1) == (x + 1)**2 # issue 4858 p = Symbol("p", positive=True) assert separatevars(sqrt(p**2 + x * p**2)) == p * sqrt(1 + x) assert separatevars(sqrt(y * (p**2 + x * p**2))) == p * sqrt(y * (1 + x)) assert separatevars(sqrt(y * (p**2 + x * p**2)), force=True) == p * sqrt(y) * sqrt(1 + x) # issue 4865 assert separatevars(sqrt(x * y)).is_Pow assert separatevars(sqrt(x * y), force=True) == sqrt(x) * sqrt(y) # issue 4957 # any type sequence for symbols is fine assert separatevars(((2 * x + 2) * y), dict=True, symbols=()) == { "coeff": 1, x: 2 * x + 2, y: y, } # separable assert separatevars(((2 * x + 2) * y), dict=True, symbols=[x]) == { "coeff": y, x: 2 * x + 2, } assert separatevars(((2 * x + 2) * y), dict=True, symbols=[]) == { "coeff": 1, x: 2 * x + 2, y: y, } assert separatevars(((2 * x + 2) * y), dict=True) == { "coeff": 1, x: 2 * x + 2, y: y, } assert separatevars(((2 * x + 2) * y), dict=True, symbols=None) == { "coeff": y * (2 * x + 2) } # not separable assert separatevars(3, dict=True) is None assert separatevars(2 * x + y, dict=True, symbols=()) is None assert separatevars(2 * x + y, dict=True) is None assert separatevars(2 * x + y, dict=True, symbols=None) == { "coeff": 2 * x + y } # issue 4808 n, m = symbols("n,m", commutative=False) assert separatevars(m + n * m) == (1 + n) * m assert separatevars(x + x * n) == x * (1 + n) # issue 4910 f = Function("f") assert separatevars(f(x) + x * f(x)) == f(x) + x * f(x) # a noncommutable object present eq = x * (1 + hyper((), (), y * z)) assert separatevars(eq) == eq s = separatevars(abs(x * y)) assert s == abs(x) * abs(y) and s.is_Mul z = cos(1)**2 + sin(1)**2 - 1 a = abs(x * z) s = separatevars(a) assert not a.is_Mul and s.is_Mul and s == abs(x) * abs(z) s = separatevars(abs(x * y * z)) assert s == abs(x) * abs(y) * abs(z) # abs(x+y)/abs(z) would be better but we test this here to # see that it doesn't raise assert separatevars(abs((x + y) / z)) == abs((x + y) / z)
def define_px_poly_eqn( self, eta_choice: Rational = None, do_ndim: bool = False ) -> None: r""" Define :math:`p_x` polynomial. TODO: remove ref to xiv_0 Define polynomial form of function combining normal-slowness covector components :math:`(p_x,p_z)` (where the latter is given in terms of the vertical erosion rate :math:`\xi^{\downarrow} = -\dfrac{1}{p_z}`) and the erosion model flow component :math:`\varphi(\mathbf{r})` Args: eta_choice (:class:`~sympy.core.numbers.Rational`): value of :math:`\eta` to use instead value given at instantiation; otherwise the latter value is used Attributes: poly_px_xiv_varphi_eqn (:class:`~sympy.polys.polytools.Poly`): :math:`\operatorname{Poly}{\left( \left(\xi^{\downarrow}\right)^{4} \varphi^{4}{\left(\mathbf{r} \right)} p_{x}^{6} - \left(\xi^{\downarrow}\right)^{4} p_{x}^{2} - \left(\xi^{\downarrow}\right)^{2}, p_{x}, domain=\mathbb{Z}\left[\varphi{\left(\mathbf{r} \right)}, \xi^{\downarrow}\right] \right)}` poly_px_xiv_eqn (:class:`~sympy.core.relational.Equality`): :math:`\varphi_0^{4} \left(\xi^{\downarrow{0}}\right)^{4} p_{x}^{6} \left(\varepsilon + \left(\frac{x_{1} - {r}^x}{x_{1}}\right)^{2 \mu}\right)^{4} - \left(\xi^{\downarrow{0}}\right)^{4} p_{x}^{2} - \left(\xi^{\downarrow{0}}\right)^{2} = 0` """ logging.info(f"gme.core.pxpoly.define_px_poly_eqn (ndim={do_ndim})") if do_ndim: # Non-dimensionalized version varphi0_solns = solve( self.sinCi_xih0_eqn.subs({eta: eta_choice}), varphi_0 ) varphi0_eqn = Eq(varphi_0, varphi0_solns[0]) if eta_choice is not None and eta_choice <= 1: tmp_eqn = separatevars( simplify( self.px_xiv_varphi_eqn.subs({eta: eta_choice}) .subs({varphi_r(rvec): self.varphi_rxhat_eqn.rhs}) .subs(e2d(self.px_pxhat_eqn)) .subs(e2d(varphi0_eqn)) ) ) self.poly_pxhat_xiv_eqn = simplify( Eq( ( numer(tmp_eqn.lhs) - denom(tmp_eqn.lhs) * (tmp_eqn.rhs) ) / xiv ** 2, 0, ) ) self.poly_pxhat_xiv0_eqn = self.poly_pxhat_xiv_eqn.subs( {xiv: xiv_0} ).subs(e2d(self.xiv0_xih0_Ci_eqn)) else: tmp_eqn = separatevars( simplify( self.px_xiv_varphi_eqn.subs({eta: eta_choice}) .subs({varphi_r(rvec): self.varphi_rxhat_eqn.rhs}) .subs(e2d(self.px_pxhat_eqn)) .subs(e2d(varphi0_eqn)) ) ) self.poly_pxhat_xiv_eqn = simplify( Eq( ( numer(tmp_eqn.lhs) - denom(tmp_eqn.lhs) * (tmp_eqn.rhs) ) / xiv ** 2, 0, ) ) self.poly_pxhat_xiv0_eqn = simplify( Eq( self.poly_pxhat_xiv_eqn.lhs.subs({xiv: xiv_0}).subs( e2d(self.xiv0_xih0_Ci_eqn) ) / xih_0 ** 2, 0, ) ) else: # Dimensioned version tmp_eqn = simplify(self.px_xiv_varphi_eqn.subs({eta: eta_choice})) if eta_choice is not None and eta_choice <= 1: self.poly_px_xiv_varphi_eqn = poly(tmp_eqn.lhs, px) else: self.poly_px_xiv_varphi_eqn = poly( numer(tmp_eqn.lhs) - denom(tmp_eqn.lhs) * (tmp_eqn.rhs), px ) self.poly_px_xiv_eqn = Eq( self.poly_px_xiv_varphi_eqn.subs(e2d(self.varphi_rx_eqn)), 0 )