矩阵变换； 概念和理论，有没有免费的实用学习资源？

Question

Closed. This question is seeking recommendations for software libraries, tutorials, tools, books, or other off-site resources. It does not meet Stack Overflow guidelines. It is not currently accepting answers.

---

我们不允许提出寻求软件库、教程、工具、书籍或其他场外资源推荐的问题。 您可以编辑问题，以便用事实和引文来回答。

8 年前已关闭。

Answer 1

原始答案：我不确定您是否会喜欢数学课程通常介绍矩阵的方式。 作为一名程序员，您可能会更乐意阅读一本像样的 3D 图形书。 它当然应该有非常具体的 3x3 矩阵。 另外，找出那些可以教您射影变换的内容（射影几何是一个非常美丽的领域低维几何且易于编程）。

使用 Python 3 进行矩阵数学迷你课程

内容：

1. 矩阵 [Vector、__add__、reflect_y、rotate、dilate、transform]
2. 矩阵：重载 [矩阵，__add__，__str__，__mul__，零，det，inv，__pow__]
3. 奖励：复数
4. 矩阵：(R)进化。 已经在制作中了（最后有总结）

前言：根据我的教学经验，我认为别人参考的课程都是很好的课程。 这意味着，如果您的目标是像数学家一样理解矩阵，那么您无论如何都应该学习整个课程。 但是，如果您的目标比较温和，那么我会尝试一些更适合您需求的内容（但仍然是为了传达许多理论概念而编写的，这有点与我最初的建议相矛盾。）

如何使用：

• 这篇文章很长。 您可以考虑打印此内容并缓慢进行，例如一天一份。
• 代码是必不可少的。 这是一门针对程序员的课程。 练习也是必不可少的。
• 您应该看看代码伴侣包含所有这些代码以及更多内容
• 这是“1 的价格 2”的特别之处：您还可以在这里学习 Python 3。 还有复数。
• 我将高度重视任何阅读本文的尝试（我正式有资格获得有史以来最长的帖子吗？），因此，如果您不明白某些内容（如果您理解了），请随时发表评论。

1. 矩阵
   =

向量

在矩阵之前是向量。 您肯定知道如何处理 2 维和 3 维向量：

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)

，但它本身并没有多大乐趣。 让我们添加更多有用的方法：

    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)
    
    

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

print(v + w * 2)

并得到答案 (19, 1) 很好地打印为向量（如果示例看起来不熟悉，请想想这段代码将如何看看C++）。

转换

现在能够编写 1274 * w 已经很酷了，但是您需要更多的图形矢量操作。 以下是其中一些：您可以围绕 (0,0) 点翻转矢量，可以围绕 x 或 y 轴反射它，你可以顺时针或逆时针旋转它（这里画图是个好主意）。

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

    ...

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

• 问题：是否可以使用我下面的操作来表达flip(...)？ reflect_x 怎么样？

现在您可能想知道为什么我省略了 reflect_y。 嗯，这是因为我想让你停下来写一下你自己的版本。 好吧，这是我的：

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

看，如果你看看这个函数是如何计算的，它实际上非常简单。 但突然发生了一件令人惊奇的事情：我能够仅使用现有的转换 flip 和 reflect_x 编写一个转换。 无论如何，我关心的是，reflect_y 可以在派生类中定义，而无需访问 x 和 y 并且它仍然可以工作！

数学家将这些函数称为“运算符”。 他们会说 reflect_y 是由运算符 flip 和 reflect_x 组合而成的运算符，即
由 reflect_y = Flip ○ Reflect_x 表示（您应该看到小圆圈，一个 Unicode 符号 25CB）。

• 注意： 从现在开始，我将非常自由地使用 = 符号来表示两个操作产生相同的结果，如上面的段落所示。 这是一个“数学=”，它不能用程序来表达。

因此，如果我这样做，

print(v.reflect_y())

我会得到结果 (-5, 3)。 去想象一下吧！

• 问题：考虑一个组合reflect_y ◦reflect_y。 你会怎么命名它？

旋转

这些操作很好而且很有用，但您可能想知道为什么引入旋转这么慢。 好吧，我开始了：

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

此时，如果你知道如何旋转向量，你应该继续填写问号。 否则请耐心听我讲一个更简单的情况：逆时针旋转 90 度。 在一张纸上画这个并不难：

    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°rotate_90。

无论如何，我不会再隐藏秘密成分了：

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)，您一定会失望的。 该代码打印：

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

天哪，它丑吗？

• 符号：我会说我们在上面的示例中将操作rotate(90)应用于x。 我们获得的知识是rotate(90) !=rotate_90。

• 问题：这里发生了什么？ 如何用rotate来表达rotate_90？ 如何用rotate来表达flip？

膨胀

这些旋转当然很有用，但它们并不是您完成 2D 图形所需的一切。 考虑以下转换：

    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)

此 dilate 事物以可能不同的方式扩大 x 和 y 轴。

• 练习：填写dilate(?, ?) = Flip、dilate(?, ?) =reflect_x中的问号。

我将使用这个dilate函数来演示数学家所说的交换性：也就是说，对于参数a、b<的每个值/code>, c, d 你可以确定

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

• 练习：证明它。 另外，对于所有可能的参数值，下面的值是否都成立？

  •  `旋转(a) ◦ 旋转(b) = 旋转(b) ◦ 旋转(a)` 
      

  •  `扩张(a, b) ◦ 旋转(c) = 旋转(c) ◦ 扩张(a, b)` 
      

  •  `旋转(a) ◦ __mul__(b) = __mul__(b) ◦ 旋转(a)` 
      

矩阵

让我们总结一下这里的所有内容，向量 x 上的运算符

• flip、reflect_x、*, rotate(angle), dilate(x, y)

从中我们可以做出一些非常疯狂的东西，比如

• flip ◦rotate(angle ) ◦ dilate(x, y) ◦rotate(angle_2) ◦reflect_y + Reflect_x = ???

当您创建越来越复杂的表达式时，人们会希望某种顺序能够突然将所有可能的表达式减少到一种有用的形式。 不要害怕！ 神奇的是，上述形式的每个表达式都可以简化为

    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)

使用一些数字和/或参数而不是 ?。

• 示例：计算出 '?' 的值是什么 适用于 __mul__(2) ◦rotate(pi/4)
• 另一个示例：与 dilate(x, y) 一样的问题 ◦rotate(pi/4)< /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)

，它可以接受任何 4 元组的数字，称为矩阵，并将其应用于向量x。 这是一个示例：

rotation_90_matrix = (0, -1, 1, 0)
print(v, v.rotate_90(), v.transform(rotation_90_matrix))

打印 (5, 3) (-3, 5) (-3, 5)。 请注意，如果您应用transform
任何矩阵到原点，你仍然得到原点：

origin = Vector(0, 0)
print(origin.transform(rotation_90_matrix))

• 练习：描述flip、dilate(x, y)的元组m是什么），旋转（角度）？

在我们讨论 Vector 类时，这里为那些想要测试向量数学知识和 Python 技能的人提供了一个练习：

• 最后的战斗： 添加到 Vector 对您可以想到的所有向量操作进行分类（您可以为向量重载多少个标准运算符？查看我的答案）。

2. 矩阵：重载
   =

正如我们在上一节中发现的，矩阵可以被认为是一种简写，它允许我们以简单的方式对向量运算进行编码。 例如，rotation_90_matrix 编码旋转 90 度。

矩阵对象

现在，当我们将注意力从向量转移到矩阵时，我们无论如何应该有一个类
对于矩阵也是如此。 此外，在上面的函数 Vector.transform(...) 中，矩阵的作用在某种程度上被歪曲了。 当向量发生变化时，m 更常见的是固定的，因此从现在开始我们的转换将是矩阵类的方法：

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)

如果您不了解 Python，__call__ 会重载(...) 对于矩阵的含义，因此我可以使用作用于向量的矩阵的标准表示法。 此外，矩阵通常使用单个大写字母编写：

J = Matrix(rotation_90_matrix)
print(w, 'rotated is', J(w))

• 练习：使用上一个练习中的矩阵重复此示例。

加法

现在，让我们看看我们还能用矩阵做什么。 请记住，矩阵 m 实际上只是对向量操作进行编码的一种方法。 请注意，对于两个函数 m1(x) 和 m2(x) 我可以创建一个新函数（使用 lambda 表示法) m = lambda x: m1(x) + m2(x)。 事实证明，如果 m1 和 m2 是由矩阵编码的，您也可以使用矩阵对这个 m 进行编码！

• 练习：思考一下您在执行此陈述时可能遇到的任何困难。

您只需添加其数据，例如 (0, 1, -1, 0) + (0, 1, -1, 0) = (0, 2, -2, 0)。 以下是如何在 Python 中添加两个元组，其中使用了一些非常有用且高度 Pythonic 的技术：

    def __add__(self:'matrix', snd:'another matrix'):
        """This will add two matrix arguments.
        
        snd is a standard notation for the 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)

现在我们可以编写像 J + J 甚至 J + J + J 这样的表达式，但是要查看结果，我们必须弄清楚如何打印矩阵。 一种可能的方法是打印 4 元组的数字，但让我们从 Matrix.__call__ 函数中得到提示，数字应该组织成一个 2x2 块：

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

如果您实际查看此函数，您会发现还有一些改进的空间：

print((J + J + J).as_block())

• 练习：编写一个更好的函数Matrix.__str__，该函数将四舍五入
  数字并将其打印在固定长度的字段中。

现在您应该能够编写旋转矩阵：

def R(a: 'angle') -> 'matrix of rotation by a':
    cos = math.cos(a)
    sin = math.sin(a)
    m = ( ????? )
    return Matrix(m)

• 练习： 检查 Vector.rotate(self, angle) 的代码并填写问号。 测试

   from math import pi         
      打印（R（pi / 4）+ R（-pi / 4）） 
    

乘法

进行测试对于单参数函数，我们可以做的最重要的事情就是组合它们：f = lambda v: f1(f2(v))。 如何用矩阵来反映它？ 这需要我们检查Matrix(m1) ( Matrix(m2) (v)) 是如何工作的。 如果展开它，您会注意到，

m(v).x = m1[0] * (m2[0]*v.x + m2[1]*v.y) + m1[1] * (m2[2]*v.x + m2[3]*v.y)

对于 m(v).y 也是如此，如果打开括号，它看起来非常相似
使用新元组 m 转换为 Matrix.__call__，使得 m[0] = m1[0] * m2[0] + m1[2] * m2 [2]。 因此，让我们将此作为新定义的提示：

    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)

• 练习：填写此处的问号。 测试一下

  <前><代码> print(R(1).compose(R(2)))
  打印（R（3））

• 数学练习进行测试：证明 R(a).compose(R(b)) 始终与 R(a + b ）。

现在让我说实话：这个compose函数实际上是数学家决定乘矩阵的方法。
作为一种表示法，这是有意义的：A * B 是一个描述运算符 A ○ B 的矩阵，正如我们接下来将看到的，将其称为“乘法”有更深层次的原因’也是如此。

要开始在 Python 中使用乘法，我们所要做的就是在矩阵中对其进行排序
类：

    class Matrix:
    
          ...
    
        __mul__ = compose
        

• 练习：计算(R(pi/2) + R(pi)) * (R(-pi/2) + R(pi))。 首先尝试自己在一张纸上找到答案。

+ 和 * 的规则

让我们为与 dilate(a, b) 运算符对应的矩阵起一个好名字。 现在 D(a, b) 没有任何问题，但我会
借此机会介绍一个标准符号：

def diag(a: 'number', b: 'number') -> 'diagonal 2x2 matrix':
    m = (a, 0, 0, b)
    return Matrix(m)
    

尝试 print(diag(2, 12345)) 看看为什么它被称为对角矩阵。

由于之前发现运算的组合并不总是可交换的，因此 * 运算符对于矩阵也并不总是可交换的。

• 练习：如果有必要，请返回并刷新交换性。 然后给出由 R 和 diag 组成的矩阵 A、B 的示例，
  这样 A * B 不等于 B * A。

这有点奇怪，因为数字的乘法总是可交换的，并提出了 compose 是否真的值得被称为 __mul__ 的问题。 这里有很多 + 和 * do 满足的规则：

1. A + B = B + A
2. A * (B + C) = A * B + A * C
3. (A + B) * C = A * C + B * C
4. (A * B) * C = A * (B * C)
5. 有一种运算称为 A - B 和 (A - B) + B = A

• 练习：证明这些陈述。 如何用+、*、diag来定义A - B？ A - A 等于什么？ 将方法 __sub__ 添加到类 Matrix 中。 如果计算 R(2) - R(1)*R(1) 会发生什么？ 它应该等于什么？

(A * B) * C = A * (B * C) 等式称为关联性，它特别好，因为它意味着我们不必担心在表达式中放入括号
形式为 A * B * C：

print(R(1) * (diag(2,3) * R(2)))
print((R(1) * diag(2,3)) * R(2))

让我们找到常规数字 0 和 1 的类似物以及减法：

zero = diag(0, 0)
one = diag(1, 1)     

通过以下易于验证的加法：

1. < code>A + Zero = A
2. A * Zero = Zero
3. A * one = one * A = A

规则变得完整，即存在它们的简称：环公理。
因此，数学家会说矩阵形成一个环，并且在谈论环时他们确实总是使用符号+和*，我们也应该如此。

使用这些规则，可以轻松计算上一节中的表达式：

(R(pi/2) + R(pi)) * (R(-pi/2) + R(pi)) = R(pi/2) * R(-pi/2) +  ... = one + ...

• 练习：完成此操作。 证明(R(a) + R(b)) * (R(a) - R(b)) = R(2a) - R(2b)。

仿射变换 是

时候回到我们如何定义矩阵了：它们是您可以使用向量执行的某些操作的快捷方式，因此您可以实际绘制它。 您可能需要拿笔或查看其他人建议的材料来查看不同平面变换的示例。

在这些变换中，我们将寻找仿射变换，即那些看起来到处“相同”的变换（没有弯曲）。 例如，围绕某个点 (x, y) 的旋转就符合条件。 现在这个不能表示为 lambda v: A(v) ，但对于某个矩阵 <，它可以写成 lambda v: A(v) + b 的形式代码>A 和向量b。

• 练习：找到A和b，使得围绕点旋转pi/2（ 1, 0) 具有上述形式。 它们是独一无二的吗？

请注意，对于每个向量都有一个仿射变换，它是向量的平移。

仿射变换可以拉伸或膨胀形状，但它在任何地方都应该以相同的方式进行。 现在我希望你相信任何图形的面积在变换下都会改变一个常数。 对于矩阵 A 给出的变换，该系数称为 A 的行列式，可以通过将面积公式应用到两个向量 < code>A(x_axis) 和 A(y_axis)：

    def det(self: 'matrix') -> 'determinant of a matrix':
        return self.m[0]*self.m[3] - self.m[1] * self.m[2]

作为健全性检查，diag(a, b).det() 等于 a * b。

• 练习：检查此项。 当参数之一为 0 时会发生什么？ 什么时候是负数？

正如您所看到的，旋转矩阵的行列式始终相同：

from random import random
r = R(random())
print (r, 'det =', r.det())

关于 det 的一个有趣的事情是它是乘法的（如果您冥想足够长的时间，它可以从定义中得出）：

A = Matrix((1, 2, -3, 0))
B = Matrix((4, 1, 1, 2))
print(A.det(), '*', B.det(), 'should be', (A * B).det())

逆

A 有用 编写两个线性方程组

A.m[0]*v.x + A.m[1]*v.y = b.x
A.m[2]*v.x + A.m[3]*v.y = b.y

您可以使用矩阵做的事情是以更简单的方式 ：A(v) = b。 让我们按照（某些）高中教学的方式求解该系统：将第一个方程乘以 Am[3]，第二个方程乘以 -Am1，并添加（如果有疑问，请在一张纸上执行此操作）以求解 vx。

如果你真的尝试过，你应该得到 A.det() * vx = (Am[3]) * bx + (-Am[1]) * by，这表明你总是可以将 b 乘以其他矩阵即可得到 v。 该矩阵称为 A 的逆：

    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)

如您所见，当矩阵的行列式为零时，此方法会严重失败。 如果您确实想要，可以通过以下方式捕获此异常：

try:
    print(zero.inv())
except ZeroDivisionError as e: ...

• 练习： 完成该方法。 证明当 self.det() == 0 时逆矩阵不存在。 编写矩阵划分方法并进行测试。 使用逆矩阵求解方程 A(v) = x_axis（A 已在上面定义）。

幂

逆矩阵的主要属性是 A * A.inv() 始终等于 one

• 练习：自己检查一下。 从逆矩阵的定义解释为什么会这样。

这就是数学家用 A^-1 表示 A.inv() 的原因。 我们写一个怎么样
使用 A ** n 表示法表示 Aⁿ 是一个不错的函数吗？ 请注意，天真的 for i in range(n): answer *= self 循环是 O(|n|) 这肯定太慢了，因为
这可以通过 log |n| 的复杂度来完成：

    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 cycle. A
        while loop goes over all bits of n, multiplying answer
        by self ** (2 ** k) whenever it encounters a set bit.
        
        ...
        

• 练习： 填写此函数中的详细信息。 测试一下

  X，Y = A ** 5，A ** -5
打印(X, Y, X * Y, sep = '\n')

此函数仅适用于 n 的整数值，即使对于某些矩阵我们也可以定义分数幂，例如平方根（换句话说，矩阵 B 使得 B * B = A）。

• 练习：求diag(-1, -1)的平方根。 这是唯一可能的答案吗？
  找出一个没有有平方根的矩阵的例子。

奖励：复数

这里我将用一节的时间向您介绍这个主题！
由于这是一个复杂的主题，我很可能会失败，所以请提前原谅我。

首先，与矩阵 zero 和 one 类似，我们可以通过执行 diag(number, number) 从任何实数创建矩阵>。 这种形式的矩阵可以相加、相减、相乘、求逆，其结果将模拟数字本身所发生的情况。 因此，出于所有实际目的，我们可以说，例如，diag(5, 5) 是 5。

但是，Python 还不知道如何处理形式为 A + 1 或 5 * B，其中 A 和 B 是矩阵。 如果您有兴趣，您一定应该去做以下练习或查看我的实现（它使用了一个很酷的 Python 功能，称为装饰器）； 否则，只需知道它已实施即可。

• 大师练习：更改Matrix类中的运算符，以便在所有标准运算中，其中一个操作数是矩阵，另一个是数字，该数字会自动转换为diag 矩阵。 另外，添加相等比较。

这是一个示例测试：

print( 3 * A - B / 2 + 5 )

现在这是第一个有趣的复数：矩阵J，在开头引入，等于Matrix((0, 1, -1 , 0))，有一个有趣的属性：J * J == -1（试试吧！）。 这意味着J肯定不是一个普通的数字，但是，正如我刚才所说，矩阵和数字很容易混合在一起。 例如，

(1 + J) * (2 + J) == 2 + 2 * J + 1 * J + J * J = 1 + 3 * J

使用之前列出的规则。 如果我们用 Python 测试这个会发生什么？

(1 + J) * (2 + J) == 1 + 3*J

这应该很高兴地说True。 另一个例子：

(3 + 4*J) / (1 - 2*J) == -1 + 2*J 

正如您可能已经猜到的那样，数学家不会将这些称为“疯狂的数字”，但他们会做类似的事情 - 他们将表达式称为 a + b*J 复数。
因为它们仍然是我们的 Matrix 类的实例，所以我们可以用它们做很多运算：加法、减法、乘法、除法、幂 - 这些都已经实现了！ 矩阵是不是很神奇？

我忽略了如何打印 E = (1 + 2*J) * (1 + 3*J) 等操作的结果的问题，使其看起来像带有 的表达式J 而不是 2x2 矩阵。 如果你仔细观察的话，
您会发现需要以 ... + ...J 格式打印该矩阵的左列（还有一件好事：它正是 E(x_axis)< /code>!) 那些知道 str() 和 repr() 之间差异的人应该会很自然地看到，命名一个会生成如下形式的表达式的函数是很自然的>repr()。

• 练习：编写函数Matrix.__repr__来实现这一点，并尝试用它进行一些测试，例如(1 + J) ** 3< /code>，首先在纸上计算结果，然后用 Python 尝试。

  


• 数学问题：a + b*J 的行列式是什么？ 如果您知道复数的绝对值是什么：它们是如何连接的？ a 的绝对值是多少？ a*J？

3. 矩阵：(R)进化
   =

在这个三部曲的最后一部分，我们将看到一切都是一个矩阵。 我们将从一般的 M x N 矩阵开始，了解如何将向量视为 1 x N 矩阵以及为什么数字与对角矩阵相同。 作为旁注，我们将探索作为 2 x 2 矩阵的复数。

最后，我们将学习使用矩阵编写仿射和射影变换。

因此计划的类是[MNMatrix、NVector、Affine、Projective]。

我想如果你能耐心听我讲到这里，你可能会对这部续集感兴趣，所以我想听听我是否应该继续这个（以及在哪里，因为我非常确定我已经超越了被认为是单个文档的合理长度）。

Answer 2

麻省理工学院有很多在线数学课程材料，网址为 http://ocw.mit.edu/OcwWeb/Mathematics /。 一旦你掌握了基础知识，他们也会在网上提供物理笔记。

Answer 3

这是http://en.wikipedia.org/wiki/Computer_graphics。 其中两个关键概念是 http://mathworld.wolfram.com/LinearTransformation.html 和http://mathworld.wolfram.com/AffineTransformation.html。

Answer 4

这份 MIT 文档是获得有关转型基础知识的必备知识。

http:// stellar.mit.edu/S/course/6/fa08/6.837/courseMaterial/topics/topic2/lectureNotes/03_transform/03_transform.pdf

Answer 5

对于初学者来说最好的书籍之一是 Carl Meyer 的《矩阵分析和应用线性代数》。

您可以在此处在线查看整本书（尽管它有版权水印）：
http://www.matrixanalysis.com/DownloadChapters.html

您可能想看一下在第 5 章。 326 - 332 涵盖了 3 维计算机图形中的旋转

Answer 6

您可能想看看 I-Hsiung Lin、Yixiong Lin 的《几何线性代数》（ISBN：9812560874）。 这本书专门针对您想要的内容（2 维和 3 维向量空间的线性变换），并使用几何方法以完整、渐进的细节对其进行处理（每个维度 300 页）。 恐怕它不是免费购买的，但你应该可以在任何好的大学图书馆找到它。 否则，Bookfinder 应该可以帮助您以相对适中的价格获得它。

Answer 7

Jim Hefferon 的免费《线性代数》教科书非常好。 与太多免费电子书不同，吉姆显然花了时间制作一本优秀的阅读器和线性代数入门书。 它并没有过多地负担正式的数学写作，这些数学写作往往过于密集，难以理解。 它还包含许多线性代数在现实世界中应用的非常优秀的例子——坐标变换只是一个例子。 价格无可比拟，而且它还附带可选的练习解决方案。

PS：如果您喜欢坐标变换，那么在学完线性代数后，您可能会对微分几何感兴趣。

Answer 8

这些是我找到的信息。 其中一些可能对您有价值：

理论：

• Woflrams 有关矩阵的信息 和 维基百科上的其他内容
• Pam Norton 的《矩阵》 - 非常好的书，可在 Google 图书上免费获取。
• 正交和透视投影
• MSDN 上的 3D 转换

（搜索 "矩阵" Google 图书为您提供了大量讲座，其中一些与转换直接相关 - 这是第一个结果，但我鼓励您检查更多

• 内容。）像 这个，或者此或此 在Google的帮助下很容易找到，所以我不会发布更多。
• StackOverflow.com 上也有一些关于矩阵的问题：使用 3d 变换矩阵 和 如何应用变换矩阵？只是前几个示例，您可以找到更多示例矩阵或数学 标签。

我也鼓励（我不知道这个词是否正确，我正在学习英语）你，在其中一本书中寻找此类信息（虽然它们不是免费的，但你可以找到大部分内容） Google 图书上的较早版本）：

1. 游戏编程宝石 7
2. 游戏编程宝石 6
3. 游戏编程宝石 5
4. 游戏编程宝石 4
5. 游戏编程宝石 3
6. 游戏编程宝石 2
7. 游戏编程宝石

其中每一个都有关于数学宝石的部分 - 并且那里有很多巧妙的技巧。 这些书每一分钱都值钱。

还有 GPU 编程精华，所以您也可以尝试一下。

实践：

• 维基百科的 OpenGl Book 有关于 OpenGl 中矩阵的部分
  （此外，此处和此处)
• 在 DirectX 中绘制 3D 房间 + 有关矩阵转换的信息。

如果我能找到更多，我会在这里编辑和添加链接，但说实话 - 我在使用谷歌大约 10 分钟内找到了这些链接。 世界上最受欢迎的浏览器存储有关所有内容的数据 - 是的，“所有内容”也意味着矩阵。

队友的欢呼声。

Answer 9

我认为你应该花几天时间用 3D 向量做点积和叉积。 然后学习三角函数和向量之间的关系。 在那之后，矩阵对你来说会更有意义。

Answer 10

MIT-OCW 的线性代数课程，作者：Gilbert Strang。 一位令人难以置信的人的令人难以置信的讲座； 如果您对矩阵的理解完全来自编程资源（例如 MATLAB），那么线性代数课程肯定会为您提供使用矩阵做疯狂事情的​​基础知识。

http://www.ocw.cn/OcwWeb/数学/18-06Spring-2005/VideoLectures/index.htm