Solution System Of Linear Equations In Sympy

Can you please tell me, I need to symbolically solve a system of linear equations using sympy in python. I have programmed the automatic creation of a system of linear equations, t

Solution 1:

this is my full code :

from sympy import exp,symbols
    from sympy import Float,linsolve

    defchis_znam_construct(T,i_eq,n):
    
        En1 = symbols('Eb:' + str(n+1))
        En0 = symbols('Ea:' + str(n+1))
        En2 = symbols('Ec:' + str(n+1))
        mui = symbols('mui:' + str(n+1))
        k = symbols('k')
        chis=0
        znam=0
        i_levels=0
        eq=[]
        varS=[]
        dictvanfleck=dict({})
        dictvanfleck['eq']=[]        
        dictvanfleck['vars']=[]

    defgetvars(f,varS):
        i_var=0while i_var<=(len(f)-1):
            varS.append(f[i_var])
            i_var+=1return varS
    variable=getvars(En0,varS)
    variable=getvars(En1,varS)
    variable=getvars(En2,varS)

    for i_levels inrange(n):
        chis+=((En1[i_levels]**2)/(k*T)- 
              (En2[i_levels]+En2[i_levels]))*exp((En0[i_levels]**2)/(k*T))
        znam+=mui[i_eq]*exp((En0[i_levels]**2)/(k*T))
        i_levels+=1print('')
    print('')
    eq.append(chis-znam)
    dictvanfleck['vars']=variable
    dictvanfleck['eq']=eq
    return dictvanfleck


    defeq_construct(T,n):
        i_eq=0
        eq=[]
        for i_eq inrange(n):
            eq.append(chis_znam_construct(T[i_eq],i_eq,n))
            i_eq+=1return eq 

    print('')
    print('')

    defsolve_eq(T,n):
        equations=eq_construct(T,n)
        eqA=equations[1]
        var=eqA['vars']
        i=0
        equat=[]
        while i<=(n-1):
            eqA=equations[i]
            eqq=eqA['eq']
            equat.append(eqq[0])
            i+=1
        list_eq=str(equat)
        list_var=str(var)
        print('')
        print('list_eq',list_eq)
        print('')
        print('list_var',list_var)
        a = linsolve(list_eq,list_var)
        return a 

    n = 4
    T = symbols('T:' + str(n+1))
    equations=solve_eq(T,n)

Solution 2:

you will laugh, but an error was found: firstly, I made a tuple from list, some of the errors were gone; but the most interesting thing is that when I explicitly set equations and variables, simpi cannot solve the equations :

n = 4
T = sp.symbols('T:' + str(n+1))
Ea0, Ea1, Ea2, Ea3, Ea4, Eb0, Eb1, Eb2, Eb3, Eb4, Ec0, Ec1, Ec2, Ec3, Ec4, T0, T1, T2,
T3, T4, mui0, mui1, mui2, mui3, mui4 = sp.symbols('Ea0, Ea1, Ea2, Ea3, Ea4, Eb0, Eb1,
Eb2, Eb3, Eb4, Ec0, Ec1, Ec2, Ec3, Ec4, T0, T1, T2, T3, T4, mui0, mui1, mui2, mui3,
mui4')

eq_one=sp.Eq(-mui0*exp(Ea0**2/(T0*k)) - mui0*exp(Ea1**2/(T0*k)) - 
mui0*exp(Ea2**2/(T0*k)) - 
mui0*exp(Ea3**2/(T0*k)) + (Eb0**2/(T0*k) - 2*Ec0)*exp(Ea0**2/(T0*k)) + 
(Eb1**2/(T0*k) - 2*Ec1)*exp(Ea1**2/(T0*k)) + (Eb2**2/(T0*k) -
2*Ec2)*exp(Ea2**2/(T0*k)) + 
(Eb3**2/(T0*k) - 2*Ec3)*exp(Ea3**2/(T0*k)))
    
    

eq_two=sp.Eq(-mui1*exp(Ea0**2/(T1*k)) - mui1*exp(Ea1**2/(T1*k)) - 
mui1*exp(Ea2**2/(T1*k)) - mui1*exp(Ea3**2/(T1*k)) + 
(Eb0**2/(T1*k) - 2*Ec0)*exp(Ea0**2/(T1*k)) + (Eb1**2/(T1*k) - 
2*Ec1)*exp(Ea1**2/(T1*k)) + (Eb2**2/(T1*k) - 2*Ec2)*exp(Ea2**2/(T1*k)) + 
(Eb3**2/(T1*k) - 2*Ec3)*exp(Ea3**2/(T1*k)))
     

eq_three=sp.Eq(-mui2*exp(Ea0**2/(T2*k)) - mui2*exp(Ea1**2/(T2*k)) -
mui2*exp(Ea2**2/(T2*k)) - 
mui2*exp(Ea3**2/(T2*k)) + (Eb0**2/(T2*k) - 2*Ec0)*exp(Ea0**2/(T2*k)) + 
(Eb1**2/(T2*k) - 2*Ec1)*exp(Ea1**2/(T2*k)) + (Eb2**2/(T2*k) - 
2*Ec2)*exp(Ea2**2/(T2*k)) + 
(Eb3**2/(T2*k) - 2*Ec3)*exp(Ea3**2/(T2*k)))
     

eq_four=sp.Eq(-mui3*exp(Ea0**2/(T3*k)) - mui3*exp(Ea1**2/(T3*k)) - 
mui3*exp(Ea2**2/(T3*k)) - mui3*exp(Ea3**2/(T3*k)) + (Eb0**2/(T3*k) -
2*Ec0)*exp(Ea0**2/(T3*k)) + 
(Eb1**2/(T3*k) - 2*Ec1)*exp(Ea1**2/(T3*k)) + (Eb2**2/(T3*k) - 
2*Ec2)*exp(Ea2**2/(T3*k)) + 
(Eb3**2/(T3*k) - 2*Ec3)*exp(Ea3**2/(T3*k)))



ans = sp.solve((eq_one, eq_two,eq_three,eq_four), (Ea0, Ea1, Ea2, Ea3))

print('ответ :', ans)

raise NotImplementedError('could not solve %s' % eq2)

NotImplementedError: could not solve ....