Simultaneous Equations With 3 Unknowns in Python

3 by 3 Simultaneous Equations Code in Python

To solve 3 by 3 simultaneous equations, we will simply eliminate the z variable, then call out to our simultaneous2unknown code module.

Algorithm Steps to Follow for Simultaneous Equations with 3 unknowns in Python

Consider the equations:
         x + 2y - z = 2; and
         3x - y + 2z = 4
         2x + 3y + 4z = 9

Step 1:

Multiply equations 1, 2 & 3 by the LCM of the coefficients of variable z, divided by the z coefficient of the respective equation.
         (⁴/_-1) X (x + 2y - z = 2)
    ⇒     -4x - 8y + 4z = -8
         (⁴/₂) X (3x - y + 2z = 4)
    ⇒     6x - 2y + 4z = 8
         (⁴/₄) X (2x + 3y + 4z = 9)
    ⇒     2x + 3y + 4z = 9

Step 2:

Subtract the new equations obtained in Step 2; eqn (2) from eqn (1) and eqn (3) from eqn (2).
         -4x - 8y + 4z = -8
    -     6x - 2y + 4z = 8
    ⇒     -10x - 6y = -16
         6x - 2y + 4z = 8
    -     2x + 3y + 4z = 9     ⇒     4x - 5y = -1

Step 3:

Call out to our simultaneous2unknown code module to solve for x and y.
⇒ (x, y) = (1, 1);

Step 4:

Obtain z by solving for z from any of the original equations, using the found values of x and y.
         x + 2y - z = 2
⇒         1 + 2(1) - z = 2;
⇒         -z = 2 - 3 = -1;
⇒         z = ^-1/_-1 = 1;

Create a new module file; call it Simultaneous3Unknown.py.
Type out the adjoining Python code for solving simultaneous equations with 3 unknowns.

Note: The code module for finding LCM has been explained in the Primary Category.

You can comment out the Simultaneous2Unknown Python object code in the main class from the previous lesson or simply continue from where it stopped.

So!

Feel free to try out your own set of x_coefficients, y_coefficients, z_coefficients and equals values for 3 by 3 Simultaneous Equations.

Python code for Simultaneous3Unknown Module File

# A class
class Sim3Unknown:

    # A constructor
    def __init__(self, equations):
        self.x_coefficients    = equations['x']
        self.y_coefficients    = equations['y']
        self.z_coefficients    = equations['z']
        self.equals             = equations['eq']

        self.eliminator = [[[], [], []], [[], [], []], [[], [], []]]

    # Returns a list of the result
    def solveSimultaneous(self):
        from LCM import findLCM
        self.l_c_m = findLCM(self.z_coefficients)
        self.lcm = self.l_c_m.getLCM()

        # STEP 1:
        # eliminate z variable
        self.eliminator[0][0] = (self.lcm * self.x_coefficients[0]) / self.z_coefficients[0]
        self.eliminator[0][1] = (self.lcm * self.y_coefficients[0]) / self.z_coefficients[0]
        self.eliminator[0][2] = (self.lcm * self.equals[0])         / self.z_coefficients[0]

        self.eliminator[1][0] = (self.lcm * self.x_coefficients[1]) / self.z_coefficients[1]
        self.eliminator[1][1] = (self.lcm * self.y_coefficients[1]) / self.z_coefficients[1]
        self.eliminator[1][2] = (self.lcm * self.equals[1])         / self.z_coefficients[1]

        self.eliminator[2][0] = (self.lcm * self.x_coefficients[2]) / self.z_coefficients[2]
        self.eliminator[2][1] = (self.lcm * self.y_coefficients[2]) / self.z_coefficients[2]
        self.eliminator[2][2] = (self.lcm * self.equals[2])         / self.z_coefficients[2]

        # STEP 2:
        self.new_x  = [self.eliminator[0][0] - self.eliminator[1][0], self.eliminator[1][0] - self.eliminator[2][0]]
        self.new_y  = [self.eliminator[0][1] - self.eliminator[1][1], self.eliminator[1][1] - self.eliminator[2][1]]
        self.new_eq = [self.eliminator[0][2] - self.eliminator[1][2], self.eliminator[1][2] - self.eliminator[2][2]]

        try:
            # STEP 3
            from Simultaneous2Unknown import Sim2Unknown
            self.s2u = Sim2Unknown({'x':self.new_x, 'y':self.new_y, 'eq':self.new_eq})
            self.partial_solution = self.s2u.solveSimultaneous()

            self.x_variable = self.partial_solution[0]
            self.y_variable = self.partial_solution[1]
            # STEP 4:
            self.z_variable = (self.equals[0] - self.x_coefficients[0] * self.x_variable - self.y_coefficients[0] * self.y_variable) / self.z_coefficients[0]

            return [self.x_variable, self.y_variable, self.z_variable]

        except:
            raise ValueError(None)

Main class

#!/usr/bin/python
from Simultaneous3Unknown import Sim3Unknown

##
# Simultaneous Equations with 3 unknowns
##

x_coefficients = [2, 4, 2]
y_coefficients = [1, -1, 3]
z_coefficients = [1, -2, -8]
equals         = [4, 1, -3]

operators = [[[], []], [[], []], [[], []]]
for i in range(3):
    operators[i][0] = '+'
    if y_coefficients[i] < 0: operators[i][0] = '-'
    operators[i][1] = '+'
    if z_coefficients[i] < 0: operators[i][1] = '-'

print('\n    Solving simultaneously the equations:\n')
#Print as an equation
print(\
    '{:40d}{}  {}  {:d}{}  {}  {:d}{}  {:d}'.format(x_coefficients[0], 'x', operators[0][0],\
    abs(y_coefficients[0]), 'y', operators[0][1], abs(z_coefficients[0]), 'z  =', equals[0])\
)
print(\
    '{:40d}{}  {}  {:d}{}  {}  {:d}{}  {:d}'.format(x_coefficients[1], 'x', operators[1][0],\
    abs(y_coefficients[1]), 'y', operators[1][1], abs(z_coefficients[1]), 'z  =', equals[1])\
)
print(\
    '{:40d}{}  {}  {:d}{}  {}  {:d}{}  {:d}'.format(x_coefficients[2], 'x', operators[2][0],\
    abs(y_coefficients[2]), 'y', operators[2][1], abs(z_coefficients[2]), 'z  =', equals[2])\
)
print('{}{:>30} {}{:>40}'.format('\n', 'Yields:', '\n', '(x, y, z)  =  '), end='')

try:
    sim3unk = Sim3Unknown({'x':x_coefficients, 'y':y_coefficients, 'z':z_coefficients, 'eq':equals})
    solution = sim3unk.solveSimultaneous()

    print('{}{:.4f}{} {:.4f}{} {:.4f}{}'.format('(', solution[0], ',', solution[1], ',', solution[2], ')'))

except: print('{}'.format('(infinity,  infinity, infinity)'))

print('n\n')

I have a better version / See other versions.