矩阵变换;概念和理论，是否有实际学习的免费资源？

本文介绍了矩阵变换;概念和理论，是否有实际学习的免费资源？的处理方法，对大家解决问题具有一定的参考价值，需要的朋友们下面随着小编来一起学习吧！

问题描述

我最近很乐意从坐标渲染图表和图表，我很着迷使用矩阵来转换坐标空间。

I've been having fun rendering charts and graphs from co-ordinates lately, and I'm fascinated by using matrices to transform co-ordinate spaces.

I已经能够成功地缩放和反转二维坐标空间，但现在我的胃口很大。：）

I've been able to successfully scale and invert 2 dimensional co-ordinate spaces, but now my appetite is whetted. :)

我在哪里可以获得关于矩阵，矩阵数学的清晰，信息丰富，（免费）的教育材料，特别是适用于二维和三维空间？

Where can I go for clear, informative, (free), educational material on matrices, matrix math, especially as applies to 2 and 3 dimensional space?

推荐答案

原始答案：我不确定您是否会喜欢数学课程通常如何引入矩阵。作为程序员，你可能会更喜欢抓住任何体面的3D图形书。它当然应该具有非常具体的3x3矩阵。还要找出能教你的那些（投影几何是一个非常美丽的领域）低维几何，易于编程）。

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 projective transformations (projective geometry is a very beautiful area of low-dimensional geometry and easy to program).

内容：

矩阵 [Vector，__ add__，reflect_y ，旋转，扩张，变换]

矩阵：重载 [Matrix，__ add __，_ _ ttr __，__ mul__，零，det，inv，__ pop __]

奖励：复杂数字

矩阵：（R）进化。它已经在制作中（最后有一个摘要）

Matrices [Vector, __add__, reflect_y, rotate, dilate, transform]
Matrices: Overloaded [Matrix, __add__, __str__, __mul__, zero, det, inv, __pow__]
Bonus: Complex numbers
Matrices: The (R)evolution. It's already in the making (there's a summary at the end)

前言：根据我的教学经验，我认为其他人引用的课程非常好课程。这意味着如果你的目标是像数学家一样理解矩阵，那么你应该通过各种手段来完成全部课程。但是如果你的目标更加温和，那么我的尝试就是根据你的需求量身定做的东西（但仍然是为了传达许多理论概念而写的，与我原来的建议相矛盾。）

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.)

如何使用：

这篇文章很长。你可能会考虑打印这个并且变慢，比如每天一个部分。

代码是必不可少的。这是程序员的课程。练习也很重要。

你应该，其中包含所有这些代码等等

这是2的价格为1特价：你也可以在这里学习Python 3。复杂的数字。

我非常重视任何读这篇文章的尝试（我是否正式获得有史以来最长的职位？），如果你不明白某事，请随时评论（如果你这样做的话）。

This post is long. You might consider printing this and going slow, like one part a day.
Code is essential. This is a course for programmers. Exercises are essential too.
You should take a look at the code companion which contains all this code and much more
It's "2 for the price of 1" special: you can also learn Python 3 here. And complex numbers.
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).

在矩阵到达向量之前。你肯定知道如何处理二维和三维向量：

Before matrices come vectors. You sure know how to handle the 2- and 3- dimensional vectors:

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

现在你可以写

v = Vector(5, 3)
w = Vector(7, -1)

但它本身并不是很有趣。让我们添加更多有用的方法：

but it's not much fun by itself. Let's add more useful methods:

    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)

这让事情变得更有趣，因为我们现在可以写：

That makes things more interesting as we can now write:

print(v + w * 2)

并获得答案（19,1）很好地打印为矢量（如果示例看起来不熟悉，请考虑这段代码在C ++中的外观）。

and get the answer (19, 1) nicely printed as a vector (if the examples look unfamiliar, think how this code would look in C++).

现在能够写 1274 * w 但是你需要更多的图形矢量操作。以下是其中一些：你可以在（0,0）点附近翻转矢量，你可以在 x 或 y 轴，您可以顺时针或逆时针旋转它（这里最好画一幅画）。

Now it's all cool to be able to write 1274 * w but you need more vector operations for the graphics. Here are some of them: you can flip the vector around (0,0) point, you can reflect it around x or y axis, you can rotate it clockwise or counterclockwise (it's a good idea to draw a picture here).

让我们做一些简单的操作：

Let's do some simple operations:

    ...

    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())

问题：是否有可能表达翻转（...）使用我下面的操作？怎么样 reflect_x ？

Question: is it possible to express flip(...) using the operations I had below? What about reflect_x?

现在你可能想知道为什么我省略 reflect_y 。嗯，这是因为我希望你停下片刻并编写你自己的版本。好的，这是我的：

Now you may wonder why I omitted reflect_y. Well, it's because I want you to stop for a moment and write your own version of it. Ok, here's mine:

    def reflect_y(self:'vector') -> 'vector reflected around y axis':
        return self.flip().reflect_x()

看，如果你看看这个函数如何计算，它实际上是非常微不足道的。但突然发生了一件令人惊奇的事情：我只能使用现有的转换 flip 和 reflect_x 来编写转换。对于我所关心的一切， reflect_y 可以在派生类中定义，而无需访问 x 和是，它仍然有用！

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 flip and reflect_x. For all I care, reflect_y could be defined in a derived class without access to x and y and it would still work!

数学家会将这些函数称为运算符。他们会说 reflect_y 是由运营商的组合获得的运算符 flip 和 reflect_x 这是
由 reflect_y = flip○reflect_x 表示（你应该看到一个小圆圈，一个Unicode符号 25CB ）。

Mathematicians would call these functions operators. They would say that reflect_y is an operator obtained by composition of operators flip and reflect_x which isdenoted by reflect_y = flip ○ reflect_x (you should see the small circle, a Unicode symbol 25CB).

注意：我会很自由从现在开始使用 = 符号表示两个操作产生相同的结果，如上面的段落所示。这是一个数学 = ，。

Note: I will quite freely use the = symbol from now to denote that two operations produce the same result, like in the paragraph above. This is a "mathematical =", which cannot be expressed as a program.

所以如果我这样做

print(v.reflect_y())

我得到了结果（ - 5,3）。去拍照吧！

I get the result (-5, 3). Go and picture it!

问题：考虑作文reflect_y◦refos_y。你怎么称呼它？

Question: Consider a composition reflect_y ◦ reflect_y. How would you name it?

这些操作既好又实用，但你很可能想知道为什么引入轮换这么慢。好的，我走了：

Those operations were nice and useful, but you are probably wondering why am so slow to introduce rotations. Ok, here I go:

    def rotate(self:'vector', angle:'rotation angle') -> 'vector':
        ??????

此时，如果你知道如何旋转矢量，你应该继续填写问题分数。否则请耐心等待一个简单的案例：逆时针旋转 90 度。这个并不难在一张纸上画出：

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 90 degrees. This one is not hard to draw on a piece of paper:

    def rotate_90(self:'vector') -> 'rotated vector':
        new_x = - self.y
        new_y =   self.x
        return Vector(new_x, new_y)

尝试

x_axis = Vector(1, 0)
y_axis = Vector(0, 1)

print(x_axis.rotate_90(), y_axis.rotate_90())

现在给出（0,1）（-1,0）。自己运行！

问题：证明 flip =rotate_90◦rotation_90。

Question: Prove that flip = rotate_90 ◦ rotate_90.

无论如何，我不会长时间隐藏秘密成分：

Anyway, I won't hide the secret ingredient for longer:

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)

现在让我们尝试一下：

print(x_axis.rotate(90), y_axis.rotate(90))

如果您期望得到与之前相同的结果，（0,1）（-1,0），你一定很失望。该代码打印：

If you expect the same result as before, (0, 1) (-1, 0), you're bound to be disappointed. That code prints:

(-0.448073616129, 0.893996663601) (-0.893996663601, -0.448073616129)

和男孩，难看！

符号：我会说我们将操作 rotate（90）应用到 x 在上面的例子中。我们获得的知识是 rotate（90）！= rotate_90 。

Notation: I will say that we applied operation rotate(90) to x in the example above. The knowledge we gained is that rotate(90) != rotate_90.

问题： 这里发生了什么？如何用 rotate 来表达 rotate_90 ？如何以旋转来表达翻转？

Question: What happened here? How to express rotate_90 in terms of rotate? How to express flip in terms of rotate?

这些旋转肯定是有用的，但它们并不是你需要做的所有事情，即使是2D图形也是如此。考虑以下转换：

Those rotations are certainly useful, but they are not everything you need to do even the 2D graphics. Consider the following transformations:

    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)

此扩张的事情以可能不同的方式扩展 x 和 y 轴。

This dilate thing dilates the x and y axes in a possibly different way.

练习：在 dilate（？，？）中填写问号=翻转，扩张（？，？）= reflect_x 。

Exercise: Fill in the question marks in dilate(?, ?) = flip, dilate(?, ?) = reflect_x.

我将使用这个 dilate 函数来演示数学家称之为交换性的东西：即，对于每个参数值 a ， b ， c ， d 你可以肯定

I will use this dilate function to demonstrate a thing mathematicians call commutativity: that is, for every value of parameters a, b, c, d you can be sure that

dilate(a, b) ◦ dilate(c, d) = dilate(c, d) ◦ dilate(a, b)

练习：证明一下。此外，对于以下所有可能的参数值是否正确？
- Exercise: Prove it. Also, is it true that for all possible values of parameters those below would hold?
  - 旋转（a）◦旋转（b）=旋转（b）◦旋转（a）
  - 扩张（a，b）◦转动（c）=旋转（c）◦扩张（a，b）
  - 旋转（a）◦__mul__（b）= __mul __（b）◦旋转（a）
  - rotate(a) ◦ rotate(b) = rotate(b) ◦ rotate(a)
  - dilate(a, b) ◦ rotate(c) = rotate(c) ◦ dilate(a, b)
  - rotate(a) ◦ __mul__(b) = __mul__(b) ◦ rotate(a)
  让我们总结一下我们在这里所有的东西，我们的运算符在vector x
  Let's summarize all the stuff we had around here, our operators on vector x
  - 翻转， reflect_x ， * ，旋转（角度），扩张（x，y）
  - flip, reflect_x, *, rotate(angle), dilate(x, y)
  从中可以制作一些非常疯狂的东西，比如
  from which one could make some really crazy stuff like
  - 翻转◦旋转（角度）◦扩张（x，y）◦旋转（angle_2）◦refos_y+ reflect_x = ???
  - flip ◦ rotate(angle) ◦ dilate(x, y) ◦ rotate(angle_2) ◦ reflect_y + reflect_x = ???
  当你创建越来越复杂的表达式时，人们会希望某种顺序会突然将所有可能的表达式减少为有用的形式。不要害怕！奇怪的是，上面表格的每个表达都可以简化为
  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
```
    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)
```
  包含一些数字和/或参数而不是？ s。
  with some numbers and/or parameters instead of ?s.
  - 示例：弄清楚'？'的值是什么 __ mul __（2）◦wall（pi / 4）
  - 另一个例如： 扩展相同的问题（x，y）◦Rating（pi / 4）
  - Example: Work out what the values of '?' are for __mul__(2) ◦ rotate(pi/4)
  - Another example: Same question for dilate(x, y) ◦ rotate(pi/4)
  这允许我们编写一个通用函数
  This allows us to write a universal function
```
    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)
```
  这将需要任意4元组的数字，称为矩阵，将应用于向量 x 。这是一个例子：
  which would take any 4-tuple of numbers, called matrix, and apply it to vector x. Here's an example:
```
rotation_90_matrix = (0, -1, 1, 0)
print(v, v.rotate_90(), v.transform(rotation_90_matrix))
```
  打印（5 ，3）（ - 3，5）（ - 3），。请注意，如果您使用
  将转换与任何矩阵一起应用于原点，您仍然可以获得原点：
  which prints (5, 3) (-3, 5) (-3, 5). Note that if you apply transform withany matrix to origin, you still get origin:
```
origin = Vector(0, 0)
print(origin.transform(rotation_90_matrix))
```
  - 练习：描述的元组 m 是什么翻转，扩张（x，y），旋转（角度）？

变换