## Introduction

This article demonstrates how to use a fraction class to create a matrix class. We all study mathematics and hence matrices at high schools. So there is a need for matrix programs in computers. But the problem is that all matrix programs/classes (as far as I know) represent matrix in the form of floating point variable arrays. In our schools, we study matrices in the form of integers and fractions, so there is need of an efficient Matrix program/class that presents matrices in the form of fractions. I wrote my fraction class because I needed a matrix class consisting of fractions.

## Background

I assume that the reader has fundamental knowledge of high school mathematics.

## Implementation

Matrix is a 2D array of fractions. The class uses simple high school mathematics formulae for its internal working, some of the functions include:

`MultiplyRow()`

for multiplying a whole row by an integer/fraction/double.`AddRow()`

for adding multiple of one row to another.`InterchangeRow()`

for interchanging two rows.`Concatenate()`

to concatenate two matrices column wise (this function is helpful when we want to create augmented matrix for solving equations).`Adjoint()`

to find adjoint of the matrix.`Transpose()`

to return transpose of the matrix.`Determinent()`

there are two functions, one finds the determinant by the common minor method while the other is a very fast. algorithm that makes use of reduced echelon form to find the determinant.`Inverse()`

there are two functions, one finds the inverse by the common adjoints method while the other uses reduced echelon form method to find it. Obviously, the second one is far more efficient that the first one which slows mainly due to recursion.`EchelonForm()`

can be useful in equation solving by Gaussian Elimination method.`ReducedEchelonForm()`

can be useful in equation solving by Gauss-Jordan method.

## Using the code

The class is very simple to use, it contains a variety of constructors for various situations.

```
int[,] intarr={{1,2,3},{1,4,9},{4,5,6}}; // initializes a 2D integer array
Matrix matrix=new Matrix( intarr ); // initializes the matrix with the 2D array,
// note that the array has been converted to fractions
Console.WriteLine(matrix); //display the matrix
```

The following code block demonstrates some functions, see how simple they are to use:

```
Console.WriteLine( matrix.Transpose() );
// displays transpose
Console.WriteLine( matrix.Inverse() ); // displays inverse of the matrix
Console.WriteLine( matrix.Inverse()*matrix );
// obviously this will display an identity matrix
// (recall your school mathematics)
Console.WriteLine( matrix.EchelonForm() ); // displays Echelon form
Console.WriteLine( matrix+matrix.Transpose() );
// forgotten high school maths? this will display a
// symmetric matrix (still forgotten what is symmetric matrix,
// buy some book of mathematics :) )
```

## Application: Equation Solving by this class

Consider the following system of equation:

```
X + 2Y - 3Z = 10
4X - 2Y - Z = 6
X - Y - 2Z = -3
```

Using Gauss-Jordan method, let us solve it using the matrix class.

int[,] arrA={{1,2,-3},{4,-2,-1},{1,-1,-2}}; //array of coefficients int[,] arrB={ {2},{5},{-3}}; // array of constants Matrix matrixA=new Matrix( arrA ); // convert array to matrix Matrix matrixB=new Matrix( arrB ); // convert array to matrix // get augmented matrix by concatenation Matrix augmentedMatrix=Matrix.Concatenate( matrixA, matrixB ); Console.WriteLine("Augmented matrix for the given system of equation is" + augmentedMatrix); // evaluate reduced echelon form Matrix reducedEchForm=augmentedMatrix.ReducedEchelonForm(); Console.WriteLine("Reduced Echelon form for the given augmented matrix is" + reducedEchForm); // the last column of augmented matrix gives the answer values Console.WriteLine("Value for X is " + reducedEchForm[0,3] ); Console.WriteLine("Value for Y is " + reducedEchForm[1,3] ); Console.WriteLine("Value for Z is " + reducedEchForm[2,3] );

The above code yield values X=65/23, Y=52/23, Z=41/23.

## Other Applications

Yes, matrices are not over here. In a similar fashion, the class can be used in Linear programming problems. (I hope you will also be familiar with Economics. By the way, I implemented this class because I wanted to verify my results in linear programming problems.) The class can also be used in various transformations (a topic of analytic geometry), Eigen Value/Eigen Space problems, and in other problems related to vector space, etc.

## History

What's new in version 1.1

- Added
`DeterminentFast()`

method - Added
`InverseFast()`

method - Renamed
`ConvertToString`

to (override)`ToString()`

- Fixed some minor bugs