I’ll show you how to add two of the simpler ones: add and multiply.

In case your linear algebra is a bit rusty, let me recap a little. A matrix is a 2-dimensional array. Adding one matrix to another involves adding the values in the corresponding cells of each matrix (which both must be the same size) together and putting that sum into a new matrix at the same position.

For example, consider these two matrices (taken from the Wikipedia page on Matrix Addition):

1 3
1 0
1 2

0 0
7 5
2 1

To add them

• 1st row: 1 + 0, 3 + 0
• 2nd row: 1 + 7, 0 + 5
• 3rd row: 1 + 2, 2 + 1

This results in a new matrix:

1 3
8 5
3 3

 As you can see, addition is pretty straightforward. So how might this look in Xojo? Here is an extension method for Integer arrays that I created to do this:

Public Function Add(Extends m1(, ) As Integer, m2(, ) As Integer) As Integer(,)
  // https://en.wikipedia.org/wiki/Matrix_addition
  // Both arrays must have the same number of rows and columns.

  If m1.LastIndex(1) <> m2.LastIndex(1) Or m1.LastIndex(2) <> m2.LastIndex(2) Then
    Raise New UnsupportedOperationException("Array sizes must match.")
  End If

  // The values at each cell are added together and a new
  // array is created with their sums.
  Var newMatrix(-1, -1) As Integer

  newMatrix.ResizeTo(m1.LastIndex(1), m1.LastIndex(2))

  For c1 As Integer = 0 To m1.LastIndex(1)
    For c2 As Integer = 0 To m1.LastIndex(2)
      newMatrix(c1, c2) = m1(c1, c2) + m2(c1, c2)
    Next
  Next

  Return newMatrix

End Function

To use it, you populate two matrices and call matrix1.add(matrix2). Here is some sample code to solve the example above:

// Matrix Addition

Var matrix1(2, 1) As Integer
matrix1(0, 0) = 1
matrix1(0, 1) = 3
matrix1(1, 0) = 1
matrix1(1, 1) = 0
matrix1(2, 0) = 1
matrix1(2, 1) = 2

Var matrix2(2, 1) As Integer
matrix2(0, 0) = 0
matrix2(0, 1) = 0
matrix2(1, 0) = 7
matrix2(1, 1) = 5
matrix2(2, 0) = 2
matrix2(2, 1) = 1

Var matrix3(-1, -1) As Integer
matrix3 = matrix1.Add(matrix2)

Multiplication gets more complex and is a bit tricky to explain. First, the sizes matter. The 2nd dimension of the 1st matrix must be the same as the 1st dimension of the 2nd matrix. That means that if you have matrix1(3,2) then matrix2(2,2) is valid, but matrix2(1,2) is not. The resulting matrix is matrix1’s 1st dimension by matrix2’s 2nd dimension.

To do the multiplication, for each cell in the new matrix you multiple each cell in the corresponding row of matrix1 with each cell of the corresponding column in matrix2.

A Xojo method to do that looks like this:

Public Function Multiply(Extends m1(, ) As Integer, m2(, ) As Integer) As Integer(,)

  // https://en.wikipedia.org/wiki/Matrix_multiplication
  // matrix1's 2nd dimension size must be the same as
  // matrix2's 1st dimension size.

  If m1.LastIndex(2) <> m2.LastIndex(1) Then
    Raise New UnsupportedOperationException("m1 2nd dimension must match m2 1st dimension.")
  End If

  // The result matrix is matrix1's 1st dimension by matrix2's 2nd dimension

  Var newMatrix(-1, -1) As Integer

  newMatrix.ResizeTo(m1.LastIndex(1), m2.LastIndex(2))

  For c1 As Integer = 0 To newMatrix.LastIndex(1)
    For c2 As Integer = 0 To newMatrix.LastIndex(2)
      Var prod As Integer
      For p1 As Integer = 0 To m1.LastIndex(2)
        prod = prod + m1(c1, p1) * m2(p1, c2)
      Next
      newMatrix(c1, c2) = prod
    Next
  Next

  Return newMatrix

End Function

The Wikipedia example for matrix multiplication has these two matrices:

1 0 1
2 1 1
0 1 1
1 1 2

1 2 1
2 3 1
4 2 2

Multiplying them together results in this matrix:

 5 4 3
 8 9 5
 6 5 3
11 9 6

This code sets up the above example and multiplies it using the method:

// Matrix Multiplication

Var matrix1(3, 2) As Integer
matrix1(0, 0) = 1
matrix1(0, 1) = 0
matrix1(0, 2) = 1
matrix1(1, 0) = 2
matrix1(1, 1) = 1
matrix1(1, 2) = 1
matrix1(2, 0) = 0
matrix1(2, 1) = 1
matrix1(2, 2) = 1
matrix1(3, 0) = 1
matrix1(3, 1) = 1
matrix1(3, 2) = 2

Var matrix2(2, 2) As Integer
matrix2(0, 0) = 1
matrix2(0, 1) = 2
matrix2(0, 2) = 1
matrix2(1, 0) = 2
matrix2(1, 1) = 3
matrix2(1, 2) = 1
matrix2(2, 0) = 4
matrix2(2, 1) = 2
matrix2(2, 2) = 2

Var matrix3(-1, -1) As Integer
matrix3 = matrix1.Multiply(matrix2)

I will point out that the two methods used here are very simple algorithms that won’t be nearly fast enough when working with large matrices. But hopefully they showed you that Extension Methods are a great way to extend the Xojo language for your specific needs and you found this example interesting, even if you have no use for linear algebra or matrix math.

Download the project: MatrixMath

As an alternative to using Extends, you could create your own Matrix class and then use Operator overloading (a subject for another blog post) so that you could write code like this:

Var m1 As New Matrix(1, 3, 1, 0, 1 2)
Var m2 As New Matrix(0, 0, 7, 5, 2, 1)
Var m3 As Matrix = m1 + m2

If you actually need full matrix support in Xojo, check out the free matrix-related Delaney or Einhugur plugins.

Paul learned to program in BASIC at age 13 and has programmed in more languages than he remembers, with Xojo being an obvious favorite. When not working on Xojo, you can find him talking about retrocomputing at Goto 10 and on Mastodon @lefebvre@hachyderm.io.

In mathematics, (0,0) is typically at the center with positive X being to right, negative X to the left. Positive Y is up and negative Y is down.

This means if you are trying to draw the graphs of some standard math functions you have to do some translating. With Xojo you can use the Graphics.Translate() function to relocate the origin point. This makes it easy to move (0,0) from the top left to the center with code like this in the Paint event:

g.Translate(g.Width / 2, g.Height / 2)

Switching the Y from going from the top down to the bottom up is just a matter of negating it. With a translated origin, this would draw a line above the baseline:

g.DrawLine(1, -2, 1, -2)

I thought it might be interesting to try and wrap this up in some subclasses to make it a little more automatic, work with the smaller scale typically used for these type of graphs and even graph some functions.

The result is a project, MathGraph, which can draw some shapes on the graph and also graph simple functions that work with x.

Here’s an example of a graph for the cubic polynomial function y = x^3:

Keep in mind that this only solves for x.

Other functions you might want to try:

• quadratic polynomial: x^2
• line: x
• absolute value: abs(x)
• reciprocal of x: 1/x
• reciprocal of x²: 1/x^2
• square root: sqrt(x)
• exponential: exp(x)
• logarithmic: log(x)
• sin wave: sin(x)
• sin(x)/cos(x)

Try multiplying and dividing some of the above in combination. You can use any valid Xojo math expression and any of the math functions. If there is an error in your function, then the error message is shown in the graph itself.

There are also some built in functions to draw text, rectangles, ovals and plot points that you can use in the Paint event handler.

This is provided as a Canvas subclass, called MathCanvas. It has companion classes MathGraphics and Grapher. MathGraphics is used to draw using math coordinates. Grapher is a subclass of XojoScript and is what processes the function for graphing (it is based on the Evaluator example project included with Xojo).

Download the MathGraph project to try it for yourself.

Paul learned to program in BASIC at age 13 and has programmed in more languages than he remembers, with Xojo being an obvious favorite. When not working on Xojo, you can find him talking about retrocomputing at Goto 10 and on Mastodon @lefebvre@hachyderm.io.

23³⁷³ Mod 747

Their video was prompted by a video about Witness Numbers on the Numberphile channel, which I guess I now also need to subscribe to. This is the video description:

How do you compute a massive number raised to the power of another huge number, modulo something else? Dr Mike Pound explains the super-quick square & multiply algorithm.

Computerphile

I thought this posed an interesting question because that is obviously a huge number and is way bigger than most programming languages, including Xojo, can handle. However, taking the Mod means that the answer has to be between 0 and 746, so does the massive number actually need to be calculated at all?

It turns out the answer is no, as long as you know the algorithm, which is called Square & Multiply.

At a high level, this is the algorithm as explained in the video:

• Convert the exponent to binary.
• Each 0 requires a square
• Each 1 requires a square and then a multiply
• After each calculation, can do the modulo to keep the value small.
• The final calculation is the answer.

To test this, start with a smaller value. The video uses:

3⁴⁵ mod 7

The number 45 in binary is 101101. Since the very first digit is a 1, our starting value of this example is 3, the initial number itself.

• The next binary digit is 0, so that means a square. 3 * 3 = 9. 9 Mod 7 = 2.
• The next binary digit is 1, so that means a square and then a multiply.
  • Squaring the 2 gives us 4 and the Mod 7 of that is also 4.
  • We now use 4 and multiple it with the starting value of 3 to get 12. And 12 Mod 7 is 5.

As you can see, each time through we are only dealing with small numbers so they are easily calculated. And because the binary value of 45 only has 6 digits there will be at most 12 steps to the calculation, which is also much less than 45.

Continuing through the rest:

• Next binary digit is a 1, so square it: 5 * 5 = 25, Mod 7 = 4.
  • and multiple it: 4 * 3 = 12, Mod 7 = 5.
• Next is a 0, so square it: 5 * 5 = 25, Mod 7 = 4.
• The last digit is a 1, so square it: 4 * 4 = 16, Mod 7 = 2.
  • And finally multiply it: 2 * 3 = 6. 6 Mod 7 = 6, which the final answer.

You can verify this using Wolfram Alpha:

Despite how it may seem, the above algorithm results in short method. Here’s what it looks like in Xojo:

Public Function SquareAndMultiply(value As Integer, exponent As Integer, modulus As Integer) As Integer
  // Square and Multipe Algorithm
  Var b As String = exponent.ToBinary
  Var binaryValue() As String = b.Split("")
  
  Var lastModulus As Integer = 1
  Var newExp As Integer
  newExp = Integer.FromBinary(binaryValue(0))
  
  If binaryValue(0) = "1" Then
    lastModulus = value
  End If
  
  For i As Integer = 1 To binaryValue.LastIndex
    Var bit As String = binaryValue(i)
    
    lastModulus = (lastModulus * lastModulus) Mod modulus
    
    If bit = "1" Then // Multiply as well
      lastModulus = (lastModulus * value) Mod modulus
    End If
  Next
  
  Return lastModulus
  
End Function

I pretty much tried to implement the exact algorithm described in the video. The Wikipedia page on this topic seems to have other, perhaps more efficient, implementations.

You would call the Xojo method like this to solve the original problem shown a the top of this post:

Var answer As Integer = SquareAndMultiply(23, 373, 747)

You can download this Xojo project to try it out:

SquareAndMultiply

By the way, the answer to 23³⁷³ Mod 747 is 131.

Paul learned to program in BASIC at age 13 and has programmed in more languages than he remembers, with Xojo being an obvious favorite. When not working on Xojo, you can find him talking about retrocomputing at Goto 10 and on Mastodon @lefebvre@hachyderm.io.