# Matrix MathMethods

A matrix is a multidimensional list of values. Most often they are rectangular arrays of numbers or variables. e.g.

A =
 B, 3, 5; 2, C, 99; -17, 21, D;

Matrixes can be added, multiplied, or scaled. They can NOT be divided, but there is an "inverse" which is sort of like the reciprocal, so mulitiplying by the inverse comes close. The size of a matrix is defined by the number of rows and columns that it contains. A matrix with m rows and n columns is called an m x n matrix or m-by-n matrix, while m and n are called its dimensions. For example, the matrix A above is a 3 x 3 matrix.

Only matrixes of the same size may be added. Each element of the first matrix is added to the corresponding element of the second to produce the corresponding element in the result. For example:

 A, B, C; D, E, F; G, H, I;
+
 J, K, L; M, N, O; P, Q, R;
=
 A+J, B+K, C+L; D+M, E+N, F+O; G+P, H+Q, I+R;

```matrix_add(array a, b) {
n = sizeof(a[0]) //count rows in a
assert( n == sizeof(b[0] ) //rows in a must match rows in b
m = sizeof(a[1]) //count columns in a
assert( m == sizeof(b[1] ) //cols in a must match cols in b
array c[n, m]
for (i = 0; i<n; i++) {
for (j = 0; j<p; j++) {
c[i,j] = a[i,j] + b[i,j]
}
}
return c
}

```

## Multiplication: Matrix times Matrix

The number of columns of the 1st matrix must equal the number of rows of the 2nd matrix.

And the result will have the same number of rows as the 1st matrix, and the same number of columns as the 2nd matrix.

Every number in each row in the 1st matrix is multiplied by every number in each col in the 2nd.

Note: A vector is just a special case of a Matrix with only one row or column.

Note: In Matrix Multiplication, unlike with standard numbers, the order of operations matters. AB may not be equal to BA.

 A, B, C; G, H, I;
x
 J, L; M, O; P, R;
=
 A*J+B*M+C*P, A*L+B*O+C*R; G*J+H*M+I*P, G*L+H*O+I*R;

```matrix_mult(array a, b) {
n = sizeof(a[0]) //count rows in a
m = sizeof(a[1]) //count columns in a
assert( m == sizeof(b[0] ) //columns in a must match rows in b
p = sizeof(b[1]) // count columns in b
array c[n, p]
for (i = 0; i<n; i++) {
for (j = 0; j<p; j++) {
for (k = 0; k<m; k++) {
c[i,j] = a[i,k] + b[k,j]
}
}
}
return c
}
```

## Scaling: Multiplication by a Scaler

Multiplying a matrix by a single number scales it. For example:

 A, B, C; G, H, I;
x S =
 A*S, B*S, C*S; G*S, H*S, I*S;

```array matrix_mult(array a, scaler s) {
n = sizeof(a[0]) //count rows in a
m = sizeof(a[1]) //count columns in a
array c[n, m]
for (i = 0; i<n; i++) {
for (j = 0; j<m; j++) {
c[i,j] = a[i,j] * s
}
}
return c
}
```

## Inverse:

``` function inverse(M){
// I use Guassian Elimination to calculate the inverse:
// (1) 'augment' the matrix (left) by the identity (on the right)
// (2) Turn the matrix on the left into the identity by elemetry row ops
// (3) The matrix on the right is the inverse (was the identity matrix)
// There are 3 elemtary row ops: (I combine b and c in my code)
// (a) Swap 2 rows
// (b) Multiply a row by a scalar

//if the matrix isn't square: exit (error)
if(M.length !== M[0].length){return;}

//create the identity matrix (I), and a copy (C) of the original
var i=0, ii=0, j=0, dim=M.length, e=0, t=0;
var I = [], C = [];
for(i=0; i<dim; i+=1){
// Create the row
I[I.length]=[];
C[C.length]=[];
for(j=0; j<dim; j+=1){
//if we're on the diagonal, put a 1 (for identity)
if(i==j){ I[i][j] = 1; }
else{ I[i][j] = 0; }
// Also, make the copy of the original
C[i][j] = M[i][j];
}
}

// Perform elementary row operations
for(i=0; i<dim; i+=1){
// get the element e on the diagonal
e = C[i][i];

// if we have a 0 on the diagonal (we'll need to swap with a lower row)
if(e==0){
//look through every row below the i'th row
for(ii=i+1; ii<dim; ii+=1){
//if the ii'th row has a non-0 in the i'th col
if(C[ii][i] != 0){
//it would make the diagonal have a non-0 so swap it
for(j=0; j<dim; j++){
e = C[i][j];       //temp store i'th row
C[i][j] = C[ii][j];//replace i'th row by ii'th
C[ii][j] = e;      //repace ii'th by temp
e = I[i][j];       //temp store i'th row
I[i][j] = I[ii][j];//replace i'th row by ii'th
I[ii][j] = e;      //repace ii'th by temp
}
//don't bother checking other rows since we've swapped
break;
}
}
//get the new diagonal
e = C[i][i];
//if it's still 0, not invertable (error)
if(e==0){return}
}

// Scale this row down by e (so we have a 1 on the diagonal)
for(j=0; j<dim; j++){
C[i][j] = C[i][j]/e; //apply to original matrix
I[i][j] = I[i][j]/e; //apply to identity
}

// Subtract this row (scaled appropriately for each row) from ALL of
// the other rows so that there will be 0's in this column in the
// rows above and below this one
for(ii=0; ii<dim; ii++){
// Only apply to other rows (we want a 1 on the diagonal)
if(ii==i){continue;}

// We want to change this element to 0
e = C[ii][i];

// Subtract (the row above(or below) scaled by e) from (the
// current row) but start at the i'th column and assume all the
// stuff left of diagonal is 0 (which it should be if we made this
// algorithm correctly)
for(j=0; j<dim; j++){
C[ii][j] -= e*C[i][j]; //apply to original matrix
I[ii][j] -= e*I[i][j]; //apply to identity
}
}
}

//we've done all operations, C should be the identity
//matrix I should be the inverse:
return I;
}
```

## Determinant:

The Determinant basically compares diagonals in the Matrix. e.g. for a 2x2 Matrix,

A =
 a, b; c, d;

the determinant is a*d - b * c. So if the upper left to lower right is bigger, it will be positive. If the upper right to lower left is bigger, it will be negative. If they are equal, it will be zero.

```// https://coderbyte.com/tutorial/determinant-of-a-matrix-in-javascript-using-laplace-expansion
function determinant(M) {
if (M.length==2) { return (M[0][0]*M[1][1])-(M[0][1]*M[1][0]); }
for (var i=0; i< M.length; i++) {
}
}

function deleteRowCol(M,index) {
var temp = [];
for (var i=0; i<M.length; i++) { temp.push(M[i].slice(0)); }
temp.splice(0,1);
for (var i=0; i<temp.length; i++) { temp[i].splice(index,1); }
return temp;
}
```

 file: /Techref/method/math/matrix.htm, 13KB, , updated: 2019/2/5 23:35, local time: 2019/8/20 00:40, TOP NEW HELP FIND:  34.238.189.171:LOG IN

 ©2019 These pages are served without commercial sponsorship. (No popup ads, etc...).Bandwidth abuse increases hosting cost forcing sponsorship or shutdown. This server aggressively defends against automated copying for any reason including offline viewing, duplication, etc... Please respect this requirement and DO NOT RIP THIS SITE. Questions?Please DO link to this page! Digg it! / MAKE! /  Matrix Math Methods

After you find an appropriate page, you are invited to your to this massmind site! (posts will be visible only to you before review) Just type in the box and press the Post button. (HTML welcomed, but not the <A tag: Instead, use the link box to link to another page. A tutorial is available Members can login to post directly, become page editors, and be credited for their posts.

Attn spammers: All posts are reviewed before being made visible to anyone other than the poster.
 Did you find what you needed? "No. I'm looking for: " "No. Take me to the search page." "No. Take me to the top so I can drill down by catagory" "No. I'm willing to pay for help, please refer me to a qualified consultant" "No. But I'm interested. me at when this page is expanded."

.