{"id":6133,"date":"2007-05-07T13:51:00","date_gmt":"2007-05-07T13:51:00","guid":{"rendered":"https:\/\/blogs.msdn.microsoft.com\/vbteam\/2007\/05\/07\/operator-overloading-a-demonstration-using-matrices-matt-gertz\/"},"modified":"2024-07-05T14:46:51","modified_gmt":"2024-07-05T21:46:51","slug":"operator-overloading-a-demonstration-using-matrices-matt-gertz","status":"publish","type":"post","link":"https:\/\/devblogs.microsoft.com\/vbteam\/operator-overloading-a-demonstration-using-matrices-matt-gertz\/","title":{"rendered":"Operator Overloading: A demonstration using matrices (Matt Gertz)"},"content":{"rendered":"

Over a decade ago, before I joined Microsoft, I was a doctoral candidate at Carnegie Mellon studying robotics.  <\/span>One of the things that you had to do to get into the doctoral program was pass a qualifier test (\u201cthe qual\u201d), which was a three-hour oral examination at the conclusion of the Master\u2019s program.  <\/span>My qual was, without a doubt, the most grueling experience I\u2019d ever gone through \u2013 rougher than my actual dissertation several years later, and certainly rougher than a Microsoft interview.  <\/span>(\u201cYou just want me to write a program to shuffle a deck of cards?  <\/span>I think I can manage that\u2026\u201d)  <\/span>For the \u201cqual,\u201d it was common knowledge that you\u2019d be expected to memorize and write out on command just about every formula known to mankind about the physics of robotics.  <\/span>To prepare, I wrote down 78 equations that I thought would be fair game during the exam, and I spent one hour a day for two months memorizing those equations \u2013 I kid you not.  <\/span>Equations invaded my dreams; for example, \u201cIn order to slay the dragon, I\u2019ll have to apply an iterative Newton-Euler dynamic formulation to determine the acceleration and velocity of the sword based on the degrees of freedom in my arm.\u201d  <\/span>One of the equations involved 26 variables and I was indeed asked to write it down during the exam, and to my utter delight, I got it right.<\/font><\/p>\n

Within two days of passing my qualifier, the equations escaped from my brain, and I didn\u2019t care.  <\/span>Hey, that\u2019s what docs are for.  <\/span>I don\u2019t memorize VB language syntax, for example \u2013 I look it up in a book or on-line, same as everyone else, except possibly our architect Paul Vick, whom I think has it all tattooed on his arms.<\/font><\/p>\n

However, there comes a time when you need to use those equations, and working it out longhand would be tedious or impractical.  <\/span>That\u2019s where programming comes in.  <\/span>I\u2019m sure I\u2019m not the only person, for example, who programmed his calculator in college to solve quadratic equations for the roots \u2013 very handy during exams where you could be expected to take that ability for granted.  <\/span>Unfortunately, during my tenure as a graduate student, calculators didn\u2019t have nearly enough memory to quickly solve matrix equations (at least not the ones I could afford), and matrices are the backbone of all robotics formulae.  <\/span>However, these days a handheld device running Windows Mobile 5.0 or WindowsCE certainly has enough horsepower to do this, so in this two-part series I\u2019ll walk through putting together such a matrix calculator.  <\/span>In this part, I\u2019ll just be working with a class library, and next week, I\u2019ll get it onto the handheld.<\/font><\/p>\n

Matrices<\/font><\/h2>\n

The first thing I\u2019ll need is a matrix class, and to do that I\u2019ll create a class library called Matrices simply by choosing CreateNewProject, choosing \u201cClass Library,\u201d and changing the name appropriately before clicking \u201cOK.\u201d (Don\u2019t worry if you forget to change the name \u2013 in VB2005, it\u2019s never too late to change it, and you can do it later simply be changing the name of the file in the solution explorer).<\/font><\/p>\n

I\u2019ll rename the class inside to be called \u201cMatrix.\u201d  <\/span>Again, don\u2019t worry, you can also do this later by right-clicking on the name of the class and choosing \u201cRename.\u201d<\/font><\/p>\n

 <\/span>A matrix has some number of rows and columns (by the way, this entire series will be 0-based as far as arrays are concerned, not 1-based).  <\/span>Here\u2019s the bare-bones version:<\/font><\/font><\/p>\n

    <\/span>Private<\/span> _rows As<\/span> Integer<\/span> = 0<\/span><\/p>\n

    <\/span>Private<\/span> _columns As<\/span> Integer<\/span> = 0<\/span><\/p>\n

    <\/span>Public<\/span> ReadOnly<\/span> Property<\/span> Rows() As<\/span> Double<\/span><\/span><\/p>\n

        <\/span>Get<\/span><\/span><\/p>\n

            <\/span>Return<\/span> _rows<\/span><\/p>\n

        <\/span>End<\/span> Get<\/span><\/span><\/p>\n

    <\/span>End<\/span> Property<\/span><\/span><\/p>\n

    <\/span>Public<\/span> ReadOnly<\/span> Property<\/span> Columns() As<\/span> Double<\/span><\/span><\/p>\n

        <\/span>Get<\/span><\/span><\/p>\n

            <\/span>Return<\/span> _columns<\/span><\/p>\n

        <\/span>End<\/span> Get<\/span><\/span><\/p>\n

    <\/span>End<\/span> Property<\/span><\/span><\/p>\n

 <\/span><\/p>\n

    <\/span>Public<\/span> data(,) As<\/span> Double<\/span><\/span><\/p>\n

 <\/font><\/p>\n

All very straightforward.  <\/span>Note that the number of rows and columns default to zero.  <\/span>Clearly, they need to be non-zero, so in the class constructor, I\u2019ll enforce the requirement to supply dimensions:<\/font><\/p>\n

    <\/span>Public<\/span> Sub<\/span> New<\/span>(ByVal<\/span> m As<\/span> Integer<\/span>, ByVal<\/span> n As<\/span> Integer<\/span>)<\/span><\/p>\n

        <\/span>ReDim<\/span> data(m – 1, n – 1)<\/span><\/p>\n

        <\/span>_rows = m<\/span><\/p>\n

        <\/span>_columns = n<\/span><\/p>\n

    <\/span>End<\/span> Sub<\/span><\/span><\/p>\n

 <\/font><\/p>\n

Note the use of ReDim \u2013 this will allow me to dynamically determine the size of the array at runtime, rather than having to hard-code the array size.  <\/span>Also note that it looks like I\u2019m re-dimming them for one size less than I need.  <\/span>This is because VB automatically adds on element to each array for historical reasons, as many programmers in the past preferred to work with 1-based notation.  <\/span>I don\u2019t need the extra memory, and it makes looking at matrices in the debugger window confusing, so out it goes.  <\/span>(And yes, if you call New(1,1), it will redim the array to (0,0), which, after VB adds the additional row and column as usual, turns out to be 1 allocated element.  <\/span>It hurts my head to think too hard about that, but at least the right thing happens in the end.)<\/font><\/p>\n

Now, if I wanted to add two matrices together, I could create a shared function called Add(m1,m2) which would add the two together, something like this:<\/font><\/p>\n

    <\/span>Public<\/span> Shared<\/span> Function<\/span> Add(ByVal<\/span> m1 As<\/span> Matrix, ByVal<\/span> m2 As<\/span> Matrix) As<\/span> Matrix<\/span><\/p>\n

        <\/span>‘ \u2026 etc\u2026<\/span><\/span><\/p>\n

    <\/span>End<\/span> Function<\/span><\/span><\/p>\n

    <\/span><\/span><\/p>\n

    <\/span>Dim<\/span> m3 As<\/span> Matrix = Matrix.Add(m1, m2)<\/span><\/p>\n

 <\/font><\/p>\n

But wouldn\u2019t it be cooler if we could just do:<\/font><\/p>\n

        <\/span>Dim<\/span> m3 As<\/span> Matrix = m1 + m2<\/span><\/p>\n

 <\/font><\/p>\n

Well, we can, thanks to something in VB2005 called operating overloading.  <\/span>I discussed operator overloading in some detail in <\/font>this article here<\/font><\/a> a few years ago, but the gist of it is that Operator Overloading allows you to assign methods to the various mathematical symbols (+, -, *, \/, etc.) for a given class.  <\/span>You can even define casting operators.  <\/span>Let\u2019s define an overload here for addition:<\/font><\/p>\n

    <\/span>Public<\/span> Shared<\/span> Operator<\/span> +(ByVal<\/span> m1 As<\/span> Matrix, ByVal<\/span> m2 As<\/span> Matrix) As<\/span> Matrix<\/span><\/p>\n

        <\/span>If<\/span> m1.Rows = 0 OrElse<\/span> m2.Rows = 0 OrElse<\/span> m1.Columns = 0 OrElse<\/span> m2.Columns = 0 Then<\/span><\/span><\/p>\n

            <\/span>Dim<\/span> ex As<\/span> New<\/span> System.Exception(“Attempt to add empty matrix.”<\/span>)<\/span><\/p>\n

            <\/span>Throw<\/span> ex<\/span><\/p>\n

        <\/span>End<\/span> If<\/span><\/span><\/p>\n

        <\/span>If<\/span> m1.Rows <> m2.Rows OrElse<\/span> m1.Columns <> m2.Columns Then<\/span><\/span><\/p>\n

            <\/span>Dim<\/span> ex As<\/span> New<\/span> System.Exception(“Attempt to add differently-shaped matrices.”<\/span>)<\/span><\/p>\n

            <\/span>Throw<\/span> ex<\/span><\/p>\n

        <\/span>End<\/span> If<\/span><\/span><\/p>\n

 <\/span><\/p>\n

        <\/span>Dim<\/span> m3 As<\/span> New<\/span> Matrix(m1.Rows, m1.Columns)<\/span><\/p>\n

        <\/span>For<\/span> i As<\/span> Integer<\/span> = 0 To<\/span> m1.Rows – 1<\/span><\/p>\n

            <\/span>For<\/span> j As<\/span> Integer<\/span> = 0 To<\/span> m1.Columns – 1<\/span><\/p>\n

                <\/span>m3.data(i, j) = m1.data(i, j) + m2.data(i, j)<\/span><\/p>\n

            <\/span>Next<\/span><\/span><\/p>\n

        <\/span>Next<\/span><\/span><\/p>\n

        <\/span>Return<\/span> m3<\/span><\/p>\n

    <\/span>End<\/span> Operator<\/span><\/span><\/p>\n

 <\/font><\/p>\n

Let\u2019s start with the signature from above.  <\/span>All operator overload methods are shared methods.  <\/span>They work on a particular symbol or keyword (in this case, the plus sign, +), and they take arguments having particular classes (in this case, two matrices), and they return some type (again, in this case, a matrix).  <\/span>What you do inside the rest of the method is totally up to you.  <\/span>I start out by making sure the matrices are the same size and that they are not empty, throwing if they fail those tests.  <\/span>Then, I simply create a new matrix, add together the contents of m1 and m2 to it, and then return the result.  <\/span>Simple, isn\u2019t it?<\/font><\/p>\n

If you\u2019ve guessed that an overloaded operator is really just a function, you\u2019re right.  <\/span>What you\u2019re getting out of it is simply the ability to write more readable code.  <\/span>You do need to take care to use them properly, though.  <\/span>Take this (contrived) example, where I allow a matrix to be multiplied by a scalar:<\/font><\/p>\n

    <\/span>Public<\/span> Shared<\/span> Operator<\/span> *(ByVal<\/span> m1 As<\/span> Matrix, ByVal<\/span> val As<\/span> Double<\/span>) As<\/span> Matrix<\/span><\/p>\n

        <\/span>Dim<\/span> m2 As<\/span> New<\/span> Matrix(m1.Rows, m1.Columns)<\/span><\/p>\n

        <\/span>For<\/span> i As<\/span> Integer<\/span> = 0 To<\/span> m1.Rows – 1<\/span><\/p>\n

            <\/span>For<\/span> j As<\/span> Integer<\/span> = 0 To<\/span> m1.Columns – 1<\/span><\/p>\n

                <\/span>m2.data(i, j) = m1.data(i, j) * val<\/span><\/p>\n

            <\/span>Next<\/span><\/span><\/p>\n

        <\/span>Next<\/span><\/span><\/p>\n

        <\/span>Return<\/span> m2<\/span><\/p>\n

    <\/span>End<\/span> Operator<\/span><\/span><\/p>\n

 <\/font><\/p>\n

So, the following code works:<\/font><\/p>\n

        <\/span>Dim<\/span> m1 As<\/span> New<\/span> Matrix(5, 5)<\/span><\/p>\n

  <\/span>‘ \u2026 Pretend there\u2019s code here that fills m1 with data<\/span><\/span><\/p>\n

        <\/span>Dim<\/span> m2 As<\/span> Matrix = m1 * 7.0 <\/span><\/p>\n

 <\/font><\/p>\n

But this doesn\u2019t \u2013 the arguments are in the wrong order:<\/font><\/p>\n

        <\/span>Dim<\/span> m1 As<\/span> New<\/span> Matrix(5, 5)<\/span><\/p>\n

  <\/span>‘ \u2026 Pretend there\u2019s code here that fills m1 with data<\/span><\/span><\/p>\n

        <\/span>Dim<\/span> m2 As<\/span> Matrix = 7.0 * m1 ‘ ERROR!<\/span><\/span><\/p>\n

 <\/span><\/p>\n

We can fix this by also defining the opposite arguments in a different overload:<\/font><\/p>\n

    <\/span>Public<\/span> Shared<\/span> Operator<\/span> *(ByVal<\/span> val As<\/span> Double<\/span>, ByVal<\/span> m1 As<\/span> Matrix) As<\/span> Matrix<\/span><\/p>\n

        <\/span>Return<\/span> m1 * val ‘ This will just call the other overload<\/span><\/span><\/p>\n

    <\/span>End<\/span> Operator<\/span><\/span><\/p>\n

 <\/font><\/p>\n

And now it doesn\u2019t matter what order the arguments are in for this particular case.  <\/span>(There are certainly cases where the argument order would matter for two different types, which is why VB doesn\u2019t do this sort of thing automatically.)<\/font><\/p>\n

Of course, we can define other overloads on the multiplication operator, so long as the types and orders are different.  <\/span>For example, let’s add a third overload which multiplies two matrices, which is a vastly different operation than multiplying a matrix by a scalar:<\/font><\/p>\n

    <\/span>Public<\/span> Shared<\/span> Operator<\/span> *(ByVal<\/span> m1 As<\/span> Matrix, ByVal<\/span> m2 As<\/span> Matrix) As<\/span> Matrix<\/span><\/p>\n

        <\/span>If<\/span> m1.Rows = 0 OrElse<\/span> m2.Rows = 0 OrElse<\/span> m1.Columns = 0 OrElse<\/span> m2.Columns = 0 Then<\/span><\/span><\/p>\n

            <\/span>Dim<\/span> ex As<\/span> New<\/span> System.Exception(“Attempt to subtract empty matrix.”<\/span>)<\/span><\/p>\n

            <\/span>Throw<\/span> ex<\/span><\/p>\n

        <\/span>End<\/span> If<\/span><\/span><\/p>\n

        <\/span>If<\/span> m1.Columns <> m2.Rows Then<\/span><\/span><\/p>\n

            <\/span>Dim<\/span> ex As<\/span> New<\/span> System.Exception(“Attempt to multiply incompatible matrices.”<\/span>)<\/span><\/p>\n

            <\/span>Throw<\/span> ex<\/span><\/p>\n

        <\/span>End<\/span> If<\/span><\/span><\/p>\n

        <\/span>Dim<\/span> m3 As<\/span> New<\/span> Matrix(m1.Rows, m2.Columns)<\/span><\/p>\n

        <\/span>For<\/span> ci As<\/span> Integer<\/span> = 0 To<\/span> m3.Rows – 1<\/span><\/p>\n

            <\/span>For<\/span> cj As<\/span> Integer<\/span> = 0 To<\/span> m3.Columns – 1<\/span><\/p>\n

                <\/span>‘ Fill in the Cij value in m3<\/span><\/span><\/p>\n

                <\/span>m3.data(ci, cj) = 0<\/span><\/p>\n

                <\/span>For<\/span> i As<\/span> Integer<\/span> = 0 To<\/span> m1.Columns – 1<\/span><\/p>\n

                    <\/span>m3.data(ci, cj) = m3.data(ci, cj) + m1.data(ci, i) * m2.data(i, cj)<\/span><\/p>\n

                <\/span>Next<\/span><\/span><\/p>\n

            <\/span>Next<\/span><\/span><\/p>\n

        <\/span>Next<\/span><\/span><\/p>\n

        <\/span>Return<\/span> m3<\/span><\/p>\n

    <\/span>End<\/span> Operator<\/span><\/span><\/p>\n

 <\/font><\/p>\n

So, I can call:<\/font><\/p>\n

1.<\/font>       <\/span><\/span><\/span>5.0 * m1 (scalar multiplied by matrix)<\/font><\/p>\n

2.<\/font>       <\/span><\/span><\/span>m1 * 5.0 (matrix multiplied by scalar)<\/font><\/p>\n

3.<\/font>       <\/span><\/span><\/span>m1 * m2 (matrix multiplied by matrix)<\/font><\/p>\n

and in each case a totally different operator overload will be called, despite the consistent use of the asterisk operator.<\/font><\/p>\n

I\u2019ve attached the full library to this post.  <\/span>It includes methods for finding the determinant of a matrix, the inverse of a matrix, and the transpose of a matrix as well, since we\u2019ll need those next week \u2013 there\u2019s nothing particularly special about those methods, so I won’t dig into them here.  <\/span>(Keen eyes will note that I deliberately used the easiest calculations for the determinant and inverse, in order to make them more readable and to allow me to focus on the real subject, which was operator overloading.  <\/span>You can find more performant algorithms out on the web \u2013 they tend to be iterative and are often ghastly to try to read.)  <\/span>I\u2019ve also attached some test cases in a console application.<\/font><\/p>\n

Next week, we\u2019ll work on our hand-held matrix calculator.  <\/span>\u2018Til then\u2026<\/font><\/p>\n

–Matt–*<\/font><\/p>\n

 <\/font><\/p>\n

Matrices.zip<\/a><\/p>\n","protected":false},"excerpt":{"rendered":"

Over a decade ago, before I joined Microsoft, I was a doctoral candidate at Carnegie Mellon studying robotics.  One of the things that you had to do to get into the doctoral program was pass a qualifier test (\u201cthe qual\u201d), which was a three-hour oral examination at the conclusion of the Master\u2019s program.  My qual […]<\/p>\n","protected":false},"author":258,"featured_media":8818,"comment_status":"open","ping_status":"closed","sticky":false,"template":"","format":"standard","meta":{"_acf_changed":false,"footnotes":""},"categories":[22,195],"tags":[101,165],"class_list":["post-6133","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-matt-gertz","category-visual-basic","tag-matt-gertz","tag-vb2005"],"acf":[],"blog_post_summary":"

Over a decade ago, before I joined Microsoft, I was a doctoral candidate at Carnegie Mellon studying robotics.  One of the things that you had to do to get into the doctoral program was pass a qualifier test (\u201cthe qual\u201d), which was a three-hour oral examination at the conclusion of the Master\u2019s program.  My qual […]<\/p>\n","_links":{"self":[{"href":"https:\/\/devblogs.microsoft.com\/vbteam\/wp-json\/wp\/v2\/posts\/6133","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/devblogs.microsoft.com\/vbteam\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/devblogs.microsoft.com\/vbteam\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/vbteam\/wp-json\/wp\/v2\/users\/258"}],"replies":[{"embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/vbteam\/wp-json\/wp\/v2\/comments?post=6133"}],"version-history":[{"count":0,"href":"https:\/\/devblogs.microsoft.com\/vbteam\/wp-json\/wp\/v2\/posts\/6133\/revisions"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/vbteam\/wp-json\/wp\/v2\/media\/8818"}],"wp:attachment":[{"href":"https:\/\/devblogs.microsoft.com\/vbteam\/wp-json\/wp\/v2\/media?parent=6133"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/vbteam\/wp-json\/wp\/v2\/categories?post=6133"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/vbteam\/wp-json\/wp\/v2\/tags?post=6133"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}