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.
                        
                                                          
                        (4/-1) X (x + 2y - z = 2)
                            ⇒    
                        -4x - 8y + 4z = -8
                                                          
                        (4/2) X (3x - y + 2z = 4)
                            ⇒    
                        6x - 2y + 4z = 8
                                                          
                        (4/4) 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();
            
            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];
            
            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
            {
                
                double[] partial_solution;
                partial_solution = (new Simultaneous2Unknown(new_x, new_y, new_eq)).solveSimultaneous();
                x_variable = partial_solution[0];
                y_variable = partial_solution[1];
                
                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");
            
            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] = '+'; 
                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");
            
            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)");
            }
        }
    }
}