线性代数(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}$u+v=v+u
$(\vec{u}+\vec{v})+\vec{w} = \vec{u} + (\vec{v}+\vec{w})$(u+v)+w=u+(v+w)
$k(\vec{u}+\vec{v}) =k \vec{u} + k\vec{v}$k(u+v)=ku+kv
$(k+c)\vec{u} =k \vec{u} + c\vec{u}$(k+c)u=ku+cu
$(kc)\vec{u} =k (c\vec{u})$(kc)u=k(cu)
$1\vec{u} =\vec{u}$1u=u

零向量

零向量由来

零向量是一种特殊的向量，对于任意一个向量 $\vec{u}$u，都存在一个向量 $O$O，满足 $\vec{u} +O= \vec{u}$u+O=u。具体的可以表示如下，
$\vec{u} +O= \begin{pmatrix}u_1\\u_2\\...\\u_n\end{pmatrix} + \begin{pmatrix}o_1\\o_2\\...\\o_n\end{pmatrix} = \begin{pmatrix}u_1+o_1\\u_2+o_2\\...\\u_n+o_n\end{pmatrix} = \begin{pmatrix}u_1\\u_2\\...\\u_n\end{pmatrix}$u+O=⎝⎜⎜⎛​u1​u2​...un​​⎠⎟⎟⎞​+⎝⎜⎜⎛​o1​o2​...on​​⎠⎟⎟⎞​=⎝⎜⎜⎛​u1​+o1​u2​+o2​...un​+on​​⎠⎟⎟⎞​=⎝⎜⎜⎛​u1​u2​...un​​⎠⎟⎟⎞​
$\begin{cases} u_1+o_1=u_1\\ u_2+o_2=u_2\\ ...\\ u_n+o_n=u_n \end{cases} \underrightarrow{\text{可得}}\begin{cases} o_1=0\\ o_2=0\\ ...\\ o_n=0 \end{cases} \underrightarrow{\text{即}}O=\begin{pmatrix} 0\\0\\...\\0 \end{pmatrix}$⎩⎪⎪⎪⎨⎪⎪⎪⎧​u1​+o1​=u1​u2​+o2​=u2​...un​+on​=un​​可得​⎩⎪⎪⎪⎨⎪⎪⎪⎧​o1​=0o2​=0...on​=0​即​O=⎝⎜⎜⎛​00...0​⎠⎟⎟⎞​
零向量是一定存在的，需要注意的是零向量O是不需要箭头的，因为零向量可以看做是指向自身的向量，本身是没有方向的。零向量的维度是当前空间决定的。

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

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