Simultaneous Equations With 3 Unknowns in Java

3 by 3 Simultaneous Equations Code in Java

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 Java

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 class file; call it Simultaneous3Unknown.
Type out the adjoining Java 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 Java 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.

Java code for Simultaneous3Unknown class file

package algebra;

import java.util.Arrays;
import java.util.List;

public class Simultaneous3Unknown {

    private final int[] x_coefficients;
    private final int[] y_coefficients;
    private final int[] z_coefficients;
    private final int[] equals;
    private final double[][] eliminator;
    private double x_variable;
    private double y_variable;
    private double z_variable;

    public Simultaneous3Unknown(int[] x_coeff, int[] y_coeff, int[] z_coeff, int[] eq) {
        x_coefficients = new int[]{x_coeff[0], x_coeff[1], x_coeff[2]};
        y_coefficients = new int[]{y_coeff[0], y_coeff[1], y_coeff[2]};
        z_coefficients = new int[]{z_coeff[0], z_coeff[1], z_coeff[2]};
        equals = new int[]{eq[0], eq[1], eq[2]};
        eliminator = new double[3][3];
    }

    public double[] solveSimultaneous() {
        List<Integer> stooge;
        stooge = Arrays.asList(
                Math.abs(z_coefficients[0]),
                Math.abs(z_coefficients[1]),
                Math.abs(z_coefficients[2])
        );

        LCM l_c_m = new LCM(stooge);
        int lcm = l_c_m.getLCM();

        // STEP 1:
        eliminator[0][0] = (lcm * x_coefficients[0]) / z_coefficients[0];
        eliminator[0][1] = (lcm * y_coefficients[0]) / z_coefficients[0];
        eliminator[0][2] = (lcm * equals[0]) / z_coefficients[0];

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

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

        // STEP 2:
        double[] new_x = {
            eliminator[0][0] - eliminator[1][0],
            eliminator[1][0] - eliminator[2][0]
        };
        double[] new_y = {
            eliminator[0][1] - eliminator[1][1],
            eliminator[1][1] - eliminator[2][1]
        };
        double[] new_eq = {
            eliminator[0][2] - eliminator[1][2],
            eliminator[1][2] - eliminator[2][2]
        };

        try {
            // STEP 3:
            double[] partial_solution;
            partial_solution = (new Simultaneous2Unknown(new_x, new_y, new_eq)).solveSimultaneous();

            x_variable = partial_solution[0];
            y_variable = partial_solution[1];
            // STEP 4:
            z_variable = (double)(equals[0] - x_coefficients[0] * x_variable - y_coefficients[0] * y_variable) / z_coefficients[0];
        } catch (ArithmeticException e) {
            throw e;
        }
        return new double[]{x_variable, y_variable, z_variable};
    }
}

main class

package algebra;

import java.util.Arrays;

public class Algebra {

    public static void main(String[] args) {

        System.out.println("Welcome to our demonstration sequels");
        System.out.println("Hope you enjoy (and follow) the lessons.");
        System.out.println("\n");

        int[] x_coeff;
        int[] y_coeff;
        int[] z_coeff;
        int[] equals;

        /*
        * Simultaneous Equations with 3 unknowns
         */
        char[][] operators = new char[3][2];
        for (char[] op : operators) {
            Arrays.fill(op, '+');
        }

        double[] result3D;
        x_coeff = new int[]{2, 4, 2};
        y_coeff = new int[]{1, -1, 3};
        z_coeff = new int[]{1, -2, -8};
        equals = new int[]{4, 1, -3};

        for (int i = 0; i < 3; i++) {
            if (y_coeff[i] < 0) {
                operators[i][0] = '-';
            }
            if (z_coeff[i] < 0) {
                operators[i][1] = '-';
            }
        }

        System.out.println("Solving simultaneously the equations:");
        //Print as an equation
        System.out.printf(
                "%40dx %s %dy %s %dz = %d%n", x_coeff[0], operators[0][0],
                Math.abs(y_coeff[0]), operators[0][1], Math.abs(z_coeff[0]), equals[0]
        );
        System.out.printf(
                "%40dx %s %dy %s %dz = %d%n", x_coeff[1], operators[1][0],
                Math.abs(y_coeff[1]), operators[1][1], Math.abs(z_coeff[1]), equals[1]
        );
        System.out.printf(
                "%40dx %s %dy %s %dz = %d%n", x_coeff[2], operators[2][0],
                Math.abs(y_coeff[2]), operators[2][1], Math.abs(z_coeff[2]), equals[2]
        );
        System.out.printf("%n%30s%n%40s", "Yields:", "(x, y, z)  =  ");

        try {
            Simultaneous3Unknown sim3unk;
            sim3unk = new Simultaneous3Unknown(x_coeff, y_coeff, z_coeff, equals);
            result3D = sim3unk.solveSimultaneous();

            System.out.printf("(%.4f, %.4f, %.4f)%n", result3D[0], result3D[1], result3D[2]);

        } catch (ArithmeticException e) {
            System.out.printf("(%s, %s, %s)%n", "∞", "∞", "∞");
        }

    }
}

I have a better version / See other versions.