Enter the Matrix

Question

I've semi-often been frustrated at the lack of a proper Matrix data structure in VBA. A multi-dimensional array is obviously the right way to handle it, but there is so much missing... for example, you can't natively check to see if an array has been dimensioned, you can't resize the array while preserving values except on the last dimension, there is no convenient VBA syntax for loading immediate values into the array, etc.

So I created a Matrix class that supports:

• Matrix operations - Add, Subtract, Multiply, ScalarMultiply, Augment, Transpose
• Elementary Row Operations SwapRows, ScaleRow, AddScalarMultipleRow
• A Parser for loading the Matrix from a String - LoadMatrixString
• Utility functions - ToString, Clone
• An implementation of Gaussian Elimination - RowReduce

The parser was made based on this tutorial on hand coding a recursive descent parser.

The Elementary Row Operations are destructive, because doing otherwise would degrade the performance too much.

The Matrix operations are non-destructive, in that they create a new Matrix with the results and return it. This allows method chaining, such as Set D = A.Multiply(B).Add(C).ScalarMultiply(5), and the intuitive behavior such that C = A x B and A and B themselves are not modified in the process. I'm tempted to make these methods destructive to improve performance (an object is created for every intermediate matrix operation), but I'm not sure how intuitive it would be that the result of A.Multiply(B) would be A.

I posted an earlier version of the class as an answer to a question here, but have since made some improvements. The test code there is still valid.

I'm particularly intersted to know whether I should split the parser off into a separate class to be used independently, or maybe be called by the Matrix class itself. I've tried to clean up the code naming conventions - PascalCase for the sub/functions and camelCase for the variable names and removing Hungarian - but please point out to me if I've missed something. I've been reading that unless you are specifically coding for performance, it's better from a code maintainability standpoint to call accessors when possible within the class instead of always modifying private members directly because if the implementation of the accessor ever changes, you wouldn't have to then go through the rest of the code and change the way it's done in the other functions - does that sound right?

Here is the very self-contained Matrix class:

Option Compare Database
Option Explicit

Private Declare Sub CopyMemory Lib "kernel32.dll" Alias "RtlMoveMemory" (ByVal Destination As Long, ByVal Source As Long, ByVal Length As Integer)

'----------------------------------
'This array holds the values of the Matrix
Private matrixArray() As Double

'----------------------------------
'Shared recursive descent parsing variables
Private tempMatrixString As String
Private look As String

Public Sub Class_Initialize()

End Sub

'************************************************
'* Accessors and Utility Functions *
'***********************************

Public Property Get Value(r As Long, c As Long) As Double

    CheckDimensions

    Value = matrixArray(r, c)
End Property

Public Property Let Value(r As Long, c As Long, val As Double)

    CheckDimensions

    matrixArray(r, c) = val
End Property

Public Property Get Rows() As Long
    If GetDims(matrixArray) = 0 Then
        Rows = 0
    Else
        Rows = UBound(matrixArray, 1) + 1
    End If
End Property

Public Property Get Cols() As Long
    If GetDims(matrixArray) = 0 Then
        Cols = 0
    Else
        Cols = UBound(matrixArray, 2) + 1
    End If
End Property

Public Sub LoadMatrixString(str As String)
    tempMatrixString = str
    ParseMatrix str
    tempMatrixString = ""
    look = ""
End Sub

Public Sub Resize(Rows As Long, Cols As Long, Optional blPreserve As Boolean = False)
    Dim tempMatrix As Matrix
    Dim r As Long
    Dim c As Long

    If blPreserve Then

        CheckDimensions

        Set tempMatrix = Me.Clone
        ReDim matrixArray(0 To Rows - 1, 0 To Cols - 1)
        For r = 0 To MinLongs(tempMatrix.Rows, Me.Rows) - 1
            For c = 0 To MinLongs(tempMatrix.Cols, Me.Cols) - 1
                Value(r, c) = tempMatrix.Value(r, c)
            Next
        Next
    Else
        ReDim matrixArray(0 To Rows - 1, 0 To Cols - 1)
    End If

End Sub

Public Function Clone() As Matrix
    Dim mresult As Matrix
    Dim r As Long
    Dim c As Long

    CheckDimensions

    Set mresult = New Matrix
    mresult.Resize Me.Rows, Me.Cols
    For r = 0 To Me.Rows - 1
        For c = 0 To Me.Cols - 1
            mresult.Value(r, c) = Me.Value(r, c)
        Next
    Next
    Set Clone = mresult
End Function

Public Function ToString() As String
    Dim str As String
    Dim r As Long
    Dim c As Long
    Dim tempRow() As String
    Dim tempRows() As String
    ReDim tempRow(0 To Me.Cols - 1)
    ReDim tempRows(0 To Me.Rows - 1)


    If Not GetDims(matrixArray) = 0 Then 'Need to check if array is empty
        For r = 0 To Me.Rows - 1
            For c = 0 To Me.Cols - 1
                tempRow(c) = Me.Value(r, c)
            Next
            tempRows(r) = "[" & Join(tempRow, ", ") & "]"
        Next
        ToString = "[" & Join(tempRows, vbCrLf) & "]"
    Else
        ToString = ""
    End If
End Function

'***********************************************************
'* Matrix Operations *
'*********************

Public Function Add(m As Matrix) As Matrix
    Dim mresult As Matrix
    Dim r As Long
    Dim c As Long

    CheckDimensions

    If m.Rows = Me.Rows And m.Cols = Me.Cols Then
        Set mresult = New Matrix
        mresult.Resize Me.Rows, Me.Cols
        For r = 0 To Me.Rows - 1
            For c = 0 To Me.Cols - 1
                mresult.Value(r, c) = Me.Value(r, c) + m.Value(r, c)
            Next
        Next
    Else
        Err.Raise vbObjectError + 1, "Matrix.Add", "Could not Add matrices: the Rows and Columns must be the same. The left matrix is (" & Me.Rows & ", " & Me.Cols & ") and the right matrix is (" & m.Rows & ", " & m.Cols & ")."
    End If
    Set Add = mresult
End Function

Public Function Subtract(m As Matrix) As Matrix
    Dim mresult As Matrix
    Dim r As Long
    Dim c As Long

    CheckDimensions

    If m.Rows = Me.Rows And m.Cols = Me.Cols Then
        Set mresult = New Matrix
        mresult.Resize Me.Rows, Me.Cols
        For r = 0 To Me.Rows - 1
            For c = 0 To Me.Cols - 1
                mresult.Value(r, c) = Me.Value(r, c) - m.Value(r, c)
            Next
        Next
    Else
        Err.Raise vbObjectError + 2, "Matrix.Subtract", "Could not Subtract matrices: the Rows and Columns must be the same. The left matrix is (" & Me.Rows & ", " & Me.Cols & ") and the right matrix is (" & m.Rows & ", " & m.Cols & ")."
    End If
    Set Subtract = mresult
End Function

Public Function Multiply(m As Matrix) As Matrix
    Dim mresult As Matrix
    Dim i As Long
    Dim j As Long
    Dim n As Long

    CheckDimensions

    If Me.Cols = m.Rows Then
        Set mresult = New Matrix
        mresult.Resize Me.Rows, m.Cols
        For i = 0 To Me.Rows - 1
            For j = 0 To m.Cols - 1
                For n = 0 To Me.Cols - 1
                    mresult.Value(i, j) = mresult.Value(i, j) + (Me.Value(i, n) * m.Value(n, j))
                Next
            Next
        Next
    Else
        Err.Raise vbObjectError + 3, "Matrix.Multiply", "Could not Subtract matrices: the Columns of the left matrix and Rows of the right must be the same. The left matrix has " & Me.Cols & " Columns and the right matrix has " & m.Rows & " Rows."
    End If

    Set Multiply = mresult

End Function

Public Function ScalarMultiply(scalar As Double) As Matrix
    Dim mresult As Matrix
    Dim r As Long
    Dim c As Long

    CheckDimensions

    Set mresult = New Matrix
    mresult.Resize Me.Rows, Me.Cols
    For r = 0 To Me.Rows - 1
        For c = 0 To Me.Cols - 1
            mresult.Value(r, c) = Me.Value(r, c) * scalar
        Next
    Next

    Set ScalarMultiply = mresult

End Function

Public Function Augment(m As Matrix) As Matrix
    Dim mresult As Matrix
    Dim r As Long
    Dim c As Long

    CheckDimensions


    If Me.Rows = m.Rows Then
        Set mresult = New Matrix
        mresult.Resize Me.Rows, Me.Cols + m.Cols
        For r = 0 To Me.Rows - 1
            For c = 0 To Me.Cols - 1
                mresult.Value(r, c) = Me.Value(r, c)
            Next
        Next

        For r = 0 To Me.Rows - 1
            For c = 0 To m.Cols - 1
                mresult.Value(r, Me.Cols + c) = m.Value(r, c)
            Next
        Next
    Else
        Err.Raise vbObjectError + 4, "Matrix.Augment", "Could not Augment matrices: the matrices must have the same number of Rows. The left matrix has " & Me.Rows & " Rows and the right matrix has " & m.Rows & " Rows."
    End If
    Set Augment = mresult
End Function

Public Function Transpose() As Matrix
    Dim mresult As Matrix
    Dim r As Long
    Dim c As Long

    CheckDimensions

    If Me.Rows = Me.Cols Then
        Set mresult = New Matrix
        mresult.Resize Me.Cols, Me.Rows
        For r = 0 To Me.Rows - 1
            For c = 0 To Me.Cols - 1
                Me.Value(r, c) = mresult(c, r)
            Next
        Next
    Else
        Err.Raise vbObjectError + 5, "Matrix.Augment", "Could not Transpose matrix: the matrix must have the same number of Rows and Cols. The matrix is (" & Me.Rows & ", " & Me.Cols & ")."
    End If
    Set Transpose = mresult
End Function

Public Function RowReduce() As Matrix
    Dim i As Long
    Dim j As Long

    CheckDimensions

    'Row Echelon
    Dim mresult As Matrix
    Set mresult = Me.Clone

    For i = 0 To mresult.Rows - 1
        If Not mresult.Value(i, i) <> 0 Then
            For j = i + 1 To mresult.Rows - 1
                If mresult.Value(j, i) > 0 Then
                    mresult.SwapRows i, j
                    Exit For
                End If
            Next
        End If

        If mresult.Value(i, i) = 0 Then
            Exit For
        End If

        mresult.ScaleRow i, 1 / mresult.Value(i, i)

        For j = i + 1 To mresult.Rows - 1
            mresult.AddScalarMultipleRow i, j, -mresult.Value(j, i)
        Next
    Next

    'Backwards substitution

    For i = IIf(mresult.Rows < mresult.Cols, mresult.Rows, mresult.Cols) - 1 To 1 Step -1
        If mresult.Value(i, i) > 0 Then
            For j = i - 1 To 0 Step -1
                mresult.AddScalarMultipleRow i, j, -mresult.Value(j, i)
            Next
        End If
    Next

    Set RowReduce = mresult
End Function


'*************************************************************
'* Elementary Row Operaions *
'****************************

Public Sub SwapRows(r1 As Long, r2 As Long)
    Dim temp As Double
    Dim c As Long

    CheckDimensions

    For c = 0 To Me.Cols - 1
        temp = Me.Value(r1, c)
        Me.Value(r1, c) = Me.Value(r2, c)
        Me.Value(r2, c) = temp
    Next
End Sub

Public Sub ScaleRow(row As Long, scalar As Double)
    Dim c As Long

    CheckDimensions

    For c = 0 To Me.Cols - 1
        Me.Value(row, c) = Me.Value(row, c) * scalar
    Next
End Sub

Public Sub AddScalarMultipleRow(srcrow As Long, destrow As Long, scalar As Double)
    Dim c As Long

    CheckDimensions

    For c = 0 To Me.Cols - 1
        Me.Value(destrow, c) = Me.Value(destrow, c) + (Me.Value(srcrow, c) * scalar)
    Next
End Sub

'************************************************************
'* Parsing Functions *
'*********************

Private Sub ParseMatrix(strMatrix As String)
    Dim arr() As Double
    Dim c As Long
    GetChar 1
    Match "["
    SkipWhite
    If look = "[" Then
        arr = ParseRow
        Me.Resize 1, UBound(arr) + 1
        'ReDim matrixArray(0 To UBound(arr), 0 To 0)
        For c = 0 To Me.Cols - 1
            Me.Value(0, c) = arr(c)
        Next
        SkipWhite
        While look = ","
            Match ","
            SkipWhite
            arr = ParseRow
            Me.Resize Me.Rows + 1, Me.Cols, True

            If UBound(arr) <> (Me.Cols - 1) Then
                'Error jagged array
                Err.Raise vbObjectError + 6, "Matrix.LoadMatrixString", "Parser Error - Jagged arrays are not supported: Row 0 has " & Me.Cols & " Cols, but Row " & Me.Rows - 1 & " has " & UBound(arr) + 1 & " Cols."
            End If
            For c = 0 To Me.Cols - 1
                Me.Value(Me.Rows - 1, c) = arr(c)
            Next
            SkipWhite
        Wend
        Match "]"
    ElseIf look = "]" Then
        Match "]"
    Else
        MsgBox "Error"
    End If
    SkipWhite
    If look <> "" Then
        Err.Raise vbObjectError + 7, "Matrix.LoadMatrixString", "Parser Error - Unexpected Character: """ & look & """."
    End If
End Sub

Private Function ParseRow() As Variant
    Dim arr() As Double
    Match "["
    SkipWhite
    ReDim arr(0 To 0)
    arr(0) = ParseNumber
    SkipWhite
    While look = ","
        Match ","
        ReDim Preserve arr(0 To UBound(arr) + 1)
        arr(UBound(arr)) = ParseNumber
        SkipWhite
    Wend
    Match "]"
    ParseRow = arr
End Function

Private Function ParseNumber() As Double
    Dim strToken As String
    If look = "-" Then
        strToken = strToken & look
        GetChar
    End If
    While IsDigit(look)
        strToken = strToken & look
        GetChar
    Wend
    If look = "." Then
        strToken = strToken & look
        GetChar
        While IsDigit(look)
            strToken = strToken & look
            GetChar
        Wend
    End If

    ParseNumber = CDbl(strToken)
End Function

'****************************************************************

Private Sub GetChar(Optional InitValue)
    Static i As Long
    If Not IsMissing(InitValue) Then
        i = InitValue
    End If
    If i <= Len(tempMatrixString) Then
        look = Mid(tempMatrixString, i, 1)
        i = i + 1
    Else
        look = ""
    End If
End Sub

'****************************************************************
'* Skip Functions (Parser) *
'***************************

Private Sub SkipWhite()
    While IsWhite(look) Or IsEOL(look)
        GetChar
    Wend
End Sub

'****************************************************************
'* Match/Expect Functions (Parser) *
'***********************************

Private Sub Match(char As String)
    If look <> char Then
        Expected """" & char & """"
    Else
        GetChar
        SkipWhite
    End If
    Exit Sub

End Sub

Private Sub Expected(str As String)
    'MsgBox "Expected: " & str
    Err.Raise vbObjectError + 8, "Matrix.LoadMatrixString", "Parser Error - Expected: " & str
End Sub

'****************************************************************
'* Character Class Functions (Parser) *
'**************************************

Private Function IsDigit(char As String) As Boolean

    Dim charval As Integer
    If char <> "" Then
        charval = Asc(char)
        If 48 <= charval And charval <= 57 Then
            IsDigit = True
        Else
            IsDigit = False
        End If
    Else
        IsDigit = False
    End If

End Function

Private Function IsWhite(char As String) As Boolean

    Dim charval As Integer
    If char <> "" Then
        charval = Asc(char)
        If charval = 9 Or charval = 11 Or charval = 12 Or charval = 32 Or charval = 160 Then '160 because MS Exchange sucks
            IsWhite = True
        Else
            IsWhite = False
        End If
    Else
        IsWhite = False
    End If

End Function

Private Function IsEOL(char As String) As Boolean
    If char = Chr(13) Or char = Chr(10) Then
        IsEOL = True
    Else
        IsEOL = False
    End If
End Function

'*****************************************************************
'* Helper Functions *
'********************

Private Sub CheckDimensions()
    If GetDims(matrixArray) = 0 Then
        'Error, uninitialized array
        Err.Raise vbObjectError + 1, "Matrix", "Array has not been initialized"
    End If
End Sub

Private Function GetDims(VarSafeArray As Variant) As Integer
    Dim lpSAFEARRAY As Long
    Dim lppSAFEARRAY As Long
    Dim arrayDims As Integer

    'This check ensures that the value inside the Variant is actually an array of some type
    If (VarType(VarSafeArray) And vbArray) > 0 Then

        'If the Variant contains an array, the pointer to the pointer to the array is located at VarPtr(VarSafeArray) + 8...
        CopyMemory VarPtr(lppSAFEARRAY), VarPtr(VarSafeArray) + 8, 4&
        '...and now dereference the pointer to pointer to get the actual pointer to the array...
        CopyMemory VarPtr(lpSAFEARRAY), lppSAFEARRAY, 4&
        '...which will be 0 if the array hasn't been initialized
        If Not lpSAFEARRAY = 0 Then
            'If it HAS been initialized, we can pull the number of dimensions directly from the pointer, since it's the first member in the SAFEARRAY struct
            CopyMemory VarPtr(arrayDims), lpSAFEARRAY, 2&
            GetDims = arrayDims
        Else
            GetDims = 0 'Array not initialized
        End If
    Else
        GetDims = 0 'It's not an array... Type mismatch maybe?
    End If
End Function

Private Function MinLongs(a As Long, b As Long) As Long
    If a < b Then
        MinLongs = a
    Else
        MinLongs = b
    End If
End Function

And here are a couple examples of use:

Option Compare Database

Public Sub TestMatrix()

    Dim m1 As Matrix
    Set m1 = New Matrix
    m1.LoadMatrixString ("[[ 0,  1,  4, 9, 16]," & _
                         " [16, 15, 12, 7,  0]," & _
                         " [ 1,  1,  1, 1,  1]]")

    Dim m2 As Matrix
    Set m2 = New Matrix
    m2.LoadMatrixString ("[[190]," & _
                         " [190]," & _
                         " [ 20]]")


    MsgBox m1.Augment(m2).RowReduce.ToString

End Sub

Public Sub TestMatrix2()
    'This is an example iteration of a matrix Petri Net as described here:
    'http://www.techfak.uni-bielefeld.de/~mchen/BioPNML/Intro/MRPN.html
    Dim D_Minus As Matrix
    Dim D_Plus As Matrix
    Dim D As Matrix

    Set D_Minus = New Matrix
    D_Minus.LoadMatrixString "[[0, 0, 0, 0, 1]," & _
                             " [1, 0, 0, 0, 0]," & _
                             " [0, 1, 0, 0, 0]," & _
                             " [0, 0, 1, 1, 0]]"

    Set D_Plus = New Matrix
    D_Plus.LoadMatrixString "[[1, 1, 0, 0, 0]," & _
                            " [0, 0, 1, 1, 0]," & _
                            " [0, 0, 0, 1, 0]," & _
                            " [0, 0, 0, 0, 1]]"


    Set D = D_Plus.Subtract(D_Minus)

    MsgBox D.ToString

    Dim Transition_Matrix As Matrix
    Dim Marking_Matrix As Matrix
    Dim Next_Marking As Matrix

    Set Transition_Matrix = New Matrix
    Transition_Matrix.LoadMatrixString "[[0, 1, 1, 0]]"

    Set Marking_Matrix = New Matrix
    Marking_Matrix.LoadMatrixString "[[2, 1, 0, 0, 0]]"

    Set Next_Marking = Transition_Matrix.Multiply(D).Add(Marking_Matrix)

    MsgBox Next_Marking.ToString

End Sub

Answer 1

Public Sub Class_Initialize()

End Sub

Avoid empty members; this initializer serves no purpose, remove it.

Although I could infer r and c are meant for row and column, these single-letter parameters should probably be called row and column, for clarity. Likewise, Cols should probably be called Columns.

This is unfortunate:

Public Property Let Value(r As Long, c As Long, val As Double)

I'd consider calling the property ValueAt, and the val parameter could then be called value - and since parameters are passed ByRef by default, I'd be explicit about them being passed ByVal - there's no need to pass them by reference:

Public Property Let ValueAt(ByVal rowIndex As Long, ByVal columnIndex As Long, ByVal value As Double)

In the case of LoadMatrixString, I'd consider changing the signature from this:

Public Sub LoadMatrixString(str As String)

To that:

Public Sub LoadMatrixString(ByVal values As String)

And for the members that take a m As Matrix parameter, I'd go with ByVal value As Matrix and avoid single-letter identifiers. I find "value" remains the most descriptive name in these contexts.

There's an inconsistency in the way you're naming "Dimensions": you have CheckDimensions, but then you also have GetDims - I'd rename the latter GetDimensions.

---

I like how the class is self-contained, but then it seems to me like the ToString implementation would be a perfect excuse to use your wonderful StringBuilder class, and I bet you'd get the string output much, much faster ;)

As for this:

I'm particularly intersted to know whether I should split the parser off into a separate class to be used independently, or maybe be called by the Matrix class itself.

I think you could simply move the parsing code to a MatrixParser class, and be done with it! ...Actually, I'd copy the LoadMatrixString procedure there, and rename it Parse, make it a Function and have it return a Matrix. Then LoadMatrixString could be modified to call this new function.

Answer 2

This is by no means a full review, but I did notice something. The way you raise errors could use a little work if you're striving for maintainable code.

   Err.Raise vbObjectError + 1, "Matrix.Add", "Could not Add matrices: the Rows and Columns must be the same. The left matrix is (" & Me.Rows & ", " & Me.Cols & ") and the right matrix is (" & m.Rows & ", " & m.Cols & ")."

So, first off, I like that you're correctly adding vbObjectError to the error number. What I don't like is if I want to add a new error, I have to manually look at the whole file to see if I'm reusing one. This is a great use of an Enum.

Public Enum MatrixError
    AdditionError = vbObjectError + 1
    SomeOtherError
    ' ...
End Enum

The benefits are two fold.

1. It becomes easier to add and use the error number.
2. The error numbers get exposed to the client code, so if an error gets raised, I can check the Err.Number and handle it appropriately.

Something like this:

ErrHandler:
    If Err.Number = AdditionError Then
        ' do something to handle the matrix error
    Else
        ' throw it upstream
        Err.Raise Err.Number
    End If
End Sub

Answer 3

Just a few things to think about, more about the design and usage of the Matrix class than just the code.

In my particular and peculiar corner of the universe, we often have need for empty matrices, that is, a matrix where one or more dimensions are zero. The idea would be that a matrix would be built up or destroyed during the course of program execution and at one or another point in time, having zero rows would be quite natural. Granted VBA does not support empty arrays, one nasty (or just silly) way I had dealt with this is to pad with one extra row or column element. Sure, it's some extra space, but this is after all 2015.

More down to earth, I would use a parser-free analogue and companion to LoadMatrixString, something like

Public Sub LoadMatrixVector(rows as Long, columns as Long, values() as Double)

possibly used in conjunction with a helper function like

Public Function Vector(ParamArray values() As Variant) As Double()
    Dim result() As Double
    ReDim result(UBound(values))
    Dim i As Long
    Dim item As Variant
    i = 0
    For Each item In values
        result(i) = CDbl(values(i))
        i = i + 1
    Next item
    Vector = result
End Function

where I could write

Set mat = LoadMatrixVector(3, 3, Vector(1, 2, 3))

and get a matrix with three rows of 1, 2, and 3. LoadMatrixVector could wrap the values as needed until the result is filled. Also, I could see something like this as an acceptable compromise to do operations in place (you called this "destructive").

Set D = A.ShallowCopy().Multiply(B).Add(C).ScalarMultiply(5)

And there's more. My suggestions may contravene established coding practices. I try to go for a combination of brevity and clarity.

First, I prefer to dispose of easy cases early in a program, to reduce (cyclometric?) complexity later. For instance, instead of

Public Function Add(m As Matrix) As Matrix
    Dim mresult As Matrix
    Dim r As Long
    Dim c As Long

    CheckDimensions

    If m.Rows = Me.Rows And m.Cols = Me.Cols Then
        Set mresult = New Matrix
        mresult.Resize Me.Rows, Me.Cols
        For r = 0 To Me.Rows - 1
            For c = 0 To Me.Cols - 1
                mresult.Value(r, c) = Me.Value(r, c) + m.Value(r, c)
            Next
        Next
    Else
        Err.Raise vbObjectError + 1, "Matrix.Add", "Could not Add matrices: the Rows and Columns must be the same. The left matrix is (" & Me.Rows & ", " & Me.Cols & ") and the right matrix is (" & m.Rows & ", " & m.Cols & ")."
    End If
    Set Add = mresult
End Function

I would move the conformability check up a bit earlier and possibly exit early. Not really shorter, but the actual business part of the function is simpler and has less indentation.

Public Function Add(m As Matrix) As Matrix
    Dim mresult As Matrix
    Dim r As Long
    Dim c As Long

    CheckDimensions

    If m.Rows <> Me.Rows Or m.Cols <> Me.Cols Then
        Err.Raise vbObjectError + 1, "Matrix.Add", "Could not Add matrices: the Rows and Columns must be the same. The left matrix is (" & Me.Rows & ", " & Me.Cols & ") and the right matrix is (" & m.Rows & ", " & m.Cols & ")."
    End If

    Set mresult = New Matrix
    mresult.Resize Me.Rows, Me.Cols
    For r = 0 To Me.Rows - 1
        For c = 0 To Me.Cols - 1
            mresult.Value(r, c) = Me.Value(r, c) + m.Value(r, c)
        Next
    Next
    Set Add = mresult
End Function

Next, functions which return boolean results like

Private Function IsEOL(char As String) As Boolean
    If char = Chr(13) Or char = Chr(10) Then
        IsEOL = True
    Else
        IsEOL = False
    End If
End Function

can be written like this

Private Function IsEOL(char As String) As Boolean
    IsEOL = char = Chr(13) Or char = Chr(10)
End Function

though VBA's design decision of using = for both assignment and equality is irritating here. This also works in Java etc.

Combining the two ideas, isDigit can get much smaller

Private Function IsDigit(char As String) As Boolean

    Dim charval As Integer
    IsDigit = False
    If char = "" Then Exit Function

    charval = Asc(char)
    IsDigit = 48 <= charval And charval <= 57

End Function

I feel you did a lot if things right, you did the best with what you had.

Comments are there when needed to explain what you're doing, but you otherwise assume a reasonable language literacy level.

The MultiplyScalar function is a good example of not doing too much. Instead of mucking about with VBA's lack of function overloading and trying to separate scalar and matrix cases in a Multiply function, the burden of type checking stays with VBA, where it belongs.

Good stuff.

Answer 4

isDigit can be made twice as fast (and shorter) using Like:

Private Function IsDigit(char As String) As Boolean

    IsDigit = char Like "[0-9]"

End Function