StackOverflow2013

Note that there are some explanatory texts on larger screens.

plurals

PO
primarykey
Id
1022743
data
AcceptedAnswerId
0
AnswerCount
0
ClosedDate
CommentCount
7
CommunityOwnedDate
2009-06-30T00:47:56.200
CreationDate
2009-06-20T22:52:25.540
FavoriteCount
0
LastActivityDate
2016-10-20T08:27:01.820
LastEditDate
2016-10-20T08:27:01.820
LastEditorUserId
832230
OwnerUserId
115200
ParentId
1016284
PostTypeId
2
Score
42
ViewCount
0
LastEditorDisplayName
text
Body
Original answer: I'm not sure if you will like how mathematical courses typically introduce matrices. As a programmer you might be happier with grabbing any decent 3D graphics book. It should certainly have very concrete 3x3 matrices. Also find out the ones that will teach you <a href="http://en.wikipedia.org/wiki/Projective_transformations" rel="nofollow noreferrer">projective transformations</a> (projective geometry is a very beautiful area of low-dimensional geometry and easy to program). <h1>Mini-course in matrix math with Python 3</h1> Contents: <ol> <li>Matrices <code>[Vector, __add__, reflect_y, rotate, dilate, transform]</code></li> <li>Matrices: Overloaded <code>[Matrix, __add__, __str__, __mul__, zero, det, inv, __pow__]</code></li> <li>Bonus: Complex numbers</li> <li>Matrices: The (R)evolution. It's already in the making (there's a summary at the end)</li> </ol> Preface: Based on my teaching experience, I think that the courses referenced by others are very good courses. That means if your goal is understanding matrices as mathematicians do, than you should by all means get the whole course. But if your goals are more modest, here's my try at something more tailored to your needs (but still written with the goal to convey many theoretical concepts, kind of contradicting my original advice.) How to use: <ul> <li>This post is long. You might consider printing this and going slow, like one part a day.</li> <li>Code is essential. This is a course for programmers. Exercises are essential too. </li> <li>You should <a href="http://mit.edu/~unknot/www/matrices.py" rel="nofollow noreferrer">take a look at the code companion</a> which contains all this code and much more</li> <li>It's "2 for the price of 1" special: you can also learn Python 3 here. And complex numbers.</li> <li>I'll highly value any attempt to read this (do I officially qualify for the longest post ever?), so feel free to comment if you don't understand something (and also if you do).</li> </ul> <h1>1. Matrices</h1> <h2>Vectors</h2> Before matrices come vectors. You sure know how to handle the 2- and 3- dimensional vectors: <pre><code>class Vector: """This will be a simple 2-dimensional vector. In case you never encountered Python before, this string is a comment I can put on the definition of the class or any function. It's just one of many cool features of Python, so learn it here! """ def __init__(self, x, y): self.x = x self.y = y </code></pre> now you can write <pre><code>v = Vector(5, 3) w = Vector(7, -1) </code></pre> but it's not much fun by itself. Let's add more useful methods: <pre><code> def __str__(self: 'vector') -> 'readable form of vector': return '({0}, {1})'.format(self.x, self.y) def __add__(self:'vector', v: 'another vector') -> 'their sum': return Vector(self.x + v.x, self.y + v.y) def __mul__(self:'vector', number: 'a real number') -> 'vector': '''Multiplies the vector by a number''' return Vector(self.x * number, self.y * number) </code></pre> That makes things more interesting as we can now write: <pre><code>print(v + w * 2) </code></pre> and get the answer <code>(19, 1)</code> nicely printed as a vector (if the examples look unfamiliar, think how this code would look in C++). <h2>Transformations</h2> Now it's all cool to be able to write <code>1274 * w</code> but you need more vector operations for the graphics. Here are some of them: you can flip the vector around <code>(0,0)</code> point, you can reflect it around <code>x</code> or <code>y</code> axis, you can rotate it clockwise or counterclockwise (it's a good idea to draw a picture here). Let's do some simple operations: <pre><code> ... def flip(self:'vector') -> 'vector flipped around 0': return Vector(-self.x, -self.y) def reflect_x(self:'vector') -> 'vector reflected around x axis': return Vector(self.x, -self.y) print(v.flip(), v.reflect_x()) </code></pre> <ul> <li>Question: is it possible to express <code>flip(...)</code> using the operations I had below? What about <code>reflect_x</code>?</li> </ul> Now you may wonder why I omitted <code>reflect_y</code>. Well, it's because I want you to stop for a moment and write your own version of it. Ok, here's mine: <pre><code> def reflect_y(self:'vector') -> 'vector reflected around y axis': return self.flip().reflect_x() </code></pre> See, if you look how this function computes, it's actually quite trivial. But suddenly an amazing thing happened: I was able to write a transformation using only the existing transformations <code>flip</code> and <code>reflect_x</code>. For all I care, <code>reflect_y</code> could be defined in a derived class without access to <code>x</code> and <code>y</code> and it would still work! Mathematicians would call these functions operators. They would say that <code>reflect_y</code> is an operator obtained by composition of operators <code>flip</code> and <code>reflect_x</code> which is denoted by <code>reflect_y = flip ○ reflect_x</code> (you should see the small circle, a Unicode symbol <code>25CB</code>). <ul> <li>Note: I will quite freely use the <code>=</code> symbol from now to denote that two operations produce the same result, like in the paragraph above. This is a "mathematical <code>=</code>", which <a href="http://en.wikipedia.org/wiki/List_of_undecidable_problems" rel="nofollow noreferrer">cannot be expressed as a program</a>.</li> </ul> So if I do <pre><code>print(v.reflect_y()) </code></pre> I get the result <code>(-5, 3)</code>. Go and picture it! <ul> <li>Question: Consider a composition <code>reflect_y ◦ reflect_y</code>. How would you name it? </li> </ul> <h2>Rotations</h2> Those operations were nice and useful, but you are probably wondering why am so slow to introduce rotations. Ok, here I go: <pre><code> def rotate(self:'vector', angle:'rotation angle') -> 'vector': ?????? </code></pre> At this point, if you know how to rotate vectors, you should go on and fill in the question marks. Otherwise please bear with me for one more simple case: counterclockwise rotation by <code>90</code> degrees. This one is not hard to draw on a piece of paper: <pre><code> def rotate_90(self:'vector') -> 'rotated vector': new_x = - self.y new_y = self.x return Vector(new_x, new_y) </code></pre> Trying <pre><code>x_axis = Vector(1, 0) y_axis = Vector(0, 1) print(x_axis.rotate_90(), y_axis.rotate_90()) </code></pre> now gives <code>(0, 1) (-1, 0)</code>. Run it yourself! <ul> <li>Question: Prove that <code>flip = rotate_90 ◦ rotate_90</code>.</li> </ul> Anyway, I won't hide the secret ingredient for longer: <pre><code>import math # we'll need math from now on ... class Vector: ... def rotate(self:'vector', angle:'rotation angle') -> 'rotated vector': cos = math.cos(angle) sin = math.sin(angle) new_x = cos * self.x - sin * self.y new_y = sin * self.x + cos * self.y return Vector(new_x, new_y) </code></pre> Now let's try something along the lines: <pre><code>print(x_axis.rotate(90), y_axis.rotate(90)) </code></pre> If you expect the same result as before, <code>(0, 1) (-1, 0)</code>, you're bound to be disappointed. That code prints: <pre><code>(-0.448073616129, 0.893996663601) (-0.893996663601, -0.448073616129) </code></pre> and boy, is it ugly! <ul> <li>Notation: I will say that we applied operation <code>rotate(90)</code> to <code>x</code> in the example above. The knowledge we gained is that <code>rotate(90) != rotate_90</code>.</li> <li>Question: What happened here? How to express <code>rotate_90</code> in terms of <code>rotate</code>? How to express <code>flip</code> in terms of <code>rotate</code>?</li> </ul> <h2>Dilations</h2> Those rotations are certainly useful, but they are not everything you need to do even the 2D graphics. Consider the following transformations: <pre><code> def dilate(self:'vector', axe_x:'x dilation', axe_y:'y dilation'): '''Dilates a vector along the x and y axes''' new_x = axe_x * self.x new_y = axe_y * self.y return Vector(new_x, new_y) </code></pre> This <code>dilate</code> thing dilates the <code>x</code> and <code>y</code> axes in a possibly different way. <ul> <li>Exercise: Fill in the question marks in <code>dilate(?, ?) = flip</code>, <code>dilate(?, ?) = reflect_x</code>.</li> </ul> I will use this <code>dilate</code> function to demonstrate a thing mathematicians call commutativity: that is, for every value of parameters <code>a</code>, <code>b</code>, <code>c</code>, <code>d</code> you can be sure that <pre><code>dilate(a, b) ◦ dilate(c, d) = dilate(c, d) ◦ dilate(a, b) </code></pre> <ul> <li>Exercise: Prove it. Also, is it true that for all possible values of parameters those below would hold? <ul> <li><code>rotate(a) ◦ rotate(b) = rotate(b) ◦ rotate(a)</code></li> <li><code>dilate(a, b) ◦ rotate(c) = rotate(c) ◦ dilate(a, b)</code></li> <li><code>rotate(a) ◦ __mul__(b) = __mul__(b) ◦ rotate(a)</code></li> </ul></li> </ul> <h2>Matrices</h2> Let's summarize all the stuff we had around here, our operators on vector <code>x</code> <ul> <li><code>flip</code>, <code>reflect_x</code>, <code>*</code>, <code>rotate(angle)</code>, <code>dilate(x, y)</code></li> </ul> from which one could make some really crazy stuff like <ul> <li><code>flip ◦ rotate(angle) ◦ dilate(x, y) ◦ rotate(angle_2) ◦ reflect_y + reflect_x = ???</code></li> </ul> As you create more and more complicated expressions, one would hope for some kind of order that would suddenly reduce all possible expressions to a useful form. Fear not! Magically, every expression of the form above can be simplified to <pre><code> def ???(self:'vector', parameters): '''A magical representation of a crazy function''' new_x = ? * self.x + ? * self.y new_y = ? * self.x + ? * self.y return Vector(new_x, new_y) </code></pre> with some numbers and/or parameters instead of <code>?</code>s. <ul> <li>Example: Work out what the values of '?' are for <code>__mul__(2) ◦ rotate(pi/4)</code></li> <li>Another example: Same question for <code>dilate(x, y) ◦ rotate(pi/4)</code></li> </ul> This allows us to write a universal function <pre><code> def transform(self:'vector', m:'matrix') -> 'new vector': new_x = m[0] * self.x + m[1] * self.y new_y = m[2] * self.x + m[3] * self.y return Vector(new_x, new_y) </code></pre> which would take any 4-tuple of numbers, called matrix, and apply it to vector <code>x</code>. Here's an example: <pre><code>rotation_90_matrix = (0, -1, 1, 0) print(v, v.rotate_90(), v.transform(rotation_90_matrix)) </code></pre> which prints <code>(5, 3) (-3, 5) (-3, 5)</code>. Note that if you apply <code>transform</code> with any matrix to origin, you still get origin: <pre><code>origin = Vector(0, 0) print(origin.transform(rotation_90_matrix)) </code></pre> <ul> <li>Exercise: what are the tuples <code>m</code> that describe <code>flip</code>, <code>dilate(x, y)</code>, <code>rotate(angle)</code>?</li> </ul> As we part with the <code>Vector</code> class, here's an exercise for those who want to test both their vector math knowledge and Pythonic skills: <ul> <li>The final battle: Add to the <code>Vector</code> class all vector operations that you can come up with (how many of standard operators can you overload for vectors? Check out my answer).</li> </ul> <h1>2. Matrices: Overloaded</h1> As we found out in the previous section, a matrix can be thought of a shorthand that allows us to encode a vector operation in a simple way. For example, <code>rotation_90_matrix</code> encodes the rotation by 90 degrees. <h2>Matrix objects</h2> Now as we shift our attention from vectors to matrices, we should by all means have a class for matrix as well. Moreover, in that function <code>Vector.transform(...)</code> above the role of the matrix was somewhat misrepresented. It's more usual for <code>m</code> to be fixed while vector changes, so from now on our transformations will be methods of matrix class: <pre><code>class Matrix: def __init__(self:'new matrix', m:'matrix data'): '''Create a new matrix. So far a matrix for us is just a 4-tuple, but the action will get hotter once The (R)evolution happens! ''' self.m = m def __call__(self:'matrix', v:'vector'): new_x = self.m[0] * v.x + self.m[1] * v.y new_y = self.m[2] * v.x + self.m[3] * v.y return Vector(new_x, new_y) </code></pre> If you don't know Python, <code>__call__</code> overloads the meaning of <code>(...)</code> for matrices so I can use the standard notation for a matrix acting on a vector. Also, the matrices are usually written using a single uppercase letter: <pre><code>J = Matrix(rotation_90_matrix) print(w, 'rotated is', J(w)) </code></pre> <ul> <li>Exercise: repeat this example with matrices from the previous exercise. </li> </ul> <h2>Addition</h2> Now, let's find out what else we can do with matrices. Remember that matrix <code>m</code> is really just a way to encode an operaton on vectors. Note that for two functions <code>m1(x)</code> and <code>m2(x)</code> I can create a new function (using <a href="http://en.wikipedia.org/wiki/Lambda_calculus" rel="nofollow noreferrer">lambda notation</a>) <code>m = lambda x: m1(x) + m2(x)</code>. It turns out if <code>m1</code> and <code>m2</code> were enconded by matrices, you can also encode this <code>m</code> using matrices! <ul> <li>Exercise: Think through any difficulties you might have with this statement.</li> </ul> You just have to add its data, like <code>(0, 1, -1, 0) + (0, 1, -1, 0) = (0, 2, -2, 0)</code>. Here's how to add two tuples in Python, with some very useful and highly Pythonic techniques: <pre><code> def __add__(self:'matrix', snd:'another matrix'): """This will add two matrix arguments. snd is a standard notation for second argument. (i for i in array) is Python's powerful list comprehension. zip(a, b) is used to iterate over two sequences together """ new_m = tuple(i + j for i, j in zip(self.m, snd.m)) return Matrix(new_m) </code></pre> Now we can write expressions like <code>J + J</code> or even <code>J + J + J</code>, but to see the results we have to figure out how to print a Matrix. A possible way would be to print a 4-tuple of numbers, but let's take a hint from the <code>Matrix.__call__</code> function that the numbers should be organized into a <code>2x2</code> block: <pre><code> def as_block(self:'matrix') -> '2-line string': """Prints the matrix as a 2x2 block. This function is a simple one without any advanced formatting. Writing a better one is an exercise. """ return ('| {0} {1} |\n' .format(self.m[0], self.m[1]) + '| {0} {1} |\n' .format(self.m[2], self.m[3]) ) </code></pre> If you look at this function in action you'll notice there is some room for improvement: <pre><code>print((J + J + J).as_block()) </code></pre> <ul> <li>Exercise: write a nicer function <code>Matrix.__str__</code> that will round the numbers and print them in the fields of fixed length.</li> </ul> Now you should be able to write the matrix for rotation: <pre><code>def R(a: 'angle') -> 'matrix of rotation by a': cos = math.cos(a) sin = math.sin(a) m = ( ????? ) return Matrix(m) </code></pre> <ul> <li>Exercise: Examine the code for <code>Vector.rotate(self, angle)</code> and fill in the question marks. Test with <pre><code>from math import pi print(R(pi/4) + R(-pi/4)) </code></pre></li> </ul> <h2>Multiplication</h2> The most important thing we can do with one-parameter functions is compose them: <code>f = lambda v: f1(f2(v))</code>. How to mirror that with matrices? This requires us to examine how <code>Matrix(m1) ( Matrix(m2) (v))</code> works. If you expand it, you'll notice that <pre><code>m(v).x = m1[0] * (m2[0]*v.x + m2[1]*v.y) + m1[1] * (m2[2]*v.x + m2[3]*v.y) </code></pre> and similarly for <code>m(v).y</code>, which, if you open the parentheses, looks suspiciously similar to <code>Matrix.__call__</code> using a new tuple <code>m</code>, such that <code>m[0] = m1[0] * m2[0] + m1[2] * m2[2]</code>. So let's take this as a hint for a new definiton: <pre><code> def compose(self:'matrix', snd:'another matrix'): """Returns a matrix that corresponds to composition of operators""" new_m = (self.m[0] * snd.m[0] + self.m[1] * snd.m[2], self.m[0] * snd.m[1] + self.m[1] * snd.m[3], ???, ???) return Matrix(new_m) </code></pre> <ul> <li>Exercise: Fill in the question marks here. Test it with <pre><code>print(R(1).compose(R(2))) print(R(3)) </code></pre></li> <li>Math exercise: Prove that <code>R(a).compose(R(b))</code> is always the same as <code>R(a + b)</code>.</li> </ul> Now let me tell the truth: this <code>compose</code> function is actually how mathematicians decided to multiply matrices. This makes sense as a notation: <code>A * B</code> is a matrix that decribes operator <code>A ○ B</code>, and as we'll see next there are deeper reasons to call this 'multiplication' as well. To start using multiplication in Python all we have to do is to order it so in a <code>Matrix</code> class: <pre><code> class Matrix: ... __mul__ = compose </code></pre> <ul> <li>Exercise: Compute <code>(R(pi/2) + R(pi)) * (R(-pi/2) + R(pi))</code>. Try to find the answer yourself first on a piece of paper.</li> </ul> <h2>Rules for <code>+</code> and <code>*</code></h2> Let's make some good name for the matrix that corresponds to the <code>dilate(a, b)</code> operator. Now there's nothing wrong with <code>D(a, b)</code>, but I'll use a chance to introduce a standard notation: <pre><code>def diag(a: 'number', b: 'number') -> 'diagonal 2x2 matrix': m = (a, 0, 0, b) return Matrix(m) </code></pre> Try <code>print(diag(2, 12345))</code> to see why it's called a diagonal matrix. As the composition of operations was found before to be not always commutative, <code>*</code> operator won't be always commutative for matrices either. <ul> <li>Exercise: go back and refresh the commutativity thing if necessary. Then give examples of matrices <code>A</code>, <code>B</code>, made from <code>R</code> and <code>diag</code>, such that <code>A * B</code> is not equal to <code>B * A</code>.</li> </ul> This is somewhat strange, since multiplication for numbers is always commutative, and raises the question whether <code>compose</code> really deserves to be called <code>__mul__</code>. Here's quite a lot of rules that <code>+</code> and <code>*</code> do satisfy: <ol> <li><code>A + B = B + A</code></li> <li><code>A * (B + C) = A * B + A * C</code></li> <li><code>(A + B) * C = A * C + B * C</code></li> <li><code>(A * B) * C = A * (B * C)</code></li> <li>There is an operation called <code>A - B</code> and <code>(A - B) + B = A</code> <ul> <li>Exercise: Prove these statements. How to define <code>A - B</code> in terms of <code>+</code>, <code>*</code> and <code>diag</code>? What does <code>A - A</code> equal to? Add the method <code>__sub__</code> to the class <code>Matrix</code>. What happens if you compute <code>R(2) - R(1)*R(1)</code>? What should it be equal to?</li> </ul></li> </ol> The <code>(A * B) * C = A * (B * C)</code> equality is called associativity and is especially nice since it means that we don't have to worry about putting parentheses in an expression of the form <code>A * B * C</code>: <pre><code>print(R(1) * (diag(2,3) * R(2))) print((R(1) * diag(2,3)) * R(2)) </code></pre> Let's find analogues to regular numbers <code>0</code> and <code>1</code> and subtraction: <pre><code>zero = diag(0, 0) one = diag(1, 1) </code></pre> With the following easily verifiable additions: <ol> <li><code>A + zero = A</code></li> <li><code>A * zero = zero</code></li> <li><code>A * one = one * A = A</code></li> </ol> the rules become complete, in the sense that there is a short name for them: ring axioms. Mathematicians thus would say that matrices form a ring, and they indeed always use symbols <code>+</code> and <code>*</code> when talking about rings, and so shall we. Using the rules it's possible to easily compute the expression from the previous section: <pre><code>(R(pi/2) + R(pi)) * (R(-pi/2) + R(pi)) = R(pi/2) * R(-pi/2) + ... = one + ... </code></pre> <ul> <li>Exercise: Finish this. Prove that <code>(R(a) + R(b)) * (R(a) - R(b)) = R(2a) - R(2b)</code>. </li> </ul> <h2>Affine Transformations</h2> Time to return to how we defined matrices: they are a shortcut to some operations you can do with vectors, so it's something you can actually draw. You might want to take a pen or look at the materials that others suggested to see examples of different plane transformations. Among the transformations we'll be looking for the affine ones, those who look 'the same' everywhere (no bending). For example, a rotation around some point <code>(x, y)</code> qualifies. Now this one cannot be expressed as <code>lambda v: A(v)</code>, but in can be written in the form <code>lambda v: A(v) + b</code> for some matrix <code>A</code> and vector <code>b</code>. <ul> <li>Exercise: find the <code>A</code> and <code>b</code> such that a rotation by <code>pi/2</code> around the point <code>(1, 0)</code> has the form above. Are they unique?</li> </ul> Note that for every vector there is an affine transformation which is a shift by the vector. An affine transformation may stretch or dilate shapes, but it should do in the same way everywhere. Now I hope you believe that the area of any figure changes by a constant number under the transformation. For a transformation given by matrix <code>A</code> this coeffiecient is called the determinant of <code>A</code> and can be computed applying the formula for an area to two vectors <code>A(x_axis)</code> and <code>A(y_axis)</code>: <pre><code> def det(self: 'matrix') -> 'determinant of a matrix': return self.m[0]*self.m[3] - self.m[1] * self.m[2] </code></pre> As a sanity check, <code>diag(a, b).det()</code> is equal to <code>a * b</code>. <ul> <li>Exercise: Check this. What happens when one of arguments is 0? When it's negative?</li> </ul> As you can see, the determinant of rotation matrix is always the same: <pre><code>from random import random r = R(random()) print (r, 'det =', r.det()) </code></pre> One interesting thing about <code>det</code> is that it is multiplicative (it kind of follows from the definition if you meditate long enough): <pre><code>A = Matrix((1, 2, -3, 0)) B = Matrix((4, 1, 1, 2)) print(A.det(), '*', B.det(), 'should be', (A * B).det()) </code></pre> <h2>Inverse</h2> A useful thing you can do with matrices is write a system of two linear equations <pre><code>A.m[0]*v.x + A.m[1]*v.y = b.x A.m[2]*v.x + A.m[3]*v.y = b.y </code></pre> in a simpler way: <code>A(v) = b</code>. Let's solve the system as they teach in (some) high schools: multiply first equation by <code>A.m[3]</code>, second by -A.m<a href="http://en.wikipedia.org/wiki/Projective_transformations" rel="nofollow noreferrer">1</a> and add (if in doubt, do this on a piece of paper) to solve for <code>v.x</code>. If you really tried it, you should have got <code>A.det() * v.x = (A.m[3]) * b.x + (-A.m[1]) * b.y</code>, which suggests that you can always get <code>v</code> by multiplying <code>b</code> by some other matrix. This matrix is called inverse of <code>A</code>: <pre><code> def inv(self: 'matrix') -> 'inverse matrix': '''This function returns an inverse matrix when it exists, or raises ZeroDivisionError when it doesn't. ''' new_m = ( self.m[3] / self.det(), -self.m[1] / self.det(), ????? ) return Matrix(new_m) </code></pre> As you see, this method fails loudly when determinant of matrix is zero. If you really want you can catch this expection with: <pre><code>try: print(zero.inv()) except ZeroDivisionError as e: ... </code></pre> <ul> <li>Exercise: Finish the method. Prove that inverse matrix doesn't exist when <code>self.det() == 0</code>. Write the method to divide matrices and test it. Use the inverse matrix to solve an equation <code>A(v) = x_axis</code> (<code>A</code> was defined above).</li> </ul> <h2>Powers</h2> The main property of inverse matrix is that <code>A * A.inv()</code> always equals to <code>one</code> <ul> <li>Exercise: check that yourself. Explain why that should be so from the definition of inverse matrix.</li> </ul> That's why mathematicians denote <code>A.inv()</code> by <code>A</code>-1. How about we write a nice function to use <code>A ** n</code> notation for <code>A</code>n? Note that the naive <code>for i in range(n): answer *= self</code> cycle is O(|n|) which is certainly too slow, because this can be done with a complexity of <code>log |n|</code>: <pre><code> def __pow__(self: 'matrix', n:'integer') -> 'n-th power': '''This function returns n-th power of the matrix. It does it more efficiently than a simple for cycle. A while loop goes over all bits of n, multiplying answer by self ** (2 ** k) whenever it encounters a set bit. ... </code></pre> <ul> <li>Exercise: Fill in the details in this function. Test it with <code>X, Y = A ** 5, A ** -5</code> <code>print (X, Y, X * Y, sep = '\n')</code></li> </ul> This function only works for integer values of <code>n</code>, even though for some matrices we can also define a fractional power, such as square root (in other words, a matrix <code>B</code> such that <code>B * B = A</code>). <ul> <li>Exercise: Find a square root of <code>diag(-1, -1)</code>. Is this the only possible answer? Find an example of matrix that doesn't have a square root.</li> </ul> <h1>Bonus: Complex numbers</h1> Here I'm going to introduce you to the subject in exactly one section! Since it's a complex subject, I'm likely to fail, so please forgive me in advance. First, similarly to how we have matrices <code>zero</code> and <code>one</code>, we can make a matrix out of any real number by doing <code>diag(number, number)</code>. Matrices of that form can be added, subtracted, multiplied, inverted and the results would mimic what happens with the numbers themselves. So for all practical purposes, one can say that, e.g., <code>diag(5, 5)</code> is 5. However, Python doesn't know yet how to handle expressions of the form <code>A + 1</code> or <code>5 * B</code> where <code>A</code> and <code>B</code> are matrices. If you're interested, you should by all means go and do the following exercise or look at my implementation (which uses a cool Python feature called decorator); otherwise, just know that it's been implemented. <ul> <li>Exercise for gurus: Change the operators in a <code>Matrix</code> class so that in all standard operations where one of operands is a matrix and another a number, the number is automatically converted to the <code>diag</code> matrix. Also add comparison for equality.</li> </ul> Here's an example test: <pre><code>print( 3 * A - B / 2 + 5 ) </code></pre> Now here's the first interesting complex number: the matrix <code>J</code>, introduced in the beginning and equal to <code>Matrix((0, 1, -1, 0))</code>, has a funny property that <code>J * J == -1</code> (try it!). That means <code>J</code> is certainly not a normal number, but, as I just said, matrices and numbers easily mix together. For example, <pre><code>(1 + J) * (2 + J) == 2 + 2 * J + 1 * J + J * J = 1 + 3 * J </code></pre> using the rules listed some time before. What happens if we test this in Python? <pre><code>(1 + J) * (2 + J) == 1 + 3*J </code></pre> That should happily say <code>True</code>. Another example: <pre><code>(3 + 4*J) / (1 - 2*J) == -1 + 2*J </code></pre> As you might have guessed, the mathematicians don't call those 'crazy numbers', but they do something similar - they call expressions of the form <code>a + b*J</code> complex numbers. Because those are still instances of our <code>Matrix</code> class, we can do quite a lot of operations with those: addition, subtraction, multiplication, division, power - it's all already implemented! Aren't matrices amazing? I have overlooked the question of how to print the result of operation like <code>E = (1 + 2*J) * (1 + 3*J)</code> so that it looks like an expression with <code>J</code> rather than a <code>2x2</code> matrix. If you examine it carefully, you'll see that you need to print the left column of that matrix in the format <code>... + ...J</code> (just one more nice thing: it's exactly <code>E(x_axis)</code>!) Those who know the difference between <code>str()</code> and <code>repr()</code> should see it's natural to name a function that would produce expression of such form as <code>repr()</code>. <ul> <li>Exercise: Write the function <code>Matrix.__repr__</code> that would do exactly that and try some tests with it, like <code>(1 + J) ** 3</code>, first computing the result on paper and then trying it with Python.</li> <li>Math question: What is the determinant of <code>a + b*J</code>? If you know what the absolute value of complex number is: how they are connected? What is the absolute value of <code>a</code>? of <code>a*J</code>?</li> </ul> <h1>3. Matrices: The (R)evolution</h1> In the final part of this trilogy we will see that everything is a matrix. We'll start with general <code>M x N</code> matrices, and find out how vectors can be thought of as <code>1 x N</code> matrices and why numbers are the same as diagonal matrices. As a side note we'll explore the complex numbers as <code>2 x 2</code> matrices. Finally, we will learn to write affine and projective transformations using matrices. So the classes planned are <code>[MNMatrix, NVector, Affine, Projective]</code>. I guess if you was able to bear with me until here, you could be interested in this sequel, so I'd like to hear if I should continue with this (and where, since I'm pretty much sure I'm beyond what considered reasonable length of a single document).
Tags
Title
singulars
PostAcceptedAnswerId
1. This table or related slice is empty.
PostParentId
1. POMatrix transforms; concepts and theory, are there any free resources for learning practically?
 singulars
 PostTypePostTypeId
 PTQuestion
PostTypePostTypeId
1. PTAnswer
UserLastEditorUserId
1. USA-B-B
UserOwnerUserId
1. USilya n.
plurals
PostLinksPostIdRelatedPostId
1. This table or related slice is empty.
PostLinksRelatedPostIdPostId
1. This table or related slice is empty.
PostsAcceptedAnswerId
1. POMatrix transforms; concepts and theory, are there any free resources for learning practically?
 singulars
 PostTypePostTypeId
 PTQuestion
PostsParentIdCreationDate
1. This table or related slice is empty.
VotesPostIdCreationDate
1. VO
 singulars
 PostPostId
 PO
 UserUserId
 This table or related slice is empty.
 VoteTypeVoteTypeId
 VTUpMod
2. VO
 singulars
 PostPostId
 PO
 UserUserId
 This table or related slice is empty.
 VoteTypeVoteTypeId
 VTUpMod
3. VO
 singulars
 PostPostId
 PO
 UserUserId
 This table or related slice is empty.
 VoteTypeVoteTypeId
 VTUpMod
CommentsPostId

Querying!

Guidance

A row detail

Detail views are divided into sections. All the information in the data section comes from columns in the selected row. The other sections display data from other, related rows.

Related data can be related in a to-one or a to-many fashion. Captions of data related in a to-many fashion link to a list view showing a filtered view of the table.

Try moving around until you find a non-empty to-many entry and click on the label to get to one. You can move back to the root by clicking on the database name in the header.