A linear system consists of a set of equations with some governing parameters or variables that control the system. The variables that make up the system can be stated in the form of differential equations or autonomous variables. The system works in a dependent manner where changes in one or more variables affect the performance of the whole system in general.

Definition 5.1. An equation in the following form with the unknowns x_i and constants a_i, for i = 1, 2, ..., n, is said to be a linear equation:

Equation 5.1. 

In this definition, each unknown x_i must have an index power of 1. Also, a linear equation cannot have a variable inside sine, cosine, tangent, exponent, logarithm, and other operators. It follows that any equation in the form other than Equation (5.1) is called a nonlinear equation.

The following equations are examples of linear equations:

Equation 5.2. 

A system of linear equations consists of a set of linear equations and a set of unknowns. In general, a system of linear equations with m equations and n unknowns is expressed as follows:

Equation 5.2. 

The above system is represented in matrix form as Ax = b, as follows:

Equation 5.3. 

where A = [a_ij] is the coefficient matrix of the system, for i = 1, 2, ..., m and j = 1, 2, ..., n. In this system, m is the number of rows in the coefficient matrix, whereas n is the number of columns (unknowns). The vector b = [b_i] is the given constants, whereas x = [x_i] is the vector of the unknowns. If b_i = 0 for all i, then the linear system is called a homogeneous system; otherwise, if at least one of b_i ≠ 0, then the system is nonhomogeneous.

In designing computer programs for solving the problem involving a system of linear equations, it is important to incorporate good programming habits. These habits include making the program easy to modify in order to have the problem scalable and flexible. A program is said to be scalable if the code for a program with small data applies to one with large data as well. A flexible program is one that adapts well to changes in the parameters governing the problem with minimum modification in the program. It is our duty to discuss these approaches in this chapter.

The solution to a system of linear equations may or may not exist, depending on the given equations and several other factors. To complicate matters, a solution that exists may not be unique, and there can be an infinite number of solutions for the system. We study all cases that lead to the existence of the solution for a system of linear equations.

Definition 5.2. A system of linear equations is said to have consistent solutions if all its solutions satisfy each equation in the system. If one or more of the solutions do not satisfy at least one equation in the system, then the system is said to be inconsistent.

The above definition describes the state of the solutions in a system of linear equations. Referring to Equation (5.3), if the solution to the first equation also satisfies all other equations in the system, then this solution is consistent. It follows that the system normally produces consistent solutions if m ≤ n and inconsistent solutions if m > n. A consistent system may have either unique or many solutions. A set of inconsistent solutions consists of solutions that are valid in some but not in all equations in the system.

Ideally, good and consistent solutions are obtained if the coefficient matrix is square; that is, the number of equations in the system equals the number of unknowns, or m = n. With this assumption, Equation (5.3) can now be rewritten as follows:

Equation 5.4. 

Equation (5.4) is also expressed compactly in matrix form as A x = b, where

Equation 5.5. 

In this representation, the square matrix A is the coefficient matrix of the system, whereas x is the solution vector.

Theorem 5.1. If the coefficient matrix A of a system of linear equations is square and if |A| ≠ 0, then the system has consistent and unique solutions.

The above theorem states that a system whose coefficient matrix is not singular has consistent and unique solutions. Unique solutions imply each unknown in the system has only one value as its solution, and this value satisfies all equations in the system.

Example 5.1. The following system is consistent with unique solutions:

Equation 5.7. 

Solution. It can be shown that

Theorem 5.2. If the augmented matrix A | b reduces to U | v after row operations with one or more zero rows in U and the corresponding row(s) is v is also zero, then the system is consistent with an infinite number of solutions. If one or more corresponding row(s) in v is not zero, then the solution does not exist.

Theorem 5.2 says an infinite solution exists if a row (or more) in the augmented matrix has zero contents in all its (their) elements. The theorem is best illustrated using two examples, one with an infinite number of solutions and another with no solution.

Example 5.2. The following system is consistent with many solutions:

Equation 5.8. 

Solution. Reduce the augmented matrix, as follows:

Equation 5.9. 

Since all the elements in the second row of the augmented matrix have zero values, the system has infinite solutions. (x, y) = (1,0) and (x, y) = (−1, 1) are some of the possible solutions to the system.

Example 5.3. The following system is inconsistent:

Equation 5.10. 

Solution. Reduce the augmented matrix, as follows:

Equation 5.11. 

The last row of the final reduced augmented matrix has zero elements on the left-hand side and nonzero on the right-hand side. This contradicts the equation, and by Theorem 5.2, no solution exists for this system.

In this chapter, we will concentrate on discussing the system of linear equations in the form of Equation (5.4) that is consistent with a unique solution. In general, there are many techniques for solving this system, and they can be categorized as elimination, LU factorization, and iterative methods. An elimination technique reduces the augmented matrix in the system to its triangular form before applying backward substitutions for the solution. The LU factorization technique factorizes the coefficient matrix as a product of its upper and lower triangular matrices before generating the solution through substitutions. Lastly, an iterative technique performs iterations on all unknowns until their values converge to within a tolerable range.

Table 5.1 shows the common methods for solving a system of linear equations that can be categorized under the elimination, LU factorization, and iterative techniques. Note that some methods are very sensitive to the conditions imposed on the coefficient matrix, and we will address them later in the chapter.

The elimination technique reduces the rows of a matrix into a simpler form through a series of row operations, as discussed earlier in Chapter 2. We discuss three methods commonly used in solving a system of linear equations, namely, the Gaussian elimination method, Gaussian elimination method with partial pivoting, and Gauss-Jordan method.

Gaussian Elimination Method

The Gaussian elimination method is an elimination technique for solving a system of linear equations through two series of steps. The method works best when the coefficient matrix is not singular; that is, |A| ≠ 0 so that the solution obtained is unique according to Theorem 5.1. The Gaussian elimination method consists of two main steps, as depicted in Figure 5.1. The first step is the row operations for eliminating the elements in the coefficient matrix so as to reduce the matrix into its upper triangular form. If all elements in this triangular matrix have nonzero values, then the matrix definitely has a unique solution. The second step, which is backward substitutions, follows directly from the triangular matrix relationship for producing the solution.

Figure 5.1. Main steps in the Gaussian elimination method.

We discuss a system of linear equations Ax = b having n linear equations and n unknowns. The row operations technique in the Gaussian elimination method is similar to the technique for matrix reduction discussed in Section 2.4. This time row operations are applied to the augmented matrix A | b from the system of linear equations according to the following relationships:

Equation 5.12. 

for k = 1, 2, ..., n − 1, followed by i = k + 1, k + 2, ..., n and j = 1, 2, ..., n.

The above step reduces A | b to U | v. Backward substitutions are performed on U | v to produce the solution x according to the following:

Equation 5.13. 

Example 5.4. Solve the following system of linear equations using the Gaussian elimination method:

Equation 5.14. 

Solution. The above system is represented as the following augmented matrix:

Equation 5.15. 

Operations with Respect to the First Row. The row operation is R_i ← R_i − pR₁ for the rows i = 2, 3,4. The pivot element of the first row is a₁₁ = 2, and, therefore, p = a_i1/a₁₁. All elements in the second, third, and fourth rows are reduced to their corresponding values using the relationships a_ij ← a_ij − pa_1j and b_i ← b_i − pb₁ for the columns j = 1, 2, 3, 4.

Equation 5.16. 

Operations with Respect to the Second Row. The row operation is R_i ← R_i − pR₂ for the rows i = 3, 4. The pivot element of the second row is a₂₂ = 4, and, therefore, p = a_i2/a₂₂. All elements in the third and fourth rows are reduced to their corresponding values using the relationships a_ij ← a_ij − pa_2j and b_i ← b_i − pb₂ for the columns j = 1, 2, 3, 4.

Equation 5.17. 

Operations with Respect to the Third Row. The row operation is R_i ← R_i − pR₃ for the rows i = 4. The pivot element of the third row is a₃₃ = −35, and, therefore, p = a_i3/a₃₃. All elements in the fourth row are reduced to their corresponding values using the relationships a_ij ← a_ij − pa_3j and b_i ← b_i − pb₃ for the columns j = 1, 2, 3, 4.

Equation 5.18. 

Row operations on A and b produce U and v, respectively, where

Equation 5.19. 

Backward substitutions. The reduced system oflinear equations after row operations is

Equation 5.20. 

This system is solved by applying backward substitutions to get

Equation 5.21. 

The C++ code for this method follows from the same coding for reducing a square matrix to its upper triangular form and for finding the inverse of a matrix in Sections 3.3 and 3.4, respectively. Row operations reduce A | b to U | v, as shown below:

double Sum,m;
for (k=1; k<=n-1; k++)
      for (i=k+1; i<=n; i++)
      {
            p=a[i][k]/a[k][k];
            for (j=1; j<=n; j++)
                  a[i][j] -= p*a[k][j];
            b[i] -= p*b[k];
      }

This is followed by backward substitutions:

for (i=n; i>=1; i--)
{
      Sum=0;
      x[i]=0;
      for (j=i;j<=n; j++)
            Sum += a[i][j]*x[j];
      x[i]=(b[i]-Sum)/a[i][i];
}

Code5A.cpp solves a system of linear equations using the Gaussian elimination method. The data for the system is obtained from an external file called Code5A.in.

Code5A.cpp: Gaussian elimination method

#include <fstream.h>
#include <iostream.h>
#define n 4

void main()
{
      int i,j,k;
      double *x,*b,**a;
      for (i=0;i<=n;i++)
      {
            x=new double [n+1];
            b=new double [n+1];
            a=new double *[n+1];
            for (j=0;j<=n;j++)
                  a[j]=new double [n+1];
      }
      ifstream InFile("Code5A.in");
      cout.setf(ios::fixed);
      cout.precision(5);
      cout << "Our input data: " << endl;
      for (i=1;i<=n;i++)
      {
            cout << "a: ";
            for (j=1;j<=n;j++)
            {
                  InFile >> a[i][j];
                  cout << a[i][j] << " ";
            }
            InFile >> b[i];
            cout << "b=" << b[i] << " " << endl;
      }
      InFile.close();

      // row operations
      double Sum,p;
      for (k=1;k<=n-1;k++)
            for (i=k+1;i<=n;i++)
            {
                  p=a[i][k]/a[k][k];
                  for (j=1;j<=n;j++)
                        a[i][j]-=p*a[k][j];
                  b[i] -= p*b[k];
            }

      // backward substitutions
      for (i=n;i>=1;i--)
      {
            Sum=0;
            x[i]=0;

for (j=i;j<=n;j++)
                  Sum += a[i][j]*x[j];
             x[i]=(b[i]-Sum)/a[i][i];
      }
             cout << endl;

      // display results
      cout << "results after row operations:" << endl;
      for (i=1; i<=n; i++)
      {
            cout << "u: ";
            for (j=1;j<=n;j++)
                  cout << a[i][j] << " ";
            cout << "v=" << b[i] << " " << endl;
      }
      cout <<endl<<"results after backward substitutions: x=";
      for (i=1; i<=n; i++)
            cout << x[i] << " ";
      cout << endl;
      for (i=0;i<=n;I++)
            delete a[i];
      delete a,x,b;
}

Gaussian Elimination Method with Partial Pivoting

Very often, the diagonal elements of a matrix have values equal or close to zero. A matrix with this feature is called an ill-conditioned matrix. Division on a zero value produces an undefined number. Division on a small number whose value is very close to zero is the inverse of the division process that produces a very large number. Such a number does not fit to be a pivot element in the row operations as the result affects the accuracy of the division significantly.

An ill-conditioned matrix is treated differently when the Gaussian elimination method is applied. To avoid division by zero or a number close to this value, partial pivoting on the diagonal element is performed. Partial pivoting is a technique of interchanging a row whose pivot element has a value equal to or close to zero with another row whose element in the same column as the pivot element has the largest modulus value. Therefore, partial pivoting requires an additional step of interchanging two rows before row operations are performed.

Consider the following system:

Equation 5.22. 

The augmented matrix A | b is

Equation 5.23. 

With the Gaussian elimination method, this augmented matrix reduces to the following form with R₂ ← R₂ − R₁:

Equation 5.24. 

Continuing the next row operation with a₂₂ as the pivot element will be disastrous as this element is zero, and

Equation 5.25. 

Reduction with R₂ ← R₂ + 2R₁ produces

Equation 5.26. 

which rectifies the above problem. We discuss an example here.

Example 5.5. Solve the following system of linear equations using the Gaussian elimination method with partial pivoting:

Equation 5.27. 

Solution. The above matrix is ill-conditioned as some pivot elements have zero values, namely a₁₁ and a₂₂. Applying the Gaussian elimination method directly to solve the system will be disastrous as m is undefined due to division by these zero values. Let's try on the partial pivoting technique. The augmented matrix for this system is shown as follows:

Equation 5.28. 

Test for the Dominance of the Pivot Element in Row 1. The modulus of the pivot element in the first row is not the largest as |a₁₁| < |a₃₁|. Therefore, an interchange between rows 1 and 3 is performed.

Equation 5.29. 

Operations with Respect to the First Row. The row operation is R_i ← R_i − pR₁, where a₁₁ = 8 is the pivot element of the first row and m = a_i1/a₁₁ for the rows i = 2,3, 4. All elements in the second, third, and fourth rows are reduced to their corresponding values using the relationships a_ij ← a_ij − pa_1j and b_i ← b_i − pb₁ for the columns j = 1, 2, 3, 4.

Equation 5.30. 

Test for the Dominance of the Pivot Element in Row 2. The modulus of the pivot element in the second row is not the largest as |a₂₂| < |a₄₂|. Therefore, an interchange between rows 2 and 4 is performed.

Equation 5.31. 

Operations with Respect to the Second Row. The row operation is R_i ← R_i − pR₂, where a₂₂ = − 8.250 is the pivot element of the second row, and therefore, p = a_i2/a₂₂ for the rows i = 3, 4. All elements in the third and fourth rows are reduced to their corresponding values using the relationships a_ij ← a_ij − pa_2j and b_i ← b_i − pb₂ for the columns j = 1, 2, 3, 4.

Equation 5.32. 

Test for the Dominance of the Pivot Element in Row 3. No interchange of rows is performed as the modulus of the pivot element in the third row is larger than the elements below it.

Operations with Respect to the Third Row. The row operation is R_i ← R_i − pR₃, where a₃₃ = 6.864 is the pivot element of the third row. Therefore, p = a_i3/a₃₃ for the row i = 4. All elements in the fourth row are reduced to their corresponding values using the relationships a_ij ← a_ij − pa_3j and b_i ← b_i − pb₃ for the columns j = 1, 2, 3, 4.

Equation 5.33. 

Row operations with partial pivoting reduce A | b. to U | v. with the following values:

Equation 5.34. 

Backward substitutions. The same backward substitution technique as in the Gaussian elimination method is applied to produce the solutions, x₄ = −0.258, x₃ = −0.248, x₂ = −0.479, and x₁ = −0.097.

Gauss-Jordan Method

The Gauss-Jordan method is another elimination technique for solving the Ax = b problem involving row operations. Unlike the Gaussian elimination method, the Gauss-Jordan method is wholly based on row operations and does not involve backward substitutions. The method assumes the coefficient matrix to be nonsingular and fails to produce the desired result if the matrix is singular.

The Gauss-Jordan method is implemented as follows: Reduce the coefficient matrix A into an identity matrix I by eliminating the elements in the rows and columns of the other diagonals. The augmented matrix A | b. reduces to I | v. through row operations where v is the final solution. This is described in Figure 5.2.

Figure 5.2. The single main step in the Gauss-Jordan method.

The Gauss-Jordan method is illustrated through Example 5.6.

Example 5.6. Solve the problem from Example 5.4 using the Gauss-Jordan method.

Solution. Form the augmented matrix A | b:

Equation 5.35. 

Reduce a₁₁ value to 1 through R₁ ← R₁/a₁₁.

Equation 5.36. 

Eliminate a₂₁, a₃₁, and a₄₁ through R₂ ← R₂ − a₂₁R₁, R₃ ← R₃ − a₃₁ R₁, and R₄ ← R₄ − a₄₁R₁, respectively.

Equation 5.37. 

Reduce a₂₂ to 1 through R₂ ← R₂/a₂₂.

Equation 5.38. 

Eliminate a₁₂, a₃₂, and a₄₂ through R₁ ← R₁ − a₁₂ R₂, R₃ ← R₃ − a₃₂R₂, and R₄ ← R₄ − a₄₂ R₂, respectively.

Equation 5.39. 

Reduce a₃₃ to 1 through R₃ ← R₃/a₃₃.

Equation 5.40. 

Eliminate a₁₃, a₂₃, and a₄₃ through R₁ ← R₁ − a₁₃ R₃, R₂ ← R₂ − a₂₃R₃, and R₄ ← R₄ − a₄₃ R₃, respectively.

Equation 5.41. 

Reduce a₄₃ to 1 through R₄ ← R₄/a₄₄.

Equation 5.42. 

Eliminate a₁₄,a₂₄, and a₃₄ through R₁ ← R₁ − a₁₄ R₄, R₂ ← R₂ − a₂₄R₄, and R₄ ← R₄ − a₃₄ R₄, respectively.

Equation 5.43. 

The final step gives the solutions as x₁ = −0.050, x₂ = −0.409, x₃ = −0.261, and x₄ = −0.520, which are the same as in Example 5.4.

An iterative method is easy to implement as it is a repetition of the same set of variables that does not require too much computer memory. An iteration starts with some given initial values to the variables. These values are constantly updated at each iteration, and eventually they converge to the desired values after some successful iterations. The iterations only stop once the values have converged to some numbers where stopping criteria have been met.

The stopping point for the iterations is normally based on a comparison between an error in the iteration with some small value. A common error for an iterative process is the maximum from the difference in vector magnitude norm based on Equation (3.8), or

Equation 5.9. 

In the above equation, iteration on x = [x₁ x₂ ... x_n] ^T is indicated by the superscript k. Equation (5.9) specifies the error as the difference between the computed values of x at iteration k + 1 with the ones at iteration k. The difference is compared with some small number ε. If

We discuss two iterative methods that are commonly applied in solving a system of linear equations. The first system is the Jacobi method, which updates the values of the unknowns when an iteration has completed. The second system is the Gauss-Seidel method, which performs an update on the values immediately without waiting for an iteration to complete. These two methods are basically similar, having the same formula for updating the values. Both methods require the coefficient matrix of the system to be a special type of matrix called a diagonally-dominant matrix. The difference between them lies in the way updates are made: Gauss-Seidel uses the latest values of the variables, whereas Jacobi is not using the latest values.

Definition 5.5. A square matrix A is said to be diagonally-dominant if the absolute value of its diagonal element in each row is greater than the sum of the absolute value of all other elements in the same row. This condition is expressed as follows:

Equation 5.10. 

In the above definition, a diagonally-dominant matrix must always have the largest absolute values at its diagonal elements. As an illustration, the following matrix is diagonally-dominant:

Equation 5.77. 

The following matrix is not diagonally-dominant but becomes diagonally-dominant by exchanging rows 2 and 3:

Equation 5.78. 

The diagonally-dominance criteria test on a coefficient matrix is implemented in C++, as follows:

for (i=1;i<=n;i++)
{
      Sum=0;
      for (j=1;j<=n;j++)
            if (i!=j)
                  Sum += fabs(a[i][j]);
      if (fabs(a[i][i])<=Sum)
      {
            cout <<"Unsuccessful, the matrix is not
                    diagonally-dominant" << endl;
            return;
      }
}

Jacobi Method

The Jacobi method is an iterative method that performs updates based on the values of its variables from the previous iteration. The method requires the coefficient matrix A of the linear system to be positive definite to guarantee convergence to its solutions. Otherwise, the computed values of the variables will not converge and will cause a very significant error to the solution.

The Jacobi method starts with a formulation of the variables from the given equations in the system. The rth equation in the n × n system of linear equations is given as follows:

Equation 5.79. 

From this equation, the variable x_r is formulated as a subject of the rest of the variables:

Equation 5.80. 

At iteration k, an update is made on x_r based on the current values of the variables

Equation 5.11. 

The complete formulation of all variables in the system of linear equations based on Equation (5.11) is shown below:

Equation 5.82. 

Figure 5.6 shows the schematic flowchart of the Jacobi method. The iterations start by assigning initial values to the variables at iteration 0, which is denoted as

The stopping criteria for the iterations are normally set according to the maximum magnitude of the vector difference of Equation (5.9) or

The same process as above is repeated for the subsequent iterations until the stopping criteria of Equation (5.9) is fulfilled. The final solution is x, which consists of the values in the last iteration where the stopping criteria are met.

Example 5.12. Solve the following system using the Jacobi method with the initial value of x⁽⁰⁾ = [0 0 0 0]^T until

Equation 5.83. 

Figure 5.6. Schematic flowchart of the Jacobi and Gauss-Seidel methods.

Solution. It can be shown that the coefficient matrix in the above system is not positive definite. Therefore, the rows are interchanged in such a way that the dominant coefficient of each row forms the diagonal in the new coefficient matrix. This results in the following arrangement where the coefficient matrix is positive definite:

Equation 5.84. 

We get expressions for x₁, x₂, x₃, and x₄, as follows:

Equation 5.85. 

From Equation (5.11), the values of x₁, x₂, x₃, and x₄ are updated at each iteration k as follows:

Equation 5.86. 

With k = 0:

Equation 5.87. 

Table 5.2. Results from Jacobi iterations in Example 5.12

k	x(k)1	x(k)2	x(k)3	x(k)4
0	0.000	0.000	0.000	0.000	0.600
1	−0.167	−0.600	0.400	−0.250	0.150
2	−0.317	−0.503	0.297	−0.133	0.112
3	−0.305	−0.577	0.399	−0.245	0.045
4	−0.314	−0.532	0.357	−0.208	0.021
5	−0.305	−0.550	0.378	−0.229	0.011
6	−0.308	−0.540	0.366	−0.218	0.005
7	−0.306	−0.545	0.372	−0.223

The error is greater than the tolerance. Therefore, the iterations continue with k = 1:

Equation 5.88. 

The error is reduced significantly in this iteration, which means convergence to the solution is beginning to take its shape. Continuing the process gives the results as shown in Table 5.2.

The final solution is x⁽⁷⁾ = [−0.306 −0.545 0.372 −0.223]^T, which is achieved at k = 6 when

Gauss-Seidel Method

The Gauss-Seidel method is an iterative method that updates the values of a variable based on the latest values of other variables in the system. Because of these latest values, convergence to the solution takes place faster than the Jacobi method.

The implementation of the Gauss-Seidel method is very similar to the Jacobi method, as shown in the flowchart in Figure 5.6. For an equation given by

Equation 5.89. 

The update on x_r at iteration k is the one-step ahead value given as follows:

Equation 5.12. 

In the above equation, the update on x_r involves the latest values of x_i for i = 1, 2, ...,r − 1 at iteration k + 1 and the values of x_i for i = r + 1, r + 2, ..., n at iteration k. The complete update on the variables is shown as follows:

Equation 5.91. 

The standard error in the iterations is the maximum magnitude norm as expressed in Equation (5.9). This error is compared with the preset threshold value ε, where the iterations stop immediately if the error is smaller than or equal to this value.

Example 5.13. Solve the system of linear equations in Example 5.12 using the Gauss-Seidel method with the initial value of x⁽⁰⁾ = [0 0 0 0]^T until

Solution. The coefficient matrix of the above system is not diagonally-dominant. Rearrange the rows so that the diagonal elements become dominant, as follows:

Equation 5.92. 

From Equation (5.15), updates are performed according to

Equation 5.93. 

Starting with k = 0:

Equation 5.94. 

The iteration continues with k = 1 since the error is greater than ε:

Equation 5.95. 

Additional iterations produce results as shown in Table 5.3.

Table 5.3. Results from Example 5.12

k	x(k)1	x(k)2	x(k)3	x(k)4
0	0.000	0.000	0.000	0.000	0.633
1	−0.167	−0.633	0.340	−0.133	0.175
2	−0.341	−0.574	0.395	−0.228	0.035
3	−0.318	−0.539	0.374	−0.228	0.013
4	−0.305	−0.541	0.368	−0.221	0.002
5	−0.306	−0.543	0.369	−0.221

The iterations stop at k = 4 to produce x⁽⁵⁾ as the solution where the error given by

Code5E. Gauss-Seidel method.

#include <iostream.h>
#include <fstream.h>
#include <math.h>
#define n 4            // array size
#define MAX 10         // maximum number of iterations

void main()
{
      int i,j,k;
      double *x,*xOld,*b,**a;
      double Sum,error;

      // allocate memory
      x=new double [n+1];
      xOld=new double [n+1];
      b=new double [n+1];
      a=new double *[n+1];
      for (i=0;i<=n;i++)
            a[i]=new double [n+1];
      cout.setf(ios::fixed);
      cout.precision(3);

      // read the input data
      ifstream InFile("Code5E.in");
      for (i=1;i<=n;i++)
      {
            x[i]=xOld[i]=0;
            for (j=1;j<=n;j++)
                  InFile >> a[i][j];
            InFile >> b[i];
      }

InFile.close();

      // test for diagonally-dominance
      for (i=1;i<=n;i++)
      {
            Sum=0;
            for (j=1;j<=n;j++)
                  if (i!=j)
                       Sum += fabs(a[i][j]);
            if (fabs(a[i][i])<=Sum)
            {
                  cout <<"Unsuccessful, the matrix is not
                          diagonally-dominant" << endl;
                  return;
            }
      }

      // perform iterations & update x
      for (k=0;k<=MAX;k++)
      {
            error=0;
            cout << "k=" << k << ": ";
            for (i=1;i<=n;i++)
            {
                  Sum=0;
                  for (j=1;j<=n;j++)
                        if (i!=j)
                              Sum += a[i][j]*x[j];
                  xOld[i]=x[i];
                  x[i]=(b[i]-Sum)/a[i][i];
                  cout << x[i] << " ";
                  error=((error>fabs(x[i]-xOld[i]))?error:
                          fabs(x[i]-xOld[i]));
            }
            cout << error << endl;
      }

      // delete memory
      for (i=0;i<=n;i++)
            delete a[i];
      delete x,xOld,b,a;
}

We now discuss the design and development of several modules for solving a system of linear equations. The modules are integrated into a single system based on Windows using the resources in the Microsoft Foundation Classes library. The interface is user-friendly with dialog boxes for input, and buttons for updates, which serves as a black box for solving the system of linear equations problem to its user. A user-friendly interface must have features that allow easy input of data, modification of the input data, a choice of several methods for the same data, and an error-proof mechanism to detect problems in data entry. The last factor is important since problems like singular matrix as input can cause the system to crash instead of producing a good solution.

Figure 5.7 shows the Windows interface for solving a system of up to five linear equations problem. The interface consists of a modal window with input in the form of edit boxes (white), the output in static boxes (gray), buttons for activating the methods, and text messages. The buttons are labeled Gauss, Crout, Cholesky, Thomas, and Gauss-Seidel, which activate the named methods for solving the problem. The Reset button clears all entries and refreshes the display.

Figure 5.7. Windows interface for solving a system of up to five linear equations.

The figure also shows a sample run of the Gauss-Seidel method with A and b as input in the edit boxes, to produce the output x in the static boxes once the Gauss — Seidel button is clicked. The program is intelligent enough to recognize the coefficient matrix A as diagonally dominant. Otherwise, if A is not diagonally dominant, then a click on the Gauss-Seidel button will not produce the desired results. The same input produces the same results when the Gauss and Crout buttons are clicked, but it will respond with some error messages if the Cholesky and Thomas buttons are clicked. In this case, the program can verify correctly that A is not positive definite and tridiagonal, respectively.

Any size of matrix, from two to five, can be entered. Entries can be made beginning from the top left-hand corner. The size of the matrix is then automatically determined from the first unfilled entry in the diagonal elements.

We discuss the steps for producing this interface. They consist of creating a new Win32 project codenamed Code5 using the MFC static library, creating the resource file Code5.rc, and inserting codes for the Gauss, Crout, Cholesky, Thomas, and Gauss-Seidel methods. Only three files need to be created, namely Code5.cpp, Code5.h, and Code5.rc. A single class called CCode5 is used, and this class is derived from MFC's CDialog.

Figure 5.8 shows a schematic drawing of the computational steps in Code5. The process starts with the resource file Code5.rc for creating the dialog window. The dialog window becomes the main window that hosts several child windows consisting of edit boxes for collecting the input, static boxes for displaying the output, and buttons for selecting a method for solving the problem.

Figure 5.8. Schematic drawing of the computational steps in Code5.

Global objects and variables are initialized in the constructor, CCode5(). They include the matrices and vectors for the system of linear equations. ReadInput() reads the input data in the edit boxes, and the data are then passed for processing to a function when a push button that points to the function is clicked. The activated function returns either fStatus=1 or fStatus=0, which indicates whether the supplied data fit into the named method or not, respectively. With fStatus=1, the results from the function are displayed in the static boxes through ShowResults(), and the method is flagged as successful. A return value of fStatus=0 indicates the method fails because of irrelevant data, and the error message is shown through ShowError(). Another function called OnReset() refreshes the edit and static boxes for a new data entry.

There are six major steps in the development of Code5. This project differs slightly from the skeleton program in Code3A project as the main window is a dialog window derived from MFC's CDialog. A dialog window is a container class that can host several objects from other classes.

Step 1. Create a new Win32 project.

From the menu, choose File, followed by New and Project. Name the project Code5, and press the OK button. A new class called CCode5 is created. Declare the project as an empty Windows application project through the check boxes.

From the Solution Explorer, highlight CCode5 and right-click Properties. Choose Use MFC in a Static Library from the item Use of MFC in the combo box. These options allow the application to use the resources in the MFC library.

Step 2. Add the resource file Code5.rc.

This step creates all the friendly tools in the modal window that are the resources in Windows. Right-click Resource Files in the Solution Explorer, as shown in Figure 5.9. Choose Add from the menu and then Add Resource.

Step 3. Add a dialog window.

A dialog window is host to several friendly tools such as buttons, edit boxes, combo boxes, check boxes, and static boxes. To create a dialog window, choose Dialog from the Add Resource window, as shown in Figure 5.10.

Step 5. Create edit boxes, static boxes, and buttons.

A dialog window as shown in Figure 5.11 appears. This window is automatically assigned with the id IDD_DIALOG1. From the Toolbox, choose Edit Control, and draw an edit box, as shown in the figure. Click Properties Windows, and assign this edit box with the id IDC_A11 for representing the element a₁₁ in the coefficient matrix A.

Continue with the rest of the elements in matrix A (IDC_A12 up to IDC_A55) and vector b (IDC_b1 to IDC_b5) to complete the input interface. Next, click Toolbox and choose Static Text. Create static boxes for housing the vector x with ids from IDC_x1 to IDC_x5. Figure 5.12 shows the complete interface for this problem with ids on the items in the Windows.

Step 6. Create the files Code5.cpp and Code5.h, and insert their codes.

The main file is Code5.cpp, which drives the application by calling both Code5.h and Code5.rc.

Figure 5.9. Adding a resource file called Code5.rc.

Figure 5.10. Add Resource items.

The contents of the header file Code5.h differ from the skeleton program in Code3A, as its host window is a dialog window. It is necessary to add #include "resource.h" in the preprocessing area of Code5.h as this file contains all the necessary declarations for the resources created in Code5.rc.

Figure 5.11. Dialog window with the id IDD_DIALOG1.

Figure 5.12. The ids of the resources in the dialog window.

#include <afxdisp.h>
#include <math.h>
#include "resource.h"
#define N 5

class CCode5 : public CDialog
{
public:
      CCode5(CWnd* pParent = NULL);
      enum { IDD = IDD DIALOG1 };
      virtual ~CCode5();
      virtual void OnOK();
      void ReadInput(),DisplayResults(),DisplayError(CString);
      afx msg void OnGauss();
      afx msg void OnCrout();
      afx msg void OnCholesky();
      afx msg void OnThomas();
      afx msg void OnGaussSeidel();
      afx msg void OnReset();
      int n;
      double **A,**L,**U,*x,*b;
      CString **sA,*sx,*sb,method;
      DECLARE_MESSAGE_MAP()
};

class CMyWinApp : public CWinApp
{
public:
      virtual BOOL InitInstance();
};

The dialog window is created in Code5.cpp. This window is called the modal window, as it does not allow background editing if the window is active. Its opposite is the nonmodal window, which allows background editing when the window is active. The following code segment in Code5.cpp creates the dialog window:

BOOL CMyWinApp::InitInstance()
{
   AfxEnableControlContainer();
   CCode5 dlg;
   m pMainWnd = &dlg;
   dlg.DoModal();
   return FALSE;
}

A method for solving the system of linear equations based on the input data becomes active when one of the push buttons that correspond to the method is left-clicked. Each push button has an id, and it calls the corresponding function through an event mapping given by

BEGIN_MESSAGE_MAP(CCode5,CDialog)
    ON_BN_CLICKED(IDC_GAUSS, OnGauss)
    ON_BN_CLICKED(IDC_CROUT, OnCrout)
    ON_BN_CLICKED(IDC_CHOLESKY, OnCholesky)
    ON_BN_CLICKED(IDC_THOMAS, OnThomas)
    ON_BN_CLICKED(IDC_GAUSSSEIDEL, OnGaussSeidel)
    ON_BN_CLICKED(IDC_RESET, OnReset)
END_MESSAGE_MAP()

It is obvious in the message map that a click on the Gauss button, whose id is IDC_GAUSS, triggers a call on the function OnGauss(). This function reads the data provided by the user in the edit boxes and then solves the problem using the Gaussian elimination method.

Table 5.4 shows the member functions of the class CCode5. Included are eight main member functions representing the buttons in the class. Each function in the class is named according to its duty; for example, OnGauss() responds to the Gauss button click, and this function solves the system of linear equations based on the data input from the user. The ids of these buttons are shown in Figure 5.12.

The edit boxes provide input spaces for matrix A and vector b. A system of up to 5 × 5 linear equations is supported, and this is indicated as the macro N in the header file Code5.h. The program has been designed flexible so as to support other sizes simply filling in the values of A starting from the top left-hand corner. The actual size of the matrix is represented by a variable called n. The size is determined from the filled elements in the diagonal. For example, to have a 3 × 3 system, or n=3, entries must be made in the first three rows and three columns of the edit boxes beginning from the top left-hand corner.

Beside the button functions, CCode5 has four other application functions, ReadInput(), DisplayResults(), DisplayError(), and OnOK(). These functions are called from the selected method for reading the input data, displaying the output, displaying error messages, and closing the application, respectively.

The constructor in the class is CCode5(). This function activates the dialog box with the id IDD_DIALOG1, which is the one shown in Figure 5.11. This window is derived from the MFC class CDialog. Besides creating the class, CCode5() also initializes several arrays and allocates memory dynamically. This is shown as follows:

CCode5::CCode5(CWnd* pParentWnd)
: CDialog (IDD DIALOG1, pParentWnd)
{
      x=new double [N+1];
      b=new double [N+1];
      sx=new CString [N+1];
      sb=new CString [N+1];
      A=new double *[N+1];
      L=new double *[N+1];
      U=new double *[N+1];
      sA=new CString *[N+1];
      for (int i=0;i<=N;i++)
      {
            A[i]=new double [N+1];
            L[i]=new double [N+1];
            U[i]=new double [N+1];
            sA[i]=new CString [N+1];
      }
}

The destructor in the program is ~CCode5(). This function destroys the arrays allocated in the constructor and the class to mark the end of the application runtime. The code is shown as follows:

CCode5::~CCode5()
{
      for (int i=0;i<=N;i++)
            delete A[i],L[i],U[i],sA[i];
      delete x,b,sx,sb,A,L,U,sA;
}

ReadInput() is a function for reading all input from the user in the form of edit boxes, as shown in Figure 5.11. Input from the user is read through the function GetDlgItemText(). Each edit box has an idd that reflects its matrix element. For example, IDC_A24 represents the edit box for a₂₄ in matrix A, whereas IDC_b3 represents b₃ in b. However, the representation is not straightforward. An edit box takes only string (text) input, and this string needs to be converted to a double value before a computation can be performed. Hence, the value input by the user inside the box with the id IDC_A24 is stored as the string sA[2][4], whereas that of IDC_b3 is stored as sb[3]. These values are converted to the double variables called A[2][4] and b[3], respectively, using the C function atof(). The code is shown, as follows:

void CCode5::Read
{
      GetDlgItemText(IDC_A11,sA[1][1]);
      GetDlgItemText(IDC_A12,sA[1][2]);
      GetDlgItemText(IDC_A13,sA[1][3]);
      GetDlgItemText(IDC_A14,sA[1][4]);
      GetDlgItemText(IDC_A15,sA[1][5]);
      GetDlgItemText(IDC_A21,sA[2][1]);
      GetDlgItemText(IDC_A22,sA[2][2]);
      GetDlgItemText(IDC_A23,sA[2][3]);
      GetDlgItemText(IDC_A24,sA[2][4]);
      GetDlgItemText(IDC_A25,sA[2][5]);
      GetDlgItemText(IDC_A31,sA[3][1]);
      GetDlgItemText(IDC_A32,sA[3][2]);
      GetDlgItemText(IDC_A33,sA[3][3]);
      GetDlgItemText(IDC_A34,sA[3][4]);
      GetDlgItemText(IDC_A35,sA[3][5]);
      GetDlgItemText(IDC_A41,sA[4][1]);
      GetDlgItemText(IDC_A42,sA[4][2]);
      GetDlgItemText(IDC_A43,sA[4][3]);
      GetDlgItemText(IDC_A44,sA[4][4]);
      GetDlgItemText(IDC_A45,sA[4][5]);
      GetDlgItemText(IDC_A51,sA[5][1]);
      GetDlgItemText(IDC_A52,sA[5][2]);
      GetDlgItemText(IDC_A53,sA[5][3]);
      GetDlgItemText(IDC_A54,sA[5][4]);
      GetDlgItemText(IDC_A55,sA[5][5]);
      GetDlgItemText(IDC_b1,sb[1]);
      GetDlgItemText(IDC_b2,sb[2]);
      GetDlgItemText(IDC_b3,sb[3]);
      GetDlgItemText(IDC_b4,sb[4]);
      GetDlgItemText(IDC_b5,sb[5]);

      for (int i=1;i<=N;i++)
            if (sA[i][i]=="")
            {
                  n=i-1; break;
            }
     // convert the string input to double
     for (i=1;i<=n;i++)
     {
           for (int j=1;j<=n;j++)

A[i][j]=atof(sA[i][j]);
           b[i]=atof(sb[i]);
     }
}

The output in the program is x = [x₁ x₂ x₃ x₄ x₅]^T, which is displayed by the function DisplayResults(). The vector is represented by the double array x, and it is displayed on the static boxes using SetDlgItemText() through the string sx. Conversion from x to the string sx is achieved through the function Format(). The static boxes are represented byids that reflect their variables; for example,IDC_x1 represents the string sx[1]. The last statement in this function displays the successful message to acknowledge that the given method is successful. The following code shows the contents of DisplayResults():

void CCode5::DisplayResults()
{
      for (int i=1;i<=N;i++)
            sx[i].Format("%lf",x[i]);
      SetDlgItemText(IDC_x1,((1<=n)?sx[1]:""));
      SetDlgItemText(IDC_x2,((2<=n)?sx[2]:""));
      SetDlgItemText(IDC_x3,((3<=n)?sx[3]:""));
      SetDlgItemText(IDC_x4,((4<=n)?sx[4]:""));
      SetDlgItemText(IDC_x5,((5<=n)?sx[5]:""));
      SetDlgItemText(IDC_MESSAGE,method+" is successful.");
}

OnGauss() is the function that responds to the Gauss button click identified through the id IDC_GAUSS. This function is based on Code4A.cpp. A Boolean variable called fStatus is introduced to check the value of the pivot element A[k][k], where 0 (FALSE) indicates the element is 0. With this value, the Gaussian elimination method is considered a failure, and an error message is displayed through the function DisplayError(). Through this process, a division by zero in m=A[i][k]/A[k][k] during the row operations with respect to row k can be avoided. The function is given by

void CCode5::OnGauss()
{
      int i,j,k;
      double Sum,p;
      bool fStatus=1;
      CString condition="invertible";
      method="Gauss";
      ReadInput();

// perform row operations
      for (k=1;k<=n-1;k++)
            for (i=k+1;i<=n;i++)
            {
                  if (A[k][k]==0)
                  {
                        fStatus=0;
                        break;
                  }
                  else
                        p=A[i][k]/A[k][k];
                  for (j=1;j<=n;j++)
                        A[i][j] -= p*A[k][j];
                  b[i] -= p*b[k];
           }

     // perform backward substitutions
     for (i=n;i>=1;i--)
     {
           Sum=0;
          x[i]=0;
          for (j=i;j<=n;j++)
          Sum += A[i][j]*x[j];
          x[i]=(b[i]-Sum)/A[i][i];
     }
     if (fStatus)
           DisplayResults();
     else
           DisplayError(condition);
}

A click on the Crout button whose id is IDC_CROUT activates the function OnCrout(), which computes the problem using the Crout() method. This function also has a Boolean variable called fStatus to check for the zero values in the diagonal elements of matrix L. Successful runtime is achieved through fStatus=1, and the output is displayed through the function DisplayResults(). The code in this function is given, as follows:

void CCode5::OnCrout()
{
      int i,j,k,r;
      double Sum,*w;
      bool fStatus=1;
      CString condition="invertible";
      method="Crout";

w=new double [N+1];
      ReadInput();

      // initialize L and U
      for (i=1;i<=n;i++)
            for (j=1;j<=n;j++)
            {
                  L[i][j]=U[i][j]=0;
                  if (i==j)
                  U[i][j]=1;
            }

      // compute L and U
      for (i=1;i<=n;i++)
            L[i][1]=A[i][1];
      for (j=2;j<=n;j++)
            if (L[1][1]==0)
            {
                  fStatus=0;
                  break;
            }
            else
                  U[1][j]=A[1][j]/L[1][1];
      for (j=2; j<=n-1;j++)
      {
            for (i=j; i<=n; i++)
            {
                  Sum=0;
                  for (k=1;k<=j-1;k++)
                        Sum += L[i][k]*U[k][j];
                  L[i][j]=A[i][j]- Sum;
            }
            for (k=j+1;k<=n;k++)
            {
            Sum=0;
            for (r=1;r<=j-1;r++)
                  Sum += L[j][r]*U[r][k];
            if (L[j][j]==0)
            {
                  fStatus=0;
                  break;
            }
            else
                  U[j][k]=(A[j][k]-Sum)/L[j][j];
            }
       }

Sum=0;
       for (k=1;k<=n-1;k++)
             Sum += L[n][k]*U[k][n];
       L[n][n]=A[n][n]-Sum;

       // forward substitutions for finding w
       w[1]=b[1]/L[1][1];
       for (j=1;j<=n;j++)
       {
             Sum=0;
             for (k=1; k<=j-1;k++)
                   Sum += L[j][k]*w[k];
             if (L[j][j]==0)
             {
                   fStatus=0;
                   break;
             }
             else
                   w[j] =(b[j]-Sum)/L[j][j];
       }

       // backward substitutions for finding x
       for (i=n;i>=1;i--)
       {
             Sum=0;
             for (k=i+1; k<=n; k++)
                   Sum += U[i][k]*x[k];
             x[i]=w[i]-Sum;
       }
       delete w;
       if (fStatus)
             DisplayResults();
       else
             DisplayError(condition);
}

OnCholesky() responds to the Cholesky button click. This function first performs a test on the positive-definiteness of the coefficient matrix, with fStatus=1 indicating positive and fStatus=0 negative. The code is given, as follows:

void CCode5::OnCholesky()
{
      int i,j,k;
      double Sum,*w;
      bool fStatus=1;

CString condition="positive-definite";
      method="Cholesky";
      w=new double [N+1];
      ReadInput();

      // check for positive-definite
      for (i=1;i<=n;i++)
            for (j=i;j<=n;j++)
                  if ((A[i][j]!=A[j][i])
                       | | A[i][i]<=0
                       | | (i!=j && A[i][i]<=fabs(A[i][j])))
                  {
                       fStatus=0;
                       break;
                  }

      // initialize L and U
      for (i=1;i<=n;i++)
            for (j=1;j<=n;j++)
                  L[i][j]=U[i][j]=0;

     // compute L and U
     for (k=1;k<=n;k++)
     {
           Sum=0;
           for (j=1;j<=k-1;j++)
                 Sum += pow(L[k][j],2);
           L[k][k]=sqrt(A[k][k]-Sum);
           for (i=1;i<=k-1;i++)
           {
                 Sum=0;
                 for (j=1;j<=i-1;j++)
                       Sum += L[i][j]*L[k][j];
                 L[k][i]=(A[k][i]-Sum)/L[i][i];
           }
      }

      // forward substitutions for finding w
      for (j=1;j<=n;j++)
      {
            Sum=0;
            for (k=1; k<=j-1;k++)
                  Sum += L[j][k]*w[k];
            w[j] =(b[j]-Sum)/L[j][j];
      }

// backward substitutions for finding x
      for (i=n;i>=1;i--)
      {
            Sum=0;
            for (k=i+1; k<=n; k++)
                  Sum += U[i][k]*x[k];
            x[i]=w[i]-Sum;
      }
      delete w;
      if (fStatus)
           DisplayResults();
      else
           DisplayError(condition);
}

The case of the coefficient matrix in the system is tridiagonal, which leads to the deployment of the Thomas algorithm through the function OnThomas(). Just like other methods, this function uses the Boolean variable fStatus; a value of 1 indicates the matrix is tridiagonal, whereas 0 means the matrix is not tridiagonal. With fStatus=1, the Thomas algorithm is applied to the system, and the output is displayed in DisplayResults(). The code is shown below:

void CCode5::OnThomas()
{
      int i,j;
      bool fStatus=1;
      double *e,*f,*g;
      CString condition="tridiagonal";
      method="Thomas";
      e=new double [N+1];
      f=new double [N+1];
      g=new double [N+1];
      ReadInput();

      // check for tridiagonality
      for (i=1;i<=n;i++)
      {
            if (i==1)
                  for (j=3;j<=n;j++)
                        if (A[i][j]!=0)
                              fStatus=0;
            if (i==n)
                  for (j=1;j<=n-2;j++)
                        if (A[i][j]!=0)
                              fStatus=0;
            if (i>1 && i<n)
                  if (A[i][i+2]!=0 && A[i][i-2]!=0)

fStatus=0;
      }

      // compute e,f,g
      for (i=1;i<=n;i++)
      {
            f[i]=A[i][i];
            if (i<=n-1)
                  g[i]=A[i][i+1];
            if (i>=2)
                  e[i]=A[i][i-1];
      }
      for (i=2;i<=n;i++)
      {
            e[i]/=f[i-1];
            f[i] -= e[i]*g[i-1];
      }
      for (i=2;i<=n;i++)
            b[i] -= e[i]*b[i-1];
      x[n]=b[n]/f[n];
      for (i=n-1;i>=1;i--)
            x[i]=(b[i]-g[i]*x[i+1])/f[i];
      delete e,f,g;
      if (fStatus)
            DisplayResults();
      else
            DisplayError(condition);
}

The iterative technique in the program using Gauss-Seidel is illustrated through the OnGaussSeidel() function. This function checks to make sure the coefficient matrix is diagonally dominant through the Boolean variable fStatus, just like in the previous methods. The code is shown, as follows:

void CCode5::OnGaussSeidel()
{
      const int MAX=10;
      double Sum,error;
      double *xOld;
      int i,j,k;
      bool fStatus=1;
      CString condition="diagonally-dominant";
      method="Gauss-Seidel";
      xOld=new double [N+1];
      ReadInput();

      for (i=1;i<=n;i++)

{
            Sum=0;
            for (j=1;j<=n;j++)
                  if (i!=j)
                        Sum += fabs(A[i][j]);
            if (fabs(A[i][i])<=Sum)
                  fStatus=0;
      }

      for (i=1;i<=n;i++)
      x[i]=0;

      // perform iterations & update x
      for (k=0;k<=MAX;k++)
      {
            error=0;
            for (i=1;i<=n;i++)
            {
                  Sum=0;
                  for (j=1;j<=n;j++)
                        if (i!=j)
                              Sum += A[i][j]*x[j];
                  xOld[i]=x[i];
                  x[i]=(b[i]-Sum)/A[i][i];
                  error=((error>fabs(x[i]-xOld[i]))?error:
                          fabs(x[i]-xOld[i]));
            }
      }
      delete xOld;
      if (fStatus)
            DisplayResults();
      else
            DisplayError(condition);
}

The last application function is OnReset(), which responds to a mouse click on the Reset button whose id is IDC_RESET. The function resets the data in the edit boxes and prepares for a fresh input. This result is achieved by setting the string arrays sA, sb, and sx to null (""). The code is shown below:

Void CCode5::OnReset()
{
      int i,j;
      for (i=1;i<=N;i++)
      {
            for (j=1;j<=N;j++)
                  sA[i][j]="";

sb[i]="";
            sx[i]="";
      }
      SetDlgItemText(IDC_A11,sA[1][1]);
      SetDlgItemText(IDC_A12,sA[1][2]);
      SetDlgItemText(IDC_A13,sA[1][3]);
      SetDlgItemText(IDC_A14,sA[1][4]);
      SetDlgItemText(IDC_A15,sA[1][5]);
      SetDlgItemText(IDC_A21,sA[2][1]);
      SetDlgItemText(IDC_A22,sA[2][2]);
      SetDlgItemText(IDC_A23,sA[2][3]);
      SetDlgItemText(IDC_A24,sA[2][4]);
      SetDlgItemText(IDC_A25,sA[2][5]);
      SetDlgItemText(IDC_A31,sA[3][1]);
      SetDlgItemText(IDC_A32,sA[3][2]);
      SetDlgItemText(IDC_A33,sA[3][3]);
      SetDlgItemText(IDC_A34,sA[3][4]);
      SetDlgItemText(IDC_A35,sA[3][5]);
      SetDlgItemText(IDC_A41,sA[4][1]);
      SetDlgItemText(IDC_A42,sA[4][2]);
      SetDlgItemText(IDC_A43,sA[4][3]);
      SetDlgItemText(IDC_A44,sA[4][4]);
      SetDlgItemText(IDC_A45,sA[4][5]);
      SetDlgItemText(IDC_A51,sA[5][1]);
      SetDlgItemText(IDC_A52,sA[5][2]);
      SetDlgItemText(IDC_A53,sA[5][3]);
      SetDlgItemText(IDC_A54,sA[5][4]);
      SetDlgItemText(IDC_A55,sA[5][5]);
      SetDlgItemText(IDC_b1,sb[1]);
      SetDlgItemText(IDC_b2,sb[2]);
      SetDlgItemText(IDC_b3,sb[3]);
      SetDlgItemText(IDC_b4,sb[4]);
      SetDlgItemText(IDC_b5,sb[5]);
      SetDlgItemText(IDC_x1,sx[1]);
      SetDlgItemText(IDC_x2,sx[2]);
      SetDlgItemText(IDC_x3,sx[3]);
      SetDlgItemText(IDC_x4,sx[4]);
      SetDlgItemText(IDC_x5,sx[5]);
}

We have discussed various systems of linear equations, their representation, methods for solving them, and program designs in C++ as their solution. We also developed a Windows-based version of the program using the Microsoft Foundation Class library, which provides a user-friendly interface for solving the problem.

In solving a system of linear equations, it is important to consider a user-friendly interface that allows interaction between the user and the program. On the problem side, the user must understand the factors affecting the existence and uniqueness of the solution. The solution to a mathematical problem can be drawn based on the solid understanding of the concepts that govern the problem.

Providing a friendly solution to the problem can be summarized to fall into three steps. First, the conceptual and analytic solution based on the mathematical theories must be fully understood. Second, when the first step has been cleared, the next step is to derive the manual solution to the problem using a calculator as a tool. This second approach should be applicable to a small problem, like a system of 3 × 3 linear equations. Once this step is completed, the third and last step involving programming can now be embarked on comfortably. This step is a realization to the problem where all the tedious work in step one and two is simplified with the click of some buttons. A computer is the ultimate tool that helps to digest the massive calculations involved in solving a problem involving systems of linear equations.

All three steps have been discussed in this chapter, with a special attention on step three. The methods for solving the systems of linear equations in this chapter are the fundamental solution to many problems in engineering and the sciences, as will be discussed later in the book.

Check the results by running Code5.