Solving Simultaneous Equations With 3 Unknowns in C#

Solving Simultaneous Equations in C#: A Junior Secondary Guide

Welcome to this junior secondary C# math project! In this tutorial, you'll learn how to solve simultaneous equations with three unknowns using C#. This is a great way to combine your coding skills with algebra and logic.
You'll also learn the following:

How to use C# to solve 3x3 simultaneous equations
Applying the elimination method step-by-step
Using LCM (Least Common Multiple) to simplify equations
Writing a C# class to automate the solving process

Solving equations is a key part of algebra. By coding the solution in C#, you'll not only understand the math better; you'll also build a useful tool. This project is perfect for students looking to explore C# math algorithms, or teachers seeking C# algebra exercises for the classroom.

How to Solve Three-Variable Algebra Problems | Maths Explanation for C# Kids

To solve 3 by 3 simultaneous equations, we will simply eliminate the z variable, then call out to our C# Code for Simultaneous Equations with 2 Unknowns module.

Step-by-Step Guide to Solve Three-Variable Algebra Equations | Elimination Method C# Algorithm

Let's try to draft a C# algorithm that solves simultaneous equations with 2 unknowns, using the elimination method, with the following set of equations in consideration.
         x + 2y - z = 2; and
         3x - y + 2z = 4
         2x + 3y + 4z = 9
These steps will help the student understand both the math and the logic behind the code.

Step 1:

Using the Find LCM in C# class from the Primary Category, find the LCM of the coefficients of variable z. 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 C# Code for Simultaneous Equations with 2 Unknowns 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 C# class file; call it Simultaneous3Unknown.
Type out the adjoining C# code for solving simultaneous equations with 3 unknowns.

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

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

So! C# Fun Practice Exercise - Simultaneous Equations with 3 Unknowns

As a fun practice exercise, feel free to try out your own set of x_coefficients, y_coefficients and equals values, and see how the C# code solves the resulting 3x3 Simultaneous Equations.

C# Code for Solving Simultaneous Equations with 3 Unknowns - Class File

using System;
using System.Collections.Generic;

namespace Algebra
{
    class Simultaneous3Unknown
    {
        private int[] x_coefficients;
        private int[] y_coefficients;
        private int[] z_coefficients;
        private int[] equals;
        private 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()
        {
            int lcm;
            List<int> stooge = new List<int>();
            foreach (int z in z_coefficients)
            {
                stooge.Add(Math.Abs(z));
            }
            LCM l_c_m = new LCM(stooge);
            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 = (equals[0] - x_coefficients[0] * x_variable - y_coefficients[0] * y_variable) / z_coefficients[0];
            }
            catch (Exception e)
            {
                throw e;
            }
            return new double[] { x_variable, y_variable, z_variable };
        }
    }
}

C# Code for Solving Simultaneous Equations with 3 Unknowns - Main Class

using System;
using System.Collections.Generic;

namespace Algebra
{
    class Program
    {
        static void Main(string[] args)
        {
            Console.WriteLine("Welcome to our demonstration sequels");
            Console.WriteLine("Hope you enjoy (and follow) the lessons.");
            Console.WriteLine("\r\n");

            /*
                * Simultaneous Equations with 3 unknowns
             */
            char[, ] operate = new char[3, 2];

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

            for (int i = 0; i < 3; i++)
            {
                operate[i, 0] = '+'; // lazy if..else
                if (y_coeff[i] < 0)
                {
                    operate[i, 0] = '-';
                }
                operate[i, 1] = '+';
                if (z_coeff[i] < 0)
                {
                    operate[i, 1] = '-';
                }
            }

            Console.WriteLine("\r\n    Solving simultaneously the equations:\r\n");
            //Print as an equation
            Console.WriteLine(String.Format("{0,20}x  {1}  {2}y  {3}  {4}z  =  {5}",
                    x_coeff[0], operate[0, 0], Math.Abs(y_coeff[0]),
                    operate[0, 1], Math.Abs(z_coeff[0]), equals[0]
                )
            );
            Console.WriteLine(String.Format("{0,20}x  {1}  {2}y  {3}  {4}z  =  {5}",
                    x_coeff[1], operate[1, 0], Math.Abs(y_coeff[1]),
                    operate[1, 1], Math.Abs(z_coeff[1]), equals[1]
                )
            );
            Console.WriteLine(String.Format("{0,20}x  {1}  {2}y  {3}  {4}z  =  {5}",
                    x_coeff[2], operate[2, 0], Math.Abs(y_coeff[2]),
                    operate[2, 1], Math.Abs(z_coeff[2]), equals[2]
                )
            );
            Console.WriteLine(Environment.NewLine);
            Console.Write(String.Format("{0,15} {1}{2,20}", "Yields:", "\r\n", "(x, y, z)  =  "));

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

                Console.Write(String.Format("({0:0.0000}, {1:0.0000}, {2:0.0000})", result3D[0], result3D[1], result3D[2]));

            }
            catch (Exception)
            {
                Console.Write("(infinity,  infinity, infinity)");
            }

        }
    }
}

I have a better version / See other versions.