Robust simplification

[Alexander Lindsay]

I have this short code that solves for an expression I need to input into a finite element code. The simpler the expression the better. The code is here:

from sympy import *

r_e, a, mu_el, E, n, epsilon, n_gamma, epsilon_gamma, v_th, Gamma_p, mu_e, gamma_p, n_alpha, epsilon_alpha, Gamma_e, mu_i, b, n_i, v_ith, bob, e, A, R, V_bat, u = symbols('r_e a mu_el E n epsilon n_gamma epsilon_gamma v_th Gamma_p mu_e gamma_p n_alpha epsilon_alpha Gamma_e mu_i b n_i v_ith bob e A R V_bat u')

Gamma_e = (1 - r_e) / (1 + r_e) * (-(2 * a -1) * mu_e * E * n_alpha + v_th * 1 / 2 * n_alpha) - (1 - a) * gamma_p * Gamma_p
Gamma_e = Gamma_e.subs(n_alpha, n - n_gamma)
Gamma_e = Gamma_e.subs(Gamma_p, (1 - r_e) / (1 + r_e) * ((2 * b - 1) * mu_i * E * n_i + v_ith * 1 / 2 * n_i))
Gamma_p = (1 - r_e) / (1 + r_e) * ((2 * b - 1) * mu_i * E * n_i + v_ith * 1 / 2 * n_i)
J_tot = simplify(e * Gamma_p - e * Gamma_e)
soln = solve(V_bat + u - J_tot * A * R, E, dict=True)
Gamma_eps = simplify(soln[0][E])
factored = Gamma_eps.factor()

print Gamma_eps
# Output: (-A*R*a*e*gamma_p*n_i*r_e*v_ith + A*R*a*e*gamma_p*n_i*v_ith + A*R*e*gamma_p*n_i*r_e*v_ith - A*R*e*gamma_p*n_i*v_ith - A*R*e*n*r_e*v_th + A*R*e*n*v_th + A*R*e*n_gamma*r_e*v_th - A*R*e*n_gamma*v_th + A*R*e*n_i*r_e*v_ith - A*R*e*n_i*v_ith + 2*V_bat*r_e + 2*V_bat + 2*r_e*u + 2*u)/(2*A*R*e*(2*a*b*gamma_p*mu_i*n_i*r_e - 2*a*b*gamma_p*mu_i*n_i - a*gamma_p*mu_i*n_i*r_e + a*gamma_p*mu_i*n_i - 2*a*mu_e*n*r_e + 2*a*mu_e*n + 2*a*mu_e*n_gamma*r_e - 2*a*mu_e*n_gamma - 2*b*gamma_p*mu_i*n_i*r_e + 2*b*gamma_p*mu_i*n_i - 2*b*mu_i*n_i*r_e + 2*b*mu_i*n_i + gamma_p*mu_i*n_i*r_e - gamma_p*mu_i*n_i + mu_e*n*r_e - mu_e*n - mu_e*n_gamma*r_e + mu_e*n_gamma + mu_i*n_i*r_e - mu_i*n_i))
print factored
# Output: (-A*R*a*e*gamma_p*n_i*r_e*v_ith + A*R*a*e*gamma_p*n_i*v_ith + A*R*e*gamma_p*n_i*r_e*v_ith - A*R*e*gamma_p*n_i*v_ith - A*R*e*n*r_e*v_th + A*R*e*n*v_th + A*R*e*n_gamma*r_e*v_th - A*R*e*n_gamma*v_th + A*R*e*n_i*r_e*v_ith - A*R*e*n_i*v_ith + 2*V_bat*r_e + 2*V_bat + 2*r_e*u + 2*u)/(2*A*R*e*(r_e - 1)*(2*a*b*gamma_p*mu_i*n_i - a*gamma_p*mu_i*n_i - 2*a*mu_e*n + 2*a*mu_e*n_gamma - 2*b*gamma_p*mu_i*n_i - 2*b*mu_i*n_i + gamma_p*mu_i*n_i + mu_e*n - mu_e*n_gamma + mu_i*n_i))

As it stands now Gamma_eps is a very long expression with a lot of terms that should be readily factorable. However, a naive application of the factor() method at the end does one factorization in the denominator and that's it. Clearly I'm a noobie here and I'm going to do some research on my own to see whether I can make this work, but do others have some quick suggestions for how I might reduce this expression, say with minimizing the number of operations as the goal criterion?

Alex

[Aaron Meurer]

If you want to pull out common terms you should use collect(). factor() only performs complete factorizations (meaning the result should be a product of polynomials).

Aaron Meurer

--
You received this message because you are subscribed to the Google Groups "sympy" group.
To unsubscribe from this group and stop receiving emails from it, send an email to sympy+un...@googlegroups.com.
To post to this group, send email to sy...@googlegroups.com.
Visit this group at https://groups.google.com/group/sympy.
To view this discussion on the web visit https://groups.google.com/d/msgid/sympy/c9eb95f7-7984-4246-99ce-9c8b5129e47d%40googlegroups.com.
For more options, visit https://groups.google.com/d/optout.

[Chris Smith]

You can also try the function `cse`; there may be a post-processor that will put the code in python form (but I am not sure).