brl.mod/matrix.mod/doc/intro.bbdoc

Matrices are fundamental mathematical constructs used in various fields, such as computer graphics,
physics simulations, and linear algebra. They are especially useful for representing linear transformations,
including rotations, translations, and scaling operations. In the context of graphics and 3D geometry,
matrices are commonly used to manipulate vertices and objects in a scene, transforming their coordinates
and orientations.

A matrix is a rectangular array of numbers, organized into rows and columns. In BlitzMax,
`brl.matrix` provides several structs to work with matrices of different
sizes and types, such as #SMat2D, #SMat3D, #SMat4D, #SMat2F, #SMat3F, #SMat4F, #SMat2I, #SMat3I, and #SMat4I.
The name of each struct indicates its size and the primitive type it uses: #Double, #Float, or #Int.
In our examples, we'll focus primarily on the #Double structs, but the same concepts apply to the other
structs as well.

The following is a brief introduction to the three main types of matrices used in graphics and 3D geometry, which
BlitzMax provides structs for, along with a high-level overview of their applications:

## Types of Matrices

### 2x2 Matrices
A 2x2 matrix, represented by the #SMat2D, #SMat2F and #SMat2I structs, is primarily used for 2D linear transformations,
such as rotation and scaling. These matrices can be applied to 2D vectors, transforming their
coordinates accordingly. For example, a 2x2 rotation matrix can be used to rotate a 2D vector
around the origin by a specified angle.

### 3x3 Matrices
3x3 matrices, represented by the #SMat3D, #SMat3F and #SMat3I structs, are commonly used for 3D linear transformations that do
not involve translation, such as rotation and scaling. These matrices can be applied to 3D vectors,
transforming their coordinates without changing their position in the scene. For example, a 3x3 rotation
matrix can be used to rotate a 3D vector around a specific axis by a given angle.

The following example demonstrates the use of 3x3 matrices, by creating a simple solar system. The sun
is represented by a yellow circle, and the planets are represented by blue circles. The planets are
rotating around the sun, and their positions are calculated using 3x3 matrices.

```blitzmax
SuperStrict

Framework SDL.SDLRenderMax2D
Import brl.matrix

Graphics 800, 600, 0

Local sunX:Float = GraphicsWidth() / 2
Local sunY:Float = GraphicsHeight() / 2
Local sunRadius:Float = 50

Local planets:TPlanet[] = [New TPlanet(150, 20, 0.7), New TPlanet(200, 15, 0.5), New TPlanet(250, 10, 0.3)]

While Not KeyHit(KEY_ESCAPE)
    Cls

    ' Draw the sun
    SetColor(255, 255, 0)
    DrawOval(sunX - sunRadius, sunY - sunRadius, sunRadius * 2, sunRadius * 2)

    ' Draw the planets
    For Local planet:TPlanet = EachIn planets
        planet.Draw(sunX, sunY)
    Next

    Flip
Wend

Type TPlanet
    Field distance:Float
    Field radius:Float
    Field angle:Float
    Field speed:Float

    Method New(distance:Float, radius:Float, speed:Float)
        Self.distance = distance
        Self.radius = radius
        Self.speed = speed
    End Method

	Method Draw(centerX:Float, centerY:Float)
		' Calculate the planet's position
		Local planetMatrix:SMat3D = SMat3D.Identity()
		planetMatrix = planetMatrix.Rotate(angle)
		planetMatrix = planetMatrix.Translate(New SVec3D(distance, 0, 0))
		Local planetPos:SVec3D = planetMatrix.Apply(New SVec3D(0, 0, 1))
	
		' Draw the planet
		SetColor(0, 0, 255)
		DrawOval(Float(centerX + planetPos.x - radius), Float(centerY + planetPos.y - radius), radius * 2, radius * 2)
	
		' Update the angle for the next frame
		angle :+ speed
	End Method
End Type
```

### 4x4 Matrices
4x4 matrices, represented by the #SMat4D, #SMat4F and #SMat4I structs, are the most versatile and widely used matrices in 3D
graphics. They can represent any combination of linear transformations, such as rotation, scaling,
and translation. A 4x4 matrix can be applied to a 3D vector, transforming its position, orientation,
and scale in the scene. For example, a 4x4 transformation matrix can be used to move an object in 3D space,
rotate it around a specific axis, and scale it uniformly or non-uniformly.

Creating a 3D-like effect in 2D can be achieved using simple orthogonal projection. In this example,
we will create a rotating cube using a 4x4 transformation matrix to apply rotation, scaling, and translation. 

```blitzmax
SuperStrict

Framework SDL.SDLRenderMax2D
Import brl.matrix

Graphics 800, 600, 0

Local cube:TCube = New TCube
Local angle:Float = 0

Local centerX:Int = GraphicsWidth() / 2
Local centerY:Int = GraphicsHeight() / 2

While Not KeyHit(KEY_ESCAPE)
    Cls

    ' Create the transformation matrix..
    ' Start with an identity matrix as the initial transformation.
    Local matrix:SMat4D = SMat4D.Identity()
    ' Move the object away from the camera along the Z-axis by a distance of 6 units.
    ' This translation ensures that the object is visible and centered in the view.
    matrix = matrix.Translate(New SVec3D(0, 0, -6))
    ' Rotate the object around the Z-axis (blue axis) by an angle scaled by 1.2.
    ' This rotation is applied first to achieve a "rolling" effect.
    matrix = matrix.Rotate(New SVec3D(0, 0, 1), angle * 1.2)
    ' Rotate the object around the Y-axis (green axis) by an angle scaled by 0.7.
    ' This rotation is applied after the first rotation, creating a "pitching" effect.
    matrix = matrix.Rotate(New SVec3D(0, 1, 0), angle * 0.7)
    ' Finally, rotate the object around the X-axis (red axis) by the base angle.
    ' This rotation is applied last, creating a "yawing" effect.
    matrix = matrix.Rotate(New SVec3D(1, 0, 0), angle)

    ' Draw cube
    cube.Draw(matrix, 100, centerX, centerY)

    Flip
    angle :+ 0.5
Wend

Type TCube
    Field vertices:Float[24] ' 8 vertices, each with 3 coordinates
    Field edges:Int[24] ' 12 edges, each with 2 vertex indices

    Method New()
        vertices = [ -1:Float, -1:Float, -1:Float, 1:Float, -1:Float, -1:Float, 1:Float, 1:Float, -1:Float, -1:Float, ..
					1:Float, -1:Float, -1:Float, -1:Float, 1:Float, 1:Float, -1:Float, 1:Float, 1:Float, 1:Float, ..
					1:Float, -1:Float, 1:Float, 1:Float ]
        edges = [ 0, 1, 1, 2, 2, 3, 3, 0, ..
                  4, 5, 5, 6, 6, 7, 7, 4, ..
                  0, 4, 1, 5, 2, 6, 3, 7 ]
    End Method

    Method Draw(matrix:SMat4D, scale:Float = 1, centerX:Int, centerY:Int)
        Local transformedVertices:Float[24]

		' Apply transformation and orthographic projection
		For Local i:Int = 0 Until 24 Step 3
			Local vertex:SVec3D = New SVec3D(vertices[i], vertices[i + 1], vertices[i + 2])
			vertex = matrix.Apply(vertex)
			transformedVertices[i] = centerX + (scale * vertex.x)
			transformedVertices[i + 1] = centerY - (scale * vertex.y)
		Next

		' Draw edges
		For Local i:Int = 0 Until 24 Step 2
			DrawLine(transformedVertices[edges[i] * 3], transformedVertices[edges[i] * 3 + 1],
					transformedVertices[edges[i + 1] * 3], transformedVertices[edges[i + 1] * 3 + 1])
		Next

    End Method
End Type
```

## Column-Major vs. Row-Major Matrices

In `brl.matrix`, we use column-major ordering for matrices. Column-major ordering is a convention
in which elements are stored column by column in memory. It is the opposite of row-major ordering, where
elements are stored row by row. This distinction is important when performing operations like matrix
multiplication or when applying transformations to vectors or other matrices.

Column-major ordering is commonly used in graphics programming and some mathematical libraries. In
this convention, when applying transformations, the order in which they are applied is reversed
compared to row-major ordering. This means that when you want to apply multiple transformations,
you should apply them in the reverse order that you would with row-major ordering.

For example, in column-major ordering, to rotate an object around the X, Y, and Z axes and then
translate it, you would first apply the translation, then the rotation around the Z axis, followed
by the rotation around the Y axis, and finally the rotation around the X axis.

## Determinant, Inverse, and Transpose in Matrices

### Determinant

The determinant is a scalar value associated with square matrices that carries essential
information about the matrix's properties. It has several important geometric interpretations
and applications in linear algebra.

In the context of 2D transformations, the determinant represents the area scaling factor when a
matrix is applied to a vector. If the determinant is positive, the transformation preserves the
orientation; if it's negative, the orientation is reversed. A determinant equal to zero indicates
that the transformation collapses the vector onto a lower-dimensional subspace (e.g., a line or a point),
making the matrix singular and non-invertible.

Mathematically, the determinant of a 2x2 matrix is calculated as follows:

```
|A| = |a  b|
      |c  d|

|A| = ad - bc
```

Here's an example illustrating how to calculate the determinant of a 2x2 matrix using the #SMat2D struct:

```blitzmax
SuperStrict

Framework BRL.StandardIO
Import BRL.Matrix

' Define matrix elements
Local a:Double = 3.0
Local b:Double = 2.0
Local c:Double = 5.0
Local d:Double = 4.0

' Create a 2x2 matrix
Local mat:SMat2D = New SMat2D(a, b, c, d)

' Calculate the determinant
Local det:Double = mat.Determinant()

' Print the determinant
Print "Determinant: " + det
```
When you run this example, it will create a 2x2 matrix with the specified elements,
calculate the determinant using the `Determinant()` method provided by #SMat2D, and print the resulting
determinant value. In this case, the output will be:
```
Determinant: -2.0
```

For a 3x3 matrix, the determinant can be calculated using the following formula:
```
|A| = |a  b  c|
      |d  e  f|
      |g  h  i|

|A| = a(ei - fh) - b(di - fg) + c(dh - eg)
```

Here's an example illustrating how to calculate the determinant of a 3x3 matrix using the #SMat3D struct:
```blitzmax
SuperStrict

Framework BRL.StandardIO
Import BRL.Matrix

' Define matrix elements
Local a:Double = 1.0
Local b:Double = 2.0
Local c:Double = 3.0
Local d:Double = 4.0
Local e:Double = 5.0
Local f:Double = 6.0
Local g:Double = 7.0
Local h:Double = 8.0
Local i:Double = 9.0

' Create a 3x3 matrix
Local mat:SMat3D = New SMat3D(a, b, c, d, e, f, g, h, i)

' Calculate the determinant
Local det:Double = mat.Determinant()

' Print the determinant
Print "Determinant: " + det
```

When you run this example, it will create a 3x3 matrix with the specified elements,
calculate the determinant using the `Determinant()` method provided by #SMat3D, and print the
resulting determinant value. In this case, the output will be:
```
Determinant: 0.0
```

### Inverse

The inverse of a matrix is another matrix that, when multiplied with the original matrix,
results in the identity matrix. In other words, for a matrix A, its inverse A⁻¹ exists if
and only if A * A⁻¹ = A⁻¹ * A = I, where I is the identity matrix. Not all matrices have
inverses; only square matrices (i.e., matrices with the same number of rows and columns) may
have inverses, and even then, not all square matrices are invertible.

For a 2x2 matrix:
```
| a  b |
| c  d |
```
The inverse can be calculated using the following formula:
```
1 / (ad - bc) * |  d  -b |
                | -c   a |
```

The term (ad - bc) is the determinant of the matrix. If the determinant is zero, the matrix
is singular and does not have an inverse.

For a 3x3 matrix, the process is more complicated and involves finding the matrix of minors,
the matrix of cofactors, and finally, the adjugate matrix. The inverse can then be computed
by dividing the adjugate matrix by the determinant of the original matrix.

Here is an example for finding the inverse of a 2x2 matrix using the #SMat2D struct:
```blitzmax
SuperStrict

Framework brl.standardio
Import brl.matrix

' Create a 2x2 matrix
Local a:Double = 3
Local b:Double = 2
Local c:Double = 5
Local d:Double = 3

Local mat:SMat2D = New SMat2D(a, b, c, d)

' Calculate the inverse
Local matInverse:SMat2D = mat.Invert()

' Print the original and inverse matrices
Print "Original matrix:~n" + mat.ToString()
Print "Inverse matrix:~n" + matInverse.ToString()
```
When you run this example, it will output the original 2x2 matrix and its inverse:
```
Original matrix:
3.000 2.000
5.000 3.000
Inverse matrix:
-1.000 0.667
 1.667 -1.000
```


And here is an example for finding the inverse of a 3x3 matrix using the #SMat3D struct:
```blitzmax
SuperStrict

Framework brl.standardio
Import brl.matrix

' Create a 3x3 matrix
Local a:Double = 1
Local b:Double = 2
Local c:Double = 3
Local d:Double = 0
Local e:Double = 1
Local f:Double = 4
Local g:Double = 5
Local h:Double = 6
Local i:Double = 0

Local mat:SMat3D = New SMat3D(a, b, c, d, e, f, g, h, i)

' Calculate the inverse
Local matInverse:SMat3D = mat.Invert()

' Print the original and inverse matrices
Print "Original matrix: " + mat.ToString()
Print "Inverse matrix: " + matInverse.ToString()
```
When you run this example, it will output the original 3x3 matrix and its inverse:
```
Original matrix:
 1.000 2.000 3.000
 0.000 1.000 4.000
 5.000 6.000 0.000
Inverse matrix:
 -24.000 18.000 5.000
 20.000 -15.000 -4.000
 -5.000 4.000 1.000
```

### Transpose

The transpose of a matrix is a new matrix obtained by interchanging its rows and columns.
In other words, the transpose of a matrix A is a new matrix Aᵀ, where the element Aᵀ[i, j] = A[j, i].
The transpose operation has several important properties and applications in linear algebra, including
simplifying matrix equations and working with symmetric matrices.

For a 2x2 matrix A:
```
A = |a  b|       Aᵀ = |a  c|
    |c  d|            |b  d|
```

For a 3x3 matrix A:
```
A = |a  b  c|       Aᵀ = |a  d  g|
    |d  e  f|            |b  e  h|
    |g  h  i|            |c  f  i|
```

Here's an example illustrating how to calculate the transpose of a 2x2 matrix using the #SMat2D struct.
```blitzmax
SuperStrict

Framework brl.standardIO
Import brl.matrix

' Define matrix elements
Local a:Double = 1.0
Local b:Double = 2.0
Local c:Double = 3.0
Local d:Double = 4.0

' Create a 2x2 matrix
Local mat:SMat2D = New SMat2D(a, b, c, d)

' Calculate the transpose
Local matTranspose:SMat2D = mat.Transpose()

' Print the original and transposed matrices
Print "Original matrix:~n" + mat.ToString()
Print "Transposed matrix:~n" + matTranspose.ToString()
```
When you run this example, it will create a 2x2 matrix with the specified elements, calculate
the transpose using the Transpose() method provided by the #SMat2D struct, and print the original
and transposed matrices. In this case, the output will be:
```
Original matrix:
1.0,  2.0
3.0,  4.0
Transposed matrix:
1.0  3.0
2.0  4.0
```

And an example for calculating the transpose of a 3x3 matrix using the #SMat3D struct.
```blitzmax
SuperStrict

Framework brl.standardIO
Import brl.matrix

' Define matrix elements
Local a:Double = 1.0
Local b:Double = 2.0
Local c:Double = 3.0
Local d:Double = 4.0
Local e:Double = 5.0
Local f:Double = 6.0
Local g:Double = 7.0
Local h:Double = 8.0
Local i:Double = 9.0

' Create a 3x3 matrix
Local mat:SMat3D = New SMat3D(a, b, c, d, e, f, g, h, i)

' Calculate the transpose
Local matTranspose:SMat3D = mat.Transpose()

' Print the original and transposed matrices
Print "Original matrix: " + mat.ToString()
Print "Transposed matrix: " + matTranspose.ToString()
```

When you run this example, it will create a 3x3 matrix with the specified elements,
calculate the transpose using the Transpose() method provided by the #SMat3D struct, and print the
original and transposed matrices. In this case, the output will be:
```
Original matrix:
1.0  2.0  3.0
4.0  5.0  6.0
7.0  8.0  9.0
Transposed matrix:
1.0  4.0  7.0
2.0  5.0  8.0
3.0  6.0  9.0
```


Understanding the transpose concept and its properties is important when working with matrices
in your BlitzMax projects. The transpose operation can help simplify matrix equations and work with
symmetric matrices, among other applications. By transposing a matrix, you can manipulate its elements
and apply various transformations as required in your project.

## Scaling, rotation, and shearing matrices

Scaling, rotation, and shearing matrices are fundamental linear transformations used in various fields, such as
computer graphics, physics simulations, and geometric modeling. These transformations can be applied to vectors or points
to change their position, orientation, or shape. 

### Scaling matrices

Scaling is the process of resizing an object uniformly or non-uniformly along its axes. Scaling matrices are diagonal matrices
that have scaling factors along the diagonal elements, and zeros elsewhere.

For 2D scaling:

```
| sx  0  |
| 0   sy |
```

For 3D scaling:
```
| sx  0   0  |
| 0   sy  0  |
| 0   0   sz |
```

Here, sx, sy, and sz are the scaling factors along the x, y, and z axes, respectively. To apply the scaling transformation, you multiply
the scaling matrix by the vector or point you want to scale.

### Rotation matrices

Rotation is the process of rotating an object around a point or an axis. Rotation matrices are used to represent the rotation
transformations in both 2D and 3D spaces.

For 2D rotation around the origin by angle θ:

```
| cos(θ)  -sin(θ) |
| sin(θ)   cos(θ) |
```

For 3D rotation around an arbitrary axis (x, y, z) by angle θ, the rotation matrix is more complex. One common method is using
the axis-angle representation, which involves the Rodrigues' rotation formula. The formula for the 3D rotation matrix is as follows:

```
R = I + sin(θ) * K + (1 - cos(θ)) * K^2
```

Where `I` is the identity matrix, `θ` is the angle of rotation, and `K` is the skew-symmetric matrix representation of the axis vector.

### Shearing matrices

Shearing is the process of transforming an object by displacing its points along one axis based on the displacement of points along a
parallel axis. Shearing matrices are used to represent these transformations.

For 2D shearing:

```
| 1  shx |
| shy  1 |
```

For 3D shearing along the x-axis:

```
| 1  shy  shz |
| 0   1    0  |
| 0   0    1  |
```

And similar matrices can be defined for shearing along the y-axis and z-axis. Here, `shx`, `shy`, and `shz` represent the shearing factors.

When applying these transformations, it's important to consider the order of operations, as matrix multiplication is not commutative.
Typically, scaling and shearing are applied first, followed by rotation, and finally translation. Also, remember that these matrices should
be applied to homogeneous coordinates for translation to work correctly. In 3D graphics, this often involves using 4x4 matrices with an
additional row and column for the homogeneous coordinate.

## Matrix multiplication

Matrix multiplication is an essential operation in linear algebra and has numerous applications in computer graphics, physics, and other fields.
Multiplying two matrices involves specific rules, and it's important to understand the dimensions of the matrices and how to perform the
multiplication element-wise.

### Rules for Matrix Multiplication

Given two matrices A and B, the product AB can only be computed if the number of columns in A is equal to the number of rows in B.
If matrix A has dimensions m × n and matrix B has dimensions n × p, then the product AB will have dimensions m × p.

`(AB)_ij = A_i1 * B_1j + A_i2 * B_2j + ... + A_in * B_nj`

where (AB)_ij represents the element in the i-th row and j-th column of the resulting matrix AB.

### Element-wise matrix multiplication

To multiply two matrices element-wise, follow these steps:

1. Verify that the dimensions of the matrices are compatible for multiplication. The number of columns in matrix A must be equal
to the number of rows in matrix B.

2. Create a new matrix C with dimensions m × p, where m is the number of rows in matrix A and p is the number of columns in matrix B.

3. For each element (i, j) in the resulting matrix C, calculate the value as the sum of the products of the corresponding row elements in matrix A
and the column elements in matrix B:
`C_ij = A_i1 * B_1j + A_i2 * B_2j + ... + A_in * B_nj`
Iterate through all elements in matrix C, computing their values using the above formula.

4. The resulting matrix C represents the product of matrices A and B.

It's important to note that matrix multiplication is not commutative, meaning that AB ≠ BA in general. However, it is
associative (A(BC) = (AB)C) and distributive over addition (A(B+C) = AB + AC).

The `CompMul()` method can be used to perform element-wise matrix multiplication.

### Matrix multiplication using the dot product

Matrix multiplication is a fundamental operation in linear algebra, and it is performed using the dot product.
It is important to understand that matrix multiplication is not the same as element-wise multiplication. In matrix
multiplication, the dot product of the rows of the first matrix and the columns of the second matrix is used to calculate the resulting matrix elements.

Consider two matrices, A and B, where A has dimensions m x n (m rows and n columns), and B has dimensions p x q (p rows and q columns).
For matrix multiplication to be possible, the number of columns in A (n) must be equal to the number of rows in B (p). The resulting
matrix, C, will have dimensions m x q (m rows and q columns).

Here is the formula for matrix multiplication using the dot product:

C[i][j] = Σ (A[i][k] * B[k][j]) for k = 0 to n-1

where i ranges from 0 to m-1 and j ranges from 0 to q-1.

In other words, each element in the resulting matrix C is the dot product of the i-th row of matrix A and the j-th column of matrix B.

Let's see an example with two 3x3 matrices:

```
A = | a b c |     B = | p q r |
    | d e f |         | s t u |
    | g h i |         | v w x |

C = | (a*p + b*s + c*v) (a*q + b*t + c*w) (a*r + b*u + c*x) |
    | (d*p + e*s + f*v) (d*q + e*t + f*w) (d*r + e*u + f*x) |
    | (g*p + h*s + i*v) (g*q + h*t + i*w) (g*r + h*u + i*x) |
```

The `Operator *()` method can be used to perform matrix multiplication using the dot product.

### Vector Multiplication

Matrix-vector multiplication is a fundamental operation in linear algebra, computer graphics, and many other fields. This operation
is used to apply transformations, such as scaling, rotation, and translation, to points and vectors in 2D and 3D space. In this section,
we will discuss how to multiply a matrix by a vector and how this operation can be applied to 2D and 3D vectors in BlitzMax.

#### 2D Vectors ( #SVec2D, #SVec2F, #SVec2I )

To multiply a 2x2 matrix by a 2D vector, perform the following steps:

1. Multiply each element of the first row of the matrix by the corresponding element of the vector.
2. Sum the results from step 1 to obtain the first element of the resulting vector.
3. Multiply each element of the second row of the matrix by the corresponding element of the vector.
4. Sum the results from step 3 to obtain the second element of the resulting vector.

Mathematically, this can be represented as:

```
| a c | | x |   | a * x + c * y |
| b d | | y | = | b * x + d * y |
```

#### 3D Vectors ( #SVec3D, #SVec3F, #SVec3I )

To multiply a 3x3 matrix by a 3D vector, follow these steps:

1. Multiply each element of the first row of the matrix by the corresponding element of the vector.
2. Sum the results from step 1 to obtain the first element of the resulting vector.
3. Multiply each element of the second row of the matrix by the corresponding element of the vector.
4. Sum the results from step 3 to obtain the second element of the resulting vector.
5. Multiply each element of the third row of the matrix by the corresponding element of the vector.
6. Sum the results from step 5 to obtain the third element of the resulting vector.

Mathematically, this can be represented as:

```
| a d g | | x |   | a * x + d * y + g * z |
| b e h | | y | = | b * x + e * y + h * z |
| c f i | | z |   | c * x + f * y + i * z |
```

You can use the `Apply()` method to multiply a matrix by a vector.

Here's an example:

```blitzmax
Local mat2D:SMat2D = SMat2D.Identity()
Local vec2D:SVec2D = New SVec2D(2, 3)
Local result2D:SVec2D = mat2D.Apply(vec2D)

Local mat3D:SMat3D = SMat3D.Identity()
Local vec3D:SVec3D = New SVec3D(2, 3, 4)
Local result3D:SVec3D = mat3D.Apply(vec3D)
```

## The Identity Matrix

The identity matrix is a special square matrix that has ones on the diagonal and zeros elsewhere. In mathematical notation,
an identity matrix of size n x n is denoted as Iₙ. Here's an example of a 3x3 identity matrix:

```
I₃ = | 1 0 0 |
     | 0 1 0 |
     | 0 0 1 |
```

The identity matrix plays a crucial role in matrix algebra, as it serves as the "neutral element" for matrix multiplication. When you
multiply any matrix by the identity matrix, the result is the original matrix unchanged. Mathematically, this property can be written as:

A * Iₙ = A

Iₙ * A = A

where A is any n x n matrix.

This property is analogous to the number 1 in scalar multiplication. Just as multiplying any number by 1 leaves the number unchanged
(e.g., 7 * 1 = 7), multiplying any matrix by the identity matrix leaves the matrix unchanged.

The identity matrix is also important for other matrix operations. For example, when calculating the inverse of a matrix, the goal is to
find a matrix B such that A * B = Iₙ. When this condition is met, matrix B is the inverse of matrix A.

The `Identity()` method allows you create an identity matrix.

## Linear Transformations

Matrices are often used to represent linear transformations in various fields, including computer graphics and linear algebra.
A linear transformation is a function that maps vectors from one vector space to another while preserving the operations of vector
addition and scalar multiplication. In this section, we will discuss some of the key properties of linear transformations and how
matrices can be used to represent them.

### Linearity

A linear transformation, T, has the property of linearity, which means it satisfies the following conditions:

1. T(u + v) = T(u) + T(v) for all vectors u and v.
2. T(c * u) = c * T(u) for all vectors u and any scalar c.

This property ensures that the transformation maintains the structure of the vector space, preserving
parallelism and proportions between the vectors.

### Invertibility

A linear transformation is invertible if there exists another transformation, called its inverse, that can undo the effect of the original
transformation. In terms of matrices, a matrix A is invertible if there exists a matrix B such that AB = BA = I, where I is the identity matrix.
Invertible transformations are essential in many applications, as they allow us to reverse the effects of a transformation and recover the original data.

### Effect on Geometry

Linear transformations can have various effects on the geometry of shapes, including:

1. Scaling: A transformation that changes the size of a shape, either uniformly or non-uniformly along different axes.
2. Rotation: A transformation that rotates a shape around a specified point or axis.
3. Shearing: A transformation that distorts a shape by shifting its points along one axis relative to the other axis.

## Orthogonal and Orthonormal Matrices

Orthogonal and orthonormal matrices are special types of square matrices that have unique properties, making them particularly useful in
various applications such as computer graphics, physics, and linear algebra.

### Orthogonal Matrices

A matrix A is called an orthogonal matrix if its transpose, A^T, is also its inverse, i.e., A^T * A = A * A^T = I, where I is the identity
matrix. In other words, the columns (and rows) of an orthogonal matrix are orthogonal to each other, meaning they form a 90-degree angle
and their dot product is zero.

The geometric interpretation of orthogonal matrices is that they represent transformations that preserve lengths and angles, such as
rotations and reflections.

### Orthonormal Matrices

An orthonormal matrix is an orthogonal matrix where the columns (and rows) are not only orthogonal but also have unit length (i.e., they
are normalized). Orthonormal matrices simplify calculations in various applications, as they do not change the length of the vectors they transform.

### Applications

Orthogonal and orthonormal matrices play a significant role in computer graphics, as they are used to represent transformations that maintain
the geometry of 3D objects. For instance, they can be employed to create rotation matrices, which are essential for rotating objects in 3D space.

Here's a BlitzMax example demonstrating the use of an orthonormal matrix to represent a 3D rotation:

```blitzmax
Local angleX:Float = 30 ' in degrees
Local angleY:Float = 45 ' in degrees
Local angleZ:Float = 60 ' in degrees

' Create orthonormal rotation matrices for each axis
Local rotationMatrixX:SMat3D = SMat3D.RotationX(angleX)
Local rotationMatrixY:SMat3D = SMat3D.RotationY(angleY)
Local rotationMatrixZ:SMat3D = SMat3D.RotationZ(angleZ)

' Combine the rotations
Local rotationMatrix:SMat3D = rotationMatrixX * rotationMatrixY * rotationMatrixZ

' Apply the rotation to a 3D vector
Local vec:SVec3D = New SVec3D(1, 2, 3)
Local rotatedVec:SVec3D = rotationMatrix.Apply(vec)
```

When the rotation matrix is applied to a 3D vector, it will rotate the vector according to the specified angles.
The order in which the rotations are combined (in this example, X, then Y, then Z) will determine the final rotation.