线性代数(1)——向量基础

什么是向量？引入向量的原因

向量是一组数的基本表示方法，是线性代数的基本元素。

研究一组数的基本出发点是因为使用一组数能够更好地表示方向。向量的起始点统一认为是从(0, 0)点，即原点开始。但是向量是一组有序的数字，即便是所有数字相同的向量，顺序不同其表征的方向和含义也是不同的。

如果向量仅仅用于表征方向，最多三个维度就够了，因为物理世界的最高维度就是三维。但是为了扩大数学范围和计算的能力，可以将向量抽象到n维。拓展到更高维度的向量依旧是一组数，但是含义是由使用者定义的。

综上所述，看待向量可以从两个角度出发，

1. 可以将它看成是一个有向线段。
2. 更抽象的可以将其看成是n维空间中的一个点。

更多的向量术语

1. 和向量对应的是一个一个单独的数字，称为标量。
2. 代数是使用符号代表数字。标量和向量都能够使用符号进行区分，二者的区别仅在于向量的符号上面画了个箭头表示“有向”，有时也使用加粗字体表示向量。
3. 个别情况下，需要考虑向量的起始位点，但是这种更多层面用在几何学上，线性代数中起始位点统一认为是原点。
4. 行向量和列向量
   仅仅是向量的一组数的排布方向的位置有区别。

   向量	说明
   行向量	将一组数排列成一行
   列向量	将一组数排布成一列

   通常的教材、论文中提及的向量都指的是列向量。具体的原因见下节笔记。一般的书籍都是横版印刷，所以列向量的表示形式是在行向量的右上角添加一个字母"T"，表示转置。

实现向量类

首先是基本的实现，在之后会不断地完善这个向量类，此处免去了PyCharm中创建项目的过程，可以单独创建一个项目”LinearAlgebra“来管理各种代码。更推荐的是在创建了项目文件夹后点击右键选择”create package“选项，可以在这个项目中创建一个简单的函数库，之后可以在这个库中创建各个文件，假设这个库命名为"playLA"，

LinearAlgebra
    |
    |—— playLA
            |———— __init__.py
            |———— _global.py    # 用于存放一些公共变量，对用户不可见
            |———— Vector.py
    |
    |—— main_vector.py    # 用于测试编写的向量类(注意其位置不在playLA中)

本次向量的实现创建一个名为"Vector.py"的文件，

class Vector:
    def __init__(self, lst):
        """
        :param lst: 传入一个list(可以看做是数组)，用于初始化向量
        """
        self._values = lst.copy()    # 复制一份，因为如果Vector指向的lst对象发生了改变会影响Vector类

    def __repr__(self):
        """
        系统调用该类时如何显示，如在交互界面中
        """
        return "Vector({})".format(self._values)

    def __str__(self):
        """
        用户调用该类时如何显示，如使用print方法
        """
        return "({})".format(", ".join(str(e) for e in self._values))

    def __len__(self):
        """
        返回向量的维度，即向量中包含的元素个数
        """
        return len(self._value)

    def __getitem__(self, index):
        """
        取出向量中某个元素，注意index是索引从0开始
        """
        assert index < len(self) and type(index) == int
        return self._value[index]

相应的在 main_vector.py中可以进行如下测试，

from playLA.Vector import Vector

if __name__ == "__main__":
    vec = Vector([5, 2])
    print(vec)         # 返回 (5, 2)
    print(len(vec))    # 返回 2
    print("vec[0] = {}, vec[1] = {}".format(vec[0], vec[1]))    # 返回 vec[0] = 5, vec[1] = 2

向量基本运算

向量的基本运算包括两种，

• 向量加法
• 向量数乘

向量加法

一个向量和另一个向量之间的运算，

向量加法
(5, 2)^T+ (2, 5)^T= (7, 7)^T

符号表示
(a, b)^T + (c, d)^T = (a+c, b+d)^T
拓展到更高维度也是适用的
(v₁, v₂, …,v_n)^T + (u₁, u₂, …, u_n)^T = (v₁+u₁, v₂+u₂, …, v_n+u_n)^T

向量的加法可以理解为，

• 先从原点开始走到(5, 2)的位置(先向x移动5个单位，再向y移动2个单位)

• 之后再从该位置走相当于(2, 5)这样的位移(向x移动2个单位，再向y移动5个单位)。
  
  最终的结果是向x移动7个单位，再向y移动7个单位。

向量数乘

一个向量和一个标量的乘法运算，

向量数乘
2 × (5， 2)^T = (10, 4)
抽象表示
k × (a, b)^T = (ka, kb)^T
推广到更高维度
k × (v₁, v₂, …, v_n)^T = (kv₁, kv₂, …, kv_n)^T

有了向量加法的基础，数乘的理解很简单，以上面的式子为例，实际上就是2个(5, 2)^T向量相加。

实现向量的基本运算

接上一部分的代码，

    def __iter__(self):
        """
        返回向量的迭代器
        """
        return self._values.__iter__()

    def __add__(self, another):
        """
        向量加法
        :param another: 另一个Vector类对象。该方法返回一个新的Vector对象。
        """
        assert len(self) == len(another), "Error in adding.Length of vectors must be same."
        # Vector类本身是可迭代对象，可以直接传入zip方法
        return Vector([a+b for a, b in zip(self, another)])

    def __sub__(self, another):
        """
        向量减法
        """
        assert len(self) == len(another), "Error in substracting. Length of vectors must be same."
        return Vector([a-b for a, b in zip(self, another)])

    def __mul__(self, k):
        """
        向量乘法，但是这是左乘法即 Vector*k 的运算。如果求取 k*Vector，时会报错
        :param k: 一个实数k
        """
        return Vector([k*e for e in self])
    
    def __rmul__(self, k):
        """
        向量乘法，是对 __mul__ 的补充，防止求取 k*Vector时报错
        """
        return self.__mul__(k)

    def __truediv__(self, k):
        """
        __truediv__方法实现的是真除法(浮点除),而不是整数除法
        :param k: 一个实数
        """
        assert k != 0
        return (1 / k) * self

    def __pos__(self):
        """
        向量取正的结果
        """
        return self.__mul__(1)

    def __neg__(self):
        """
        向量取负的结果
        """
        return self.__mul__(-1)

向量运算基本性质

与加法和乘法的交换律、结合律等相似，加法运算也有一定的规则。向量的运算也遵循交换律、结合律和分配率。

$$\vec{u}+\vec{v}=\vec{v}+\vec{u}$$
$$(\vec{u}+\vec{v})+\vec{w}=\vec{u}+(\vec{v}+\vec{w})$$
$$k(\vec{u}+\vec{v})=k\vec{u}+k\vec{v}$$
$$(k+c)\vec{u}=k\vec{u}+c\vec{u}$$
$$(kc)\vec{u}=k(c\vec{u})$$
$$1\vec{u}=\vec{u}$$

零向量

零向量由来

零向量是一种特殊的向量，对于任意一个向量 $\vec{u}$，都存在一个向量 $O$，满足 $\vec{u}+O=\vec{u}$。具体的可以表示如下，
$$\vec{u}+O=\left(\begin{array}{c}{u}_1\\ u_2\\ ...\\ u_n\end{array}\right)+\left(\begin{array}{c}{o}_1\\ o_2\\ ...\\ o_n\end{array}\right)=\left(\begin{array}{c}{u}_1+o_1\\ u_2+o_2\\ ...\\ u_n+o_n\end{array}\right)=\left(\begin{array}{c}{u}_1\\ u_2\\ ...\\ u_n\end{array}\right)$$
$$\{\begin{array}{l}{u}_1+o_1=u_1\\ u_2+o_2=u_2\\ ...\\ u_n+o_n=u_n\end{array}\underrightarrow{\text{可得}}\{\begin{array}{l}{o}_1=0\\ o_2=0\\ ...\\ o_n=0\end{array}\underrightarrow{\text{即}}O=\left(\begin{array}{c}0\\ 0\\ ...\\ 0\end{array}\right)$$
零向量是一定存在的，需要注意的是零向量O是不需要箭头的，因为零向量可以看做是指向自身的向量，本身是没有方向的。零向量的维度是当前空间决定的。

零向量进一步延伸概念，对于任意一个向量$\vec{u}$，存在一个向量$-\vec{u}$，满足$\vec{u}+-\vec{u}=O$。且$-\vec{u}$向量是唯一的，对于唯一性给出如下证明，使用反证法进行证明，

假设存在另一个向量$\vec{v}$，满足$\vec{u}+\vec{v}=O$
$$(\vec{u}+\vec{v})+-\vec{u}=O+-\vec{u}$$
依据加法交换律，
$$(\vec{u}+-\vec{u})+\vec{v}=-\vec{u}$$
$$O+\vec{v}=-\vec{u}$$
可得，$\vec{v}=-\vec{u}$

零向量实现

接之前代码，

    @classmethod
    def zero(cls, dim):
        """
        返回一个dim维的零向量
        """
        assert dim > 0
        return Vector([0] * dim)

因为zero是类方法，所以在main_vector.py中调用与一般的实例方法有所不同，

zero2 = Vector.zero(2)
print(zero2)    # 返回 (0, 0)