精神小伙

Math in anywhere | Rasterization

Sat, 19 Jun 2021 23:18:00 +0800

# Rasterization

光栅化 就是将获得的图像在显示器件上成像的过程，Raster 在德语里是屏幕的意思，所以光栅化也就是在屏幕成像绘制的意思。所以我们需要了解一些屏幕成像的概念，原理和方法。

# Basic Concept

Pixel (short for “picture element”) 像素

一个有着统一颜色的平方单位
这个颜色由三种颜色混合而来（RGB）

Resolution 分辨率：表示像素的规模

Screen Space：屏幕空间用于准确描述屏幕具体像素的工具

像素的描述点 $(x,y)$ ，其中 x 和 y 均为整数
像素点的范围从 $(0,0) \to (width -1,height-1)$
像素点的中心在 $(x + 0.5,y+0.5)$
屏幕的覆盖范围 $(0,0) \to (width,height)$

三角形网络：以三角形为基础元素构成的多变形 Triangle Meshes

三角形作为简单的多边形由以下的优点：

能够保证是平面，一个三角形就是一个平面
有明确的内部定义
有明确的方法对顶点和重心进行插值

# Sampling

我们获得目标图像后，需要通过采样的方式来获得最终那些像素需要变成什么颜色，在三角形中我们判断像素的重点是否在三角形的内部，如果是就是需要设置的点，如果不是就不需要。

根据这个我们就能写出一个基本的函数关系：

$inside(t,x,y) = \left\{ \begin{array}{c} 1 \space in \\ 0 \space out \end{array} \right.$

Note：这个信号领域的冲激函数非常像

有了基本的模型我们就能写出伪代码：

for (int x = 0; x < xmax; ++x)
    for (int y = 0; y < ymax; ++y)
        image[x][y] = inside(tri,x + 0.5,y + 0.5);

在 inside() 这个函数中，我们需要传入一个目标三角形，还有需要确认的像素点的坐标，判断点是否在三角形内。这里的判断就用到了之前提到的向量叉乘，

同时为了简化判断范围，我们只需考虑三角形顶点的 $x_{min} \to x_{max}$ 的范围和y_{min} \to y_

通过采样出来的图像显示出来为：

很显然，出来的效果和原图像有一定的差异，存在明显的锯齿（Jaggies）

# Antialiasing

因为现在图像均是通过采样后在输出来实现对图像的模拟，所有会存在不同程度的问题，我们称之为 Artifacts（瑕疵），而 Artifacts 的出现主要是因为采样出现了 Aliasing “混叠”，混叠包括空间上和时间上的，两种情况都会导致图像出现异常，而解决的方法就是了解 Aliasing 出现的原因。

采样在空间上出现采样率过低体现为：锯齿
采样的空间频率没有远低于图像的空间频率：摩尔纹
采样在时间上出现采样率过低体现为：车轮效应

# Background Knowledge

在信号学领域，有两个非常重要的概念一个叫时域，一个叫频域。时域是以时间为自变量的描述，频域是以频率为自变量的描述。

这里要引入傅里叶变换，三角函数来组合复杂的周期函数，这些都基于三角函数的基本变化规律，如下图。

$f(t) = A_0 + \sum_{n=1}^\infty A_n \sin(nwt + \varphi_n)$

有了这些基本的概念后，我们再把这些知识和图像采样联系起来，我们的在做图像采样的时候，就好像对一个函数进行离散取值，然后通过值去还原这个函数。

如果我采样的频率不够高，就会出现采样的点还原出来的函数有问题，图像有问题，如下图所示。

在采样率一样的情况下，高频信号的波形完全丢失，用低频信号的频率采集的值最终和低频的信息加起来的结果就是错误的。为了保证采样的正确性，我们需要遵守奈奎斯特–香农采样定理：为了不失真地恢复模拟信号，采样频率应该不小于模拟信号频谱中最高频率的 2 倍。

# Filter

了解基本的知识背景后，我们来看图像的信息。一张图像是由一个像素矩阵构成的，现在我们把像素矩阵进行调整，只保留一行，其他行接到第一行的后面。这样我们就能把像素矩阵变成一个数组的结构，而数组的每一个值就是对应像素在图像上的值（RGB），这样我们就能把这个图像变成一个函数，既然是一个函数，我们就能够通过傅里叶级数把他转换成各种基本的周期函数的加和。同样的我们就能够对转换后的这个函数进行变换，使得时域的函数转化为频域的函数，如下图就是转化后的

当我们把中低频信号过滤掉：就会发现（高频信号主要描述细节）

当我们把中高频信号过滤掉：就会发现（低频信号主要描述整体）

滤波在数学上我们可以用 “卷积” 实现，也是滑动均值，我们这里演示低通滤波的数学表达

这里有两种方法：

方法一

在时域中通过卷积滤波

Note：时域的卷积等于频域的乘法，频域的卷积等于时域的乘法

方法二

变换到频域（傅立叶变换）
乘以卷积核的傅立叶变换
转换回空间域（逆傅立叶）

滤波本质其实时截断，将出现混叠的部分直接抛起

然后通过像素被图像覆盖的区域然后调整像素的值：

# MSAA

Antialiasing By Supersampling，在分辨率不够的情况下，我们假设一个像素由更多的子像素构成

然后通过计算子像素的覆盖情况来调整一个像素值

Math in anywhere | View

Tue, 15 Jun 2021 23:08:00 +0800

# Viewing transformation

视图变换包括了我们的模型变换，取景变换，投影变换，这是整个由 3 维转向 2 维的重要一步。我们可以类比我们日常生活中的拍摄的过程，首先我们需要找一个我们需要拍摄的对象，这部分叫做 model transformation （译：模型变换），这里完成的是将需要的模型构建出来，然后我们需要给相机找一个好的位置，好的角度，好的姿态，这部分叫做 view transformation（译：取景变换），这里完成的是取景器的设置工作，我们需要明确取景的位置，角度，姿态。最后我们需要按下我们的快门。这部分叫做 projection transformation（译：投影变换），这里完成将图像进行映射。这个过程简称为 MVP，因为模型变换部分需要建模部分，我们这里不讨论，只讨论图像部分的取景变换和投影变换。

# View transformation

# Basic Definition

View/Camera Transformation 取景变换，这里需要完成对取景点的设置，这是非常重要的一部，取景点的信息直接决定了投影变换的各种信息，也决定了最后成像的效果。决定取景点主要有以下几个信息：

Position： $\vec{e}$ .
Look-at / Gaze direction： $\hat{g}$ .
Up direction： $\hat{t}$ .

现在我们考虑一个情景，相机和目标能够通过移动特殊的数值使得获取的信息和移动前一样。这就出现了一种麻烦的情况，我们需要进行两次计算，才能获取到一样的信息。所以为了简化相机与目标的相对关系，我们规定了相机的位置，我们称之为 Key observation，即相机的位置是在原地位置，以 -Z 为观察方向，Y 轴为水平偏差标准。这样所有的变换就成了目标的移动。

有了这个规定以后，我们就能够将任意一个取景点进行变换，变到 Key observation，只需要：

Rotates $\hat{g}$ to -Z
Rotates $\hat{t}$ to Y
Rotates $(\hat{g} \times \hat{t})$ To X

# Math Conversion

在数学上，按照之前在目标转化分解一节中的描述，我们现进行平移变换使得位置到达原点，此时线性变换就能以原点为轴。

$M_{view }= R_{view} T_{view}$

平移变换 $T_{view}$ 的部分

$T_{view} = \left[ \begin{matrix} 1 & 0 & 0 &-x_e \\ 0 & 1 & 0 &-y_e \\ 0 & 0 & 1 &-z_e \\ 0 & 0 & 0 &1 \\ \end{matrix}\right]$

线性变换 $R_{view} $ 不好写，因为本身从特殊点进行的变换，但是我们可以通过到达目标位置进行逆变换来获取，然后利用其性质，其逆矩阵就是其转置矩阵：

$R_{view}^{-1} = \left[ \begin{matrix} x_{\hat{g} \times \hat{t}} & x_t & x_{-g} & 0\\ y_{\hat{g} \times \hat{t}} & y_t & y_{-g} & 0\\ z_{\hat{g} \times \hat{t}} & z_t & z_{-g} & 0\\ 0 & 0 & 0 &1 \\ \end{matrix}\right]$

$R_{view} = \left[ \begin{matrix} x_{\hat{g} \times \hat{t}} & y_{\hat{g} \times \hat{t}} &y_{\hat{g} \times \hat{t}} & 0\\ x_t & y_t & z_t & 0 \\ x_{-g} & y_{-g} & z_{-g} &0\\ 0 & 0 & 0 &1 \\ \end{matrix}\right]$

# Projection Transformation

# Basic Definition

投影变换是取景的最后一步，根据不同的场景设定有两种不同的投影类型，分别是：

Perspective projection：透视投影
Orthographic projection：正交投影

这两者最大的区别就是是否有近大远小的性质。

# Orthographic Projection

正交投影作为最简单的投影方式，实际上假设取景点在无穷远的地方，这样就能让成像的画面和实际取景的每一个点都构成平行线。也正因取景点在无穷远的地方，使得目标物体间的具体可以忽略不记，这样物体的深度信息就丢失了，也就是 Z 的信息。

对于一个已知的物体，我们需要 6 个信息来进行正交变换，分别是：

左右信息：l r
深度信息：n f
高度信息：t b

同理（目标转化分解），我们先进行平移变换，使各个维度的中点的投影在原点上，然后再进行线性变换：

$M_{ortho} = \left[ \begin{matrix} \frac{2}{r-l} & 0 & 0 & 0 \\ 0 & \frac{2}{t - b} & 0 & 0 \\ 0 & 0 & \frac{2}{n - f} & 0 \\ 0 & 0 & 0 &1 \\ \end{matrix}\right] \left[ \begin{matrix} 1 & 0 & 0 & -\frac{r+l}{2} \\ 0 & 1 & 0 & -\frac{t+b}{2} \\ 0 & 0 & 1 & -\frac{n+f}{2} \\ 0 & 0 & 0 &1 \\ \end{matrix}\right]$

Note: n > f

# Perspective Projection

透视投影是非常常见的投影方式，在 CG，艺术等领域都有广泛的应用，因为能够提供深度的信息，同时也符合人眼的成像习惯，因而能够给人带来真实感。透视投影的实质在特定的取景点下，成像画面会将取景画面进行 “挤压”，每个点到点之间构成的线不再能够平行。

如果我们想要获取一个物体的透视投影，我们可以通过两步来实现：

第一步：将物体图像挤压到和成像大小一样
第二部：将挤压后的物体图像进行正交投影

遵守几个规定：

近平面的点永远不变
远平面的点挤压后 Z 不会改变
远平面的中心点在挤压中不会改变

有了这些基本的规定后，我们试着来推导一下整个过程。

首先看 “挤压” 的过程，我们以其中一个切面的角度看：

因此我们能够获得：

$y^{\prime} = \frac{n}{z} y \\ x^{\prime} = \frac{n}{z} x$

我们就能转换成

$M_{presp \to ortho } \left( \begin{matrix} x \\ y \\ z \\ 1 \end{matrix}\right) = \left( \begin{matrix} nx \\ ny \\ unknown \\ z \end{matrix}\right)$

根据结果我们可以推算出

$M_{presp \to ortho } = \left( \begin{matrix} n & 0 & 0 & 0 \\ 0 & n & 0 & 0 \\ ? & ? & ? & ? \\ 0 & 0 & 1 & 0 \end{matrix}\right)$

接着我们根据规定近平面的点永远不变和远平面的点挤压后 Z 不会改变：

近平面的点永远不变

因此我们能够得出：

$\left( \begin{matrix} 0 & 0 & A & B \end{matrix}\right) \left( \begin{matrix} x \\ y \\ n \\ 1 \end{matrix}\right) = An + B = n^2$

远平面的点挤压后 Z 不会改变

因此我们能够得出：

$\left( \begin{matrix} 0 & 0 & A & B \end{matrix}\right) \left( \begin{matrix} 0 \\ 0 \\ f \\ 1 \end{matrix}\right) = Af + B = f^2$

我们就获得一个方程组：

$\left\{ \begin{array}{c} An + B = n^2\\ Af + B = f^2 \end{array} \right.$

解的得：

$\left\{ \begin{array}{c} A = n + f\\ B = -nf \end{array} \right.$

因此 “挤压” 的转化矩阵为：

$M_{presp \to ortho } = \left( \begin{matrix} n & 0 & 0 & 0 \\ 0 & n & 0 & 0 \\ 0 & 0 & n + f & -nf \\ 0 & 0 & 1 & 0 \end{matrix}\right)$

# Application

了解了两种核心的投影方式和相应的计算后，我们还需要知道一些常用的数据转化

$fov Y$ ：vertical field-of-view 指的是相机的广角角度
$aspect \space ratio = \frac{width}{height}$ ：显示的长宽比

通过这两个常用的数据转为我们需要的数据（r, l, b, t）

这里我们一般假设： l = -r, b= -t

这里我们可以获得

$angle : \frac{fovY}{2} \\ \tan{\frac{fovY}{2}}= \frac{t}{|n|} \\ aspect = \frac{r}{t}$

当我们在做透视投影或者正交投影时，都会最后转为规范立方矩阵，然后我们先需要通过 Viewport Transform 矩阵将图像转为显示器尺寸的矩阵：

$M_{presp \to ortho } = \left( \begin{matrix} \frac{width}{2} & 0 & 0 & \frac{width}{2} \\ 0 & \frac{height}{2} & 0 & \frac{height}{2} \\ 0 & 0 & 1 & 0 \\ 0 & 0 & 0 & 1 \end{matrix}\right)$

# Case One

问题：求出已知图像绕一个经过原点的任意轴旋转 $\theta$ 的转化矩阵

分析：之前我们已经分析过绕 X，Y，Z 轴旋转的旋转矩阵了，现在我们需要的是任意过原点的旋转轴。我们可以通过把未知的旋转方式转为已知的进行旋转（Z，X，Y）, 然后旋转完，再逆变换回去。

如图所示，假设我们需要绕向量 V 为轴进行旋转 $\theta$ 角度，那么首先我们可以将向量进行旋转，使得 V 与已知的（X，Y，Z）其中一个重合，我这里演示的是与 Z 轴重合：分为两步法

将向量绕 X 轴旋转到 ZOX 平面获得V_
然后将 $V_{ZOX}$ 绕 Y 轴旋转到和 Z 轴重合

第一步：将向量绕 X 轴旋转到 ZOX 平面获得V_

绕 X 轴旋转的角度 $α$ 等于向量 V 在 ZOY 平面上的投影向量 $V_{ZOY}$ 与 Z 轴正向的夹角。其实就是 $V_{ZOY}$ 和 V 组成的面上的所有经过原点的向量要想通过 X 轴旋转到 ZOX 都是转的角度 $α$ ，由投影可知

$V_{ZOY} (0,b,c)$

则夹角就可以通过简单的三角函数获得：

$\sin{\alpha} = \frac{b}{\sqrt{b^2+c^2}}, \space \cos{\alpha} = 1 - \sin^2{\alpha}$

获得到角度后，我们就能够列出绕 X 轴旋转的矩阵：

$V_x(\alpha) = \left( \begin{matrix} 1 & 0 & 0 & 0 \\ 0 & \cos \alpha & -\sin \alpha & 0 \\ 0 & \sin \alpha & \cos \alpha & 0 \\ 0 & 0 & 0 & 1 \end{matrix}\right)$

第二步：然后将 $V_{ZOX}$ 绕 Y 轴旋转到和 Z 轴重合

绕 Y 轴旋转的角度 $\beta$ 等于向量 $V_{ZOX}$ 与 Z 轴正向的夹角，这里我们可以知道 $V_{ZOX}$ 是由 V 绕 X 轴旋转而来，所以 X 轴的分量保持不变，Y 轴分量为 0，因为模长不变，所以可知

$V_{ZOX} (a,0,\sqrt{b^2+c^2})$

同理，夹角就可以通过简单的三角函数获得：

$\sin{\beta} = \frac{a}{\sqrt{a^2+b^2+c^2}}, \space \cos{\alpha} = 1 - \sin^2{\alpha}$

获得到角度后，我们就能够列出绕 Y 轴旋转的矩阵：

$V_y(\beta) = \left( \begin{matrix} \cos \beta & 0 & \sin \beta & 0 \\ 0 & 1 & 0 & 0 \\ -\sin \beta & 0 & \cos \beta & 0 \\ 0 & 0 & 0 & 1 \end{matrix}\right)$

完成这两步后我们就能对目标进行绕 Z 轴 $\theta$ 角度的旋转：

$V_z(\theta) = \left( \begin{matrix} \cos \theta & -\sin \theta & 0 & 0 \\ \sin \theta & \cos \theta & 0 & 0 \\ 0 & 0 & 1 & 0 \\ 0 & 0 & 0 & 1 \end{matrix}\right)$

最后，将物体旋转回之前的位置。具体做法是乘以之前矩阵的逆矩阵。至此，我们得到物体旋转所需要的最终矩阵：

$V(\theta) = V_x(-\alpha)V_y(-\beta)V_z(\theta)V_y(\beta)V_x(\alpha)$

而我们知道旋转矩阵的逆矩阵等于其转置矩阵，于是我们可以得到：

$V(\theta) = V^T_x(\alpha)V^T_y(\beta)V_z(\theta)V_y(\beta)V_x(\alpha)$

# Case Two

问题：求出已知图像绕任意一个轴旋转 $\theta$ 的转化矩阵

分析：之前我们已经分析过绕过原点的任意轴旋转的旋转矩阵了，现在我们需要的是绕任意轴旋转。我们可以通过把未知的轴起点平移到原点，这样就能转为过原点的任意轴旋转的问题，然后旋转后，再把轴平移回去即可。

如图所示，假设我们需要绕向量 $\vec{SP}$ 为轴进行旋转 $\theta$ 角度，那么首先我们可以将向量进行平移，使得向量变成以原点为初始点的向量，这样就能用 Case One 的方法解答分：

将向量 $\vec{SP}$ 平移使得起点在原点
解答绕过原点任意轴的问题

第一步：将向量 $\vec{SP}$ 平移使得起点在原点

$T(x,y,z) = \left( \begin{matrix} 1 & 0 & 0 & a_1-a \\ 0 & 1 & 0 & b_1-b \\ 0 & 0 & 1 & c_1-c \\ 0 & 0 & 0 & 1 \end{matrix}\right)$

第二步：使用 Case One 的方法

$V(\theta) = V^T_x(\alpha)V^T_y(\beta)V_z(\theta)V_y(\beta)V_x(\alpha)$

最后，将物体平移回之前的位置。具体做法是乘以之前矩阵的反方向。至此，我们得到物体旋转所需要的最终矩阵：

$V(\theta) = T(-x,-y,-z)V^T_x(\alpha)V^T_y(\beta)V_z(\theta)V_y(\beta)V_x(\alpha)T(x,y,z)$

Math in anywhere | Vector

Mon, 14 Jun 2021 23:08:00 +0800

# Math in anywhere | Vector

# Vector

向量指一个同时具有大小和方向，且满足平行四边形法则的几何对象。我们用数据结构的视角来看，向量可以用数组或者链表来表达。常记为 $\vec{a}$ 或者 $\bold{a}$ ，或者 $\vec{AB} = B - A$

$x= \left[ \begin{matrix} a_{0} \\ a_{1} \\ \vdots \\ a_{n} \end{matrix}\right]$

这里 $a_0,a_1,\cdots,a_n$ 表示向量中的每个元素，其中有 n 个数就代表向量的维。一个向量的长度我们记为 (1 范数)：

$||\vec{a}||$

而关于 维 这个概念，我可以把他理解为某个尺度 / 属性上的值。

一般来说特征有很多维，因此我们可以使用向量来表示某个物体的特征。其中，向量的每个元素就代表一维特征，而元素的值代表了相应特征的值，我们称这类向量为特征向量（Feature Vector）

矩阵的几何意义是坐标的变换。如果一个矩阵存在特征向量和特征值，那么这个矩阵的特征向量就表示了它在空间中最主要的运动方向。注意区分这两个概念

# Basic Operation

# Normalized

标准化操作能够让我们获得一个特定方向的单位向量，而这个单位向量我们就用来代表这个特定方向，我们通常记为：

$\hat{a} = \frac{\vec{a}}{||\vec{a}||}$

# Addition

代数加法：首先需要满足维度相同，然后对应元素相加

$\vec{a} + \vec{b} = \left[ \begin{matrix} a_{0} \\ a_{1} \\ \vdots \\ a_{n} \end{matrix}\right] + \left[ \begin{matrix} b_{0} \\ b_{1} \\ \vdots \\ b_{n} \end{matrix}\right] = \left[ \begin{matrix} {a_{0}+b_{0}} \\ {a_{1}+b_{1}} \\ \vdots \\ {a_{n}+b_{n}} \end{matrix}\right]$

几何相加：

平行四边形法则：两个向量从起点相同，构成的平行四边形的对角线（夹在两个向量之间）
三角形法则：一个向量的起点为一个向量的终点，构成三角形的第三条边。

# Multiply

向量的乘法有两种类型：

点乘（标量积）也就是结果是一个数（标量）
叉乘（向量积）也就是结果是一个向量（向量）

点乘：

$\vec{a} \cdot \vec{b} = ||\vec{a}|| \space ||\vec{b}|| \cos \theta \\ if(unit\space vector) \{\cos \theta = \hat{a} \cdot \hat{b}\}$

$\cos \theta = \frac{\vec{a} \cdot \vec{b}}{||\vec{a}|| ||\vec{b}||}$

作为标量积满足基本的运算：
${\vec{a}\cdot\vec{b}=\vec{b}\cdot\vec{a} }$

${\vec{a}\cdot(\vec{b}+\vec{c})=\vec{a}\cdot\vec{c}+\vec{b}\cdot\vec{a} }$

$(k\vec{a}) \cdot \vec{b} = \vec{a} \cdot k\vec{b} = k(\vec{a} \cdot \vec{b})$

几何计算：

$\vec{a} \cdot \vec{b} = \left[ \begin{matrix} a_{0} \\ a_{1} \\ \vdots \\ a_{n} \end{matrix}\right] \cdot \left[ \begin{matrix} b_{0} \\ b_{1} \\ \vdots \\ b_{n} \end{matrix}\right] = {a_{0}b_{0}} + {a_{1}b_{1}} + \cdots + {a_{n}b_{n}}$

投影计算：

$\vec{b}_{\bot} = k \hat{a} \\ k = ||\vec{b}_{\bot}|| = ||\vec{b}|| \cos \theta$

叉乘：

对于线性无关的两个向量 $\mathbf {a}$ 和 $\mathbf {b}$ ，它们的外积写作 $\mathbf {a} \times \mathbf {b}$ ，是 $\mathbf {a}$ 和 $\mathbf {b}$ 所在平面的法线向量，与 $\mathbf {a}$ 和 $\mathbf {b}$ 都垂直，外积作为一个向量，其方向取决于右手定则

右手定则：
四指指向第一个向量的方向，四指往第二个向量方向握拳，此时大拇指的指向就是。这也意味着叉乘不支持乘法的交换律，因为和初始向量的位置有关。

如上图演示了用法：

$\vec{A} \times \vec{B} = \vec{C}$

外积的定义为：

$\mathbf {a} \times \mathbf {b} =\|\mathbf {a} \|\|\mathbf {b} \|\sin(\theta )\ \mathbf {n}$

其中 $\theta$ 表示 $\mathbf {a}$ 和 $\mathbf {b}$ 在它们所定义的平面上的夹角 $0^{\circ }\leq \theta \leq 180^{\circ }$ 。 $\|\mathbf {a} \|$ 和 $\|\mathbf {b} \|$ 是向量 $\mathbf {a}$ 和 $\mathbf {b}$ 的模长，而 $\mathbf{n}$ 则是一个与 $\mathbf {a} 、\mathbf {b}$ 所构成的平面垂直的单位向量，方向由右手定则决定。根据上述公式，当 $\mathbf {a}$ 与 $\mathbf {b}$ 平行（即 { $\theta$ 为 0° 或 180°）时，它们的外积为零向量 $\mathbf{0}$ 。

几何计算：

$\mathbf {u\times v} ={\begin{vmatrix}\mathbf {i} &\mathbf {j} &\mathbf {k} \\u_{1}&u_{2}&u_{3}\\v_{1}&v_{2}&v_{3}\\\end{vmatrix}}$

然后需要计算哪一个维度，就将该维度所在的行，所在的列去掉，剩下部分构成的行列式的结果即为系数。

${\begin{aligned}\mathbf {u\times v} &={\begin{vmatrix}u_{2}&u_{3}\\v_{2}&v_{3}\end{vmatrix}}\mathbf {i} -{\begin{vmatrix}u_{1}&u_{3}\\v_{1}&v_{3}\end{vmatrix}}\mathbf {j} +{\begin{vmatrix}u_{1}&u_{2}\\v_{1}&v_{2}\end{vmatrix}}\mathbf {k} \\&=(u_{2}v_{3}-u_{3}v_{2})\mathbf {i} -(u_{1}v_{3}-u_{3}v_{1})\mathbf {j} +(u_{1}v_{2}-u_{2}v_{1})\mathbf {k} \\ \end{aligned}}$

几何意义：

如果以向量 $\mathbf {a}$ 和 $\mathbf {b}$ 为边构成一个平行四边形，那么这两个向量外积的模长与这个平行四边形的正面积相等：

$\left\|\mathbf {a} \times \mathbf {b} \right\|=\left\|\mathbf {a} \right\|\left\|\mathbf {b} \right\|\sin \theta .$

# Vector Space

对一般域 F，V 记为 F - 向量空间。若 F 是实数域ℝ，则 V 称为实数向量空间；

若 F 是复数域ℂ，则 V 称为复数向量空间；

若 F 是有限域，则 V 称为有限域向量空间

公理	说明
向量加法的结合律	u + (v + w) = (u + v) + w
向量加法的交换律	u + v = v + u
向量加法的单位元	存在一个叫做零向量的元素 0 ∈ V，使得对任意 u ∈ V 都满足 u + 0 = u
向量加法的逆元素	对任意 v ∈ V 都存在其逆元素−v ∈ V 使得 v + (−v) = 0
标量乘法与标量的域乘法相容	a(bv) = (ab)v
标量乘法的单位元	域 F 存在乘法单位元 1 满足 1v = v
标量乘法对向量加法的分配律	a(u + v) = au + av
标量乘法对域加法的分配律	(a + b)v = av + bv

如果 $V$ 满足上述的公理，我们就称 $V$ 是 $F$ 上的向量空间。

# Vector Distance

Manhattan Distance

曼哈顿距离，这个距离度量的名字来自美国曼哈顿地区，从一个十字路口开车到另外一个十字路口，驾驶距离是多少呢？当然不是两点之间的直线距离，因为你无法穿越挡在其中的高楼大厦。你只能驾车绕过这些建筑物，实际的驾驶距离就叫作曼哈顿距离。

我们在二维空间中：假设两个点 $x(x_1,x_2)$ 与 $y(y_1,y_2)$

$MD(x,y) = |x_1 - y_1| + |x_2 - y_2|$

推广到 n 维空间，曼哈顿距离：

$MD(x,y) = \sum_{i=1}^n |x_i - y_i|$

从图里也能发现曼哈顿距离的特点：曼哈顿距离和路径无关，但是有多条路线。

Euclidean Distance

欧氏距离，其实就是欧几里得距离。欧氏距离是一个常用的距离定义，指在 n 维空间中两
个点之间的真实距离。

我们在二维空间中：假设两个点 $d(p_1,p_1)$ 与 $q(q_1,q_2)$

$ED(x,y) = \sqrt{(q_1 - p_1)^2 + (q_2 - p_2)^2}$

推广到 n 维空间，欧式距离：

$ED(x,y) = \sqrt{\sum_{i=1}^n(p_i - q_i)^2}$

从图里也能发现欧式距离的特点：也就是直线距离，只有一种路线。

Chebyshev Distance

切比雪夫其实是在模拟国际象棋里国王的走法。国王可以走临近 8 个格子里的任何一个，那么国王从格子 $(x_1,x_2)$ 走到格子 $(y_1,y_2)$ 最少需要多少步呢？其实就是二维空间里的切比雪夫距离。一开始，为了走尽量少的步数，国王走的一定是斜线，所以横轴和纵轴方向都会减 1，直到国王的位置和目标位置在某个轴上没有差距，这个时候就改为沿另一个轴每次减 1。

我们在二维空间中：假设两个点 $x(x_1,x_2)$ 与 $y(y_1,y_2)$

$CD(x,y) = max(|x_1 - y_1|,| x_2 - y_2|)$

推广到 n 维空间，切比雪夫距离：

$CD(x,y) = \arg_{i =1}^n max|x_i - y_i|$

arg max ：就是使后面这个式子达到最大值时的变量的取值

上述三种距离，都可以用一种通用的形式表示，那就是闵可夫斯基距离，也叫闵氏距离。

在二维空间中，两个点 $x(x_1,x_2)$ 与 $y(y_1,y_2)$ 间的闵氏距离：

$MKD(x,y) = \sqrt[p]{|x_1 - y_1|^p + |x_2 - y_2|^p}$

推广到 n 维空间，闵氏距离：

$MKD(x,y) = \sqrt[p]{\sum_{i=1}^n|x_i - y_i|^p }$

其中 $p$ 是一个变参数，不同的 p 取值就能转化不同的距离：

$p = 1$ ，曼哈顿距离
$p = 2$ ，欧氏距离
$p = \infty$ ，切比雪夫距离

当 $p$ 趋近于无穷大的时候，就是切比雪夫距离。这是因为 $p$ 当趋近于无穷大的时候，最大的 $|x_i -y_i|$ ，会占到全部权重。

# Vector length

向量的长度，也叫向量的模，是向量所对应的点到空间原点的距离。通常我们使用欧氏距离来表示向量的长度。范数常常被用来衡量某个向量空间中向量的大小或者长度

$L_1$ 范数 $||x||$ ，它是 $x$ 向量各个元素绝对值之和，对应于向量和原点之间的曼哈顿距离
$L_2$ 范数 $||x||_2$ ，它是 $x$ 向量各个元素平方和的 $\frac{1}{2}$ 次方，对应于向量和原点之间的欧式距离
$L_p$ 范数 $||x||_p$ ，它是 $x$ 向量各个元素绝对值 $p$ 次方和的 $\frac{1}{p}$ 次方，对应于向量和原点之间的闵式距离
$L_{\infty}$ 范数 $||x||_{\infty}$ ，它是 $x$ 向量各个元素绝对值最大那个元素的绝对值，对应于向量和原点之间的切比雪夫距离

# Vector angle

向量夹角的余弦，它计算了空间中两个向量所形成夹角的余弦值：

$Cosine(X,Y)= \frac{\sum_{i=1}^n(x_i \times y_i)}{\sqrt{\sum_{i=1}^nx_i^2 \times \sum_{i=1}^n y_i^2}}$

分子是两个向量的点乘，而分母是两者长度（或 L2 范数）的乘积，而 L2 范数可以使用向量点乘自身的转置来实现。夹角余弦的取值范围在 [-1,1]，

当两个向量的方向重合时夹角余弦取最大值 1，
当两个向量的方向完全相反夹角余弦取最小值 -1
值越大，说明夹角越小，两点相距就越近
值越小，说明夹角越大，两点相距就越远

# Application

在 CG 领域，向量点乘的应用：

测量两个向量的夹角（两个方向的距离）
向量分解
确定向量的朝向（向前 / 向后）

在 CG 领域，向量叉乘的应用：

确定向量的位置（左还是右）
确定向量的位置（里还是外

# Matrix

# Basic Transform

是指矩阵内的元素行索引和纵索引互换，例如 $x_{ij}$ 变为 $x_{ji}$ ，相应的，矩阵的形状由转置前的 n × m 变为转置后的 m × n。从几何的角度来说，矩阵的转置就是原矩阵以对角线为轴进行翻转后的结果。下面这张图展示了矩阵转置之后的矩阵

在线性代数中，n 阶单位矩阵，是一个 $n\times n$ 的方形矩阵，其主对角线元素为 1，其余元素为 0。单位矩阵以 $I_n$ 表示：

$I_{1}={\begin{bmatrix}1\end{bmatrix}},\ I_{2}={\begin{bmatrix}1&0\\0&1\end{bmatrix}},\ I_{3}={\begin{bmatrix}1&0&0\\0&1&0\\0&0&1\end{bmatrix}},\ \cdots ,\ I_{n}={\begin{bmatrix}1&0&\cdots &0\\0&1&\cdots &0\\\vdots &\vdots &\ddots &\vdots \\0&0&\cdots &1\end{bmatrix}}$

逆矩阵：就是和原矩阵相乘结果是单位矩阵

$X^{-1}X = I_n$

逆矩阵的一些基本性质：

$\left (A^{-1} \right )^{-1}=A \\ (\lambda A)^{-1}=\frac{1}{\lambda}\times A^{-1} \\ (AB)^{-1}=B^{-1}A^{-1} \\ {\displaystyle \left(A^{\mathrm {T} }\right)^{-1}=\left(A^{-1}\right)^{\mathrm {T} }}（A^{\mathrm{T}}为A的转置） \\ \det(A^{-1})=\frac{1}{\det(A)}（det为行列式）$

# Basic operation

# Addition

相同 n X m 矩阵，对应元素相加

# Multiply

# Application

# From A Example

首先我们看一个例子：

这是我们的目标变换：

$\left[ \begin{matrix} x^{'} \\ y^{'} \end{matrix}\right] = \left[ \begin{matrix} s&0 \\ 0&s \\ \end{matrix}\right] \left[ \begin{matrix} x \\ y \end{matrix}\right]$

推广到各种变换，都能转化成线性矩阵何向量的乘积，一般性的：

$\left[ \begin{matrix} x^{'} \\ y^{'} \end{matrix}\right] = \left[ \begin{matrix} a&b \\ c&d \\ \end{matrix}\right] \left[ \begin{matrix} x \\ y \end{matrix}\right] \\ x^{'} = M x$

Scale

Reflection

Shear

Rotation

Note：旋转的轴点我们默认使用原点

# Homogeneous Coordinates

貌似一个 2 x 2 的矩阵就能表示大多数点 / 向量的变换，但思考以下的问题：

此时矩阵无法处理平移的问题，需要额外计算：

$\left[ \begin{matrix} x^{'} \\ y^{'} \end{matrix}\right] = \left[ \begin{matrix} a&b \\ c&d \\ \end{matrix}\right] \left[ \begin{matrix} x \\ y \end{matrix}\right] + \left[ \begin{matrix} t_x \\ t_y \end{matrix}\right]$

这使得看起来非常臃肿，同时也证明了平移变换不是线性变换。

为了解决无法统一的问题，我们引入了齐次坐标系：通过增加的一个维度的信息，来将我们的平移变换统一起来。

齐次坐标：就是将一个原本是 n 维的向量用一个 n+1 维向量来表示，是指一个用于投影几何里的坐标系统，如同用于欧氏几何里的笛卡儿坐标一般。

我们做出以下定义：

$Point = \left( \begin{matrix} x \\ y \\ 1 \end{matrix}\right) Vector= \left( \begin{matrix} x \\ y \\ 0 \end{matrix}\right)$

多出一维的信息，我们用来区分是向量还是点，因为如果作为点，有唯一性，当第三维维 1 是，就是该点坐标。有了这些定义后，我们就能推出以下的关系：

$vector + vector = vector \\ point - point = vector \\ point + vector = point \\ point + point = mid\_point$

我们可以将公式（27）进行转化为以下：

$\left[ \begin{matrix} x^{'} \\ y^{'} \\ 1 \end{matrix}\right] = \left[ \begin{matrix} a&b&t_x \\ c&d&t_y \\ 0&0&1 \end{matrix}\right] \left[ \begin{matrix} x \\ y \\ 1 \end{matrix}\right]$

于是线性变换和平移变换在齐次坐标系就统一了：

逆转换

当我们知道一个点 / 向量的变换矩阵后，我们就能通过这个变换矩阵的逆矩阵使得变换后的点 / 向量回复原样

目标转化

如果我们有一个起始图像和目标图像的关系如下：

这里有两种思路：

先进行平移再进行线性变换（此时要注意到旋转轴点是原点）
先进行线性变换再进行平移

我们可以看到先进行线性变换才能获得正确的目标，因为大多数线性变换是基于原点进行的，如果先进行平移则会导致图像坐标到原点左边的距离改变。这也再次体现了矩阵计算不遵守交换律：

$R_{45} \cdot T_{(1,0)} \neq T_{(1,0)} \cdot R_{45}$

目标转化分解

上面我们提到都是图像初始点在原点的情况，如果我们的起始图像不是在原点那怎么处理呢，主要分为以下三步：

平移到原点
线性变换
平移回去

矩阵表示：

$T(c) \cdot R(a) \cdot T(-c)$

# Generalize to high-dimensional

$3D\_Point = \left( \begin{matrix} x \\ y \\ z \\ 1 \end{matrix}\right) 3D\_Vector= \left( \begin{matrix} x \\ y \\ z \\ 0 \end{matrix}\right)$

Scale

$S(s_x,s_y,s_z) = \left( \begin{matrix} s_x & 0 & 0 & 0 \\ 0 & s_y & 0 & 0 \\ 0 & 0 & s_z & 0 \\ 0 & 0 & 0 & 1 \end{matrix}\right)$

Translation

$S(s_x,s_y,s_z) = \left( \begin{matrix} 1 & 0 & 0 & t_x \\ 0 & 1 & 0 & t_y \\ 0 & 0 & 1 & t_z \\ 0 & 0 & 0 & 1 \end{matrix}\right)$

Rotation

旋转和 2 维的有一些不同，此时会有不同的旋转轴，要分情况讨论：

绕 x 轴旋转：

$R_x(a) = \left( \begin{matrix} 1 & 0 & 0 & 0 \\ 0 & \cos a & -\sin a & 0 \\ 0 & \sin a & \cos a & 0 \\ 0 & 0 & 0 & 1 \end{matrix}\right)$

绕 z 轴旋转：

$R_z(a) = \left( \begin{matrix} \cos a & -\sin a & 0 & 0 \\ \sin a & \cos a & 0 & 0 \\ 0 & 0 & 1 & 0 \\ 0 & 0 & 0 & 1 \end{matrix}\right)$

绕 y 轴旋转：

$R_y(a) = \left( \begin{matrix} \cos a & 0 & \sin a & 0 \\ 0 & 1 & 0 & 0 \\ -\sin a & 0 & \cos a & 0 \\ 0 & 0 & 0 & 1 \end{matrix}\right)$

Note: y 轴的旋转部分和 x，y 都不一样。

任何 3D 旋转都能分解为：

$R_{x,y,z}(\alpha,\beta,\gamma) = R_x(\alpha)R_y(\beta)R_z(\gamma)$

Rodrigues’ Rotation

$\mathbf {v} _{\mathrm {rot} }=\mathbf {v} \cos \theta +(\mathbf {k} \times \mathbf {v} )\sin \theta +\mathbf {k} ~(\mathbf {k} \cdot \mathbf {v} )(1-\cos \theta )\,$

这个公式中 $v_{rot}$ 是我们的目标向量， $v$ 是我们的初始向量， $k$ 是我们给定一个方向的单位向量，这个公式的推导过程如下，首先我们来看一个变换。

已知初始向量 $v$ 和给定的方向的单位向量 $k$ ，我们可以把向量 $v$ 分解为平行和垂直于向量 $k$ 的向量，记为（因为垂直叉乘后模等于原来模本身）：

$v_{\parallel} = (v \cdot k) k \\ v_{\bot} = -k \times (k \times v) \\$

然后我们可以把目标向量 $v_{rot}$ 也分解到平行和垂直于向量 $k$ 的向量，我们可以得出：

$\mathbf {v} _{\parallel \mathrm {rot} }=\mathbf {v} _{\parallel }$

因为在平行于 $k$ 的方向上，旋转不改变，接着来看垂直方向：

${\begin{aligned}\left|\mathbf {v} _{\perp \mathrm {rot} }\right|&=\left|\mathbf {v} _{\perp }\right|\,,\\\mathbf {v} _{\perp \mathrm {rot} }&=\cos(\theta )\mathbf {v} _{\perp }+\sin(\theta )\mathbf {k} \times \mathbf {v} _{\perp }\end{aligned}}$

最后我们将公式进行化简：

${\displaystyle {\begin{aligned}\mathbf {v} _{\mathrm {rot} } &=v_{\parallel rot} + v_{\bot rot} \\ &=\mathbf {v} _{\parallel }+\cos(\theta )\,\mathbf {v} _{\perp }+\sin(\theta )\,\mathbf {k} \times \mathbf {v} \\&=\mathbf {v} _{\parallel }+\cos(\theta )\left(\mathbf {v} -\mathbf {v} _{\parallel }\right)+\sin(\theta )\,\mathbf {k} \times \mathbf {v} \\&=\cos(\theta )\,\mathbf {v} +(1-\cos \theta )\mathbf {v} _{\parallel }+\sin(\theta )\,\mathbf {k} \times \mathbf {v} \\&=\cos(\theta )\,\mathbf {v} +(1-\cos \theta )(\mathbf {k} \cdot \mathbf {v} )\mathbf {k} +\sin(\theta )\,\mathbf {k} \times \mathbf {v} \end{aligned}}}$

进一步，我们讨论 $k \times v$ 的矩阵表示形式 $K$ ：

$K={\displaystyle {\begin{aligned}\mathbf {k\times v} &={\begin{vmatrix}k_{2}&k_{3}\\v_{2}&v_{3}\end{vmatrix}}\mathbf {i} -{\begin{vmatrix}k_{1}&k_{3}\\v_{1}&v_{3}\end{vmatrix}}\mathbf {j} +{\begin{vmatrix}k_{1}&k_{2}\\v_{1}&v_{2}\end{vmatrix}}\mathbf {k} \\&=(k_{2}v_{3}-k_{3}v_{2})\mathbf {i} -(k_{1}v_{3}-k_{3}v_{1})\mathbf {j} +(k_{1}v_{2}-k_{2}v_{1})\mathbf {k} \\ &={\begin{bmatrix}k_{y}v_{z}-k_{z}v_{y}\\k_{z}v_{x}-k_{x}v_{z}\\k_{x}v_{y}-k_{y}v_{x}\end{bmatrix}}\\ &={\begin{bmatrix}0&-k_{z}&k_{y}\\k_{z}&0&-k_{x}\\-k_{y}&k_{x}&0\end{bmatrix}}{\begin{bmatrix}v_{x}\\v_{y}\\v_{z}\end{bmatrix}} \end{aligned}}}$

最后我们就能得到我们的计算公式：

$R(k,\theta) = \cos(\theta) \cdot k + (1-\cos (\theta))k\cdot k_{\bot} + \sin (\theta) \left( \begin{matrix} 0 & -k_z & k_y \\ k_z & 0 & 0 \\ -k_y & k_x & 0 \\ \end{matrix}\right)$

同样可以推出：

$\mathbf {R} =k\cos \theta +(\sin \theta )\mathbf {K} +(1-\cos \theta )\mathbf {K} ^{2}$

Math in anywhere | Funciton

Wed, 28 Apr 2021 11:08:00 +0800

# Math in anywhere | Funciton

# Functions

# Space Concept

函数空间：即我们使用如干简单函数（这部分称之为” 基函数 “）通过线性组合（乘法和加法）的方式张成一个函数空间。

$L = span\{f_1,f_2,\cdots,f_n\} = \{\sum_{i=1}^na_i f_i(x)| a_i\in R\}$

$f_n (n \in R)$ ：代表函数空间中的元素

函数空间中的元素，总能表达成 n 个 $a_i f_i(x)$ 的加和，其中把系数提取出来就能够获得系数向量

$(a_1,a_2,\cdots,a_n)$

具体的实例说明

多项式的函数空间，幂基

$f(x) = \sum_{k = 0}^n w_kx^k$
三角函数的函数空间，三角函数基

$f(x) = a_0 + \sum_{k=1}^n (a_k \cos kx + b_k \sin kx)$

本质上就是确定函数的类型，然后去确定系数向量

# Weierstrass approximation theorem

定理一：设 $f(x)$ 闭区间 $[a, b]$ 上的连续函数，则存在多项式序列 $P_n(x)$ 在 $[a, b]$ 上一致收敛于 $f(x)$ 。也就是对任意给定的 ϵ > 0，存在多项式 $P(x)$ ，使得：

$|P(x) - f(x)| < \epsilon$

对一切 $x \in [a,b]$ 成立。

定理二：设 $f(x)$ 是以 2π 为周期的连续函数，则存在三角多项式序列一致收敛于 $f(x)$ 。也就是对于任意给定的 ϵ > 0，存在三角多项式 $T(x)$ ，使得:

$|T(x) -f(x)| < \epsilon$

对一切 $x \in [-\infty,\infty]$ 成立。

# Fourier series

客观世界最常见的最简单周期函数：

$f(t) = A \sin(wt + \varphi)$

这里 t 表示时间，A 表示振幅，ω 为角频率， $\varphi$ 为初相位。

因为大多数周期信号并没有这么简单，但是傅里叶在《热的解析理论》中推导出使用一系列最简单的三角函数来组合复杂的周期函数，这些都基于三角函数的基本变化规律，如下图。

可以看这个视频，让你更直观的了解傅里叶级数：

傅里叶推导出的公式为：

$f(t) = A_0 + \sum_{n=1}^\infty A_n \sin(nwt + \varphi_n)$

由 $\varphi_n$ 为常数， $A_n$ 也是常数，则对上式的 $A_n \sin(nwt + \varphi_n)$ 进行变形：

$A_n \sin(nwt + \varphi) = A_n \sin \varphi_n \cos(nwt) + A_n \cos \varphi_n \sin(nwt)$

记 $a_n = A_n \sin \varphi_n , b_n = A_n \cos \varphi_n$ 然后进行替换公式 9，然后代进去公式 8

$f(t) = A_0 + \sum_{n=1}^\infty (a_n \cos(nwt) + b_n\sin(nwt))$

这里面的参数的计算：

$A_0 = \frac{1}{2\pi}\int_{-\pi}^{\pi}f(t)$

$a_n = \frac{1}{\pi} \int_{-\pi}^{\pi}{f(t) \cdot \cos(nwt) dt}$

$b_n = \frac{1}{\pi} \int_{-\pi}^{\pi}{f(t) \cdot \sin(nwt) dt}$

这个视频能够帮助你系统的了解傅里叶级数和傅里叶变换

# Data Fitting

数据拟合需要我们抓住问题的要点，实际应用问题能够进行抽象成一个数据模型，获取输入，找到合适的函数，优化函数。而这里的核心便是如何找到合适的函数，这里分为三步：

确定函数空间
- 这一步就需要我们对数据进行观察，然后根据数据的趋势选取合适的函数空间。
确定度量方式
- 根据实际情况的不同，会分为两种不同的目标：
  - 对数据集进行函数插值
  - 对数据集进行函数逼近
求解与优化
- 根据实际的目标来选择合适的数学方法
  - 对数据集的插值
    - Lagrange 插值
    - Newton 插值
  - 对数据集的逼近
    - 最小二乘法

插值：就是无误差，数据集的每一个点都刚好可以通过函数变换而来。

# Function interpolation

在许多实际问题中，某个函数 $f(x)$ 往往很复杂、没有解析表达或者未知。我们往往只能通过某些手段观测到反映该函数的一些采样数据。我们希望通过这些观测的采样数据来估计该函数的信息，并预测函数在其他观测点的值。这时，我们从观测数据来求得一个函数 $\phi(x)$ 来近似 $f(x)$ 。

定义： $f(x)$ 为定义在区间 $[a, b]$ 上的函数， $x_0, x_1, \cdots, x_n$ 为区间上 n + 1 个互不相同的点， $\Phi$ 为给定的某一函数类。求 $\Phi$ 上的函数 $\phi(x)$ ，满足：

$\phi(x_i) = f(x_i), i = 0,1,\cdots,n$

则称 $\phi(x)$ 为 $f(x)$ 关于节点 $x_0, x_1, \cdots, x_n$ 在 $\Phi$ 上的插值函数。称 $x_0, x_1, \cdots, x_n$ 为插值节点，称 $(x_i, f(x_i))$ 为插值点。

多项式插值定理

定理：若 $x_i$ 两两不同，则对任意给定的 $y_i$ ，存在唯一的次数至多是 n 次的多项式 $p_n$ ，使得 $p_n(x_i)=y_i ,i = 0, \cdots , n$ 。

证明：在幂基 $\{1, x, \cdots , x_n\}$ 下待定多项式 $p$ 的形式为：

$p(x) = a_0 + a_1x + a_2x^2 + \cdots + a_nx^n$

由插值定理可知，可以得到如下的方程

$\left[ \begin{matrix} 1 & x_{0} & x_0^2& \cdots & x_0^n\\ 1 & x_{1} & x_1^2& \cdots & x_1^n\\ 1 & x_{2} & x_2^2& \cdots & x_2^n\\ \vdots & \vdots & \vdots &\ddots \vdots & \vdots \\ 1 & x_{n} & x_n^2& \cdots & x_n^n\\ \end{matrix}\right] \left[ \begin{matrix} a_{0} \\ a_{1} \\ a_{2} \\ \vdots\\ a_{n} \end{matrix}\right] = \left[ \begin{matrix} y_{0} \\ y_{1} \\ y_{2} \\ \vdots\\ y_{n} \end{matrix}\right]$

系数矩阵为 Vandermonde 矩阵，其行列式非零，因此方程组有唯一解。

关于 $n \times n$ 阶 Vandermonde 矩阵的行列式计算公式如下：

$\det A_n = \prod_{1\le j \le n}(x_i - x_j)$

因为我们知道 $x_i$ 是彼此相异的，代入公式 (17)，可知 $\det A_n \ne 0$ ，A 是可逆的，因此方程式必定存在唯一解。

Lagrange 插值

定义：给定一组 $k+1$ 数据 $（x_ {0}，y_ {0}），\ldots，（x_ {j}，y_ {j}），\ldots，（x_ {k}，y_ {k}）$ , 其中没有两个 $\displaystyle x_{j}$ 相同，拉格朗日插值多项式是：

$L（x）:= \sum_{ j = 0 }^k y_j \ell_j( x )$

其中 $\ell_{j}(x)$ 是拉格朗日基函数：

$\ell_{j}(x):= \prod_{\begin{smallmatrix} 0 \leq m \leq k \\ m \neq j \end{smallmatrix} }{\frac{x-x_{m} }{x_{j}-x_{m} } } = {\frac{x-x_0}{x_j - x_0} } \cdots {\frac{x-x_{j - 1} }{x_{j} - x_{j-1} } {\frac {（x-x_ {j+1}）} {（x_ {j} -x_ {j+1}）} } \cdots \frac{x - x_k}{x_j - x_k}, 0\le j \le k}$

拉格朗日基本多项式 $\ell _{j}(x)$ 的特点是在 $x_{j}$ 上取值为 1，在其它的点 $x_{i},i\neq j$ 上取值为 0 看例子可知。

Example：

假设有二次多项式函数 $f$ ，已知它在三个点的值为 $(4,10) ,(5,5.25) ,(6,1)$ ，求二次多项式

$\ell _{0}(x)={\frac {(x-5)(x-6)}{(4-5)(4-6)} } \\ {\displaystyle \ell _{1}(x)={\frac {(x-4)(x-6)}{(5-4)(5-6)} } }\\ {\displaystyle \ell _{2}(x)={\frac {(x-4)(x-5)}{(6-4)(6-5)} } }$

${\begin{aligned} p(x) & = f(4)\ell _{0}(x)+f(5)\ell _{1}(x)+f(6)\ell _{2}(x) \\ & = 10\cdot {\frac {(x-5)(x-6)}{(4-5)(4-6)} }+5.25\cdot {\frac {(x-4)(x-6)}{(5-4)(5-6)} }+1\cdot {\frac {(x-4)(x-5)}{(6-4)(6-5)} } \\ & = \frac{1}{4}(x^{2}-28x+136) \end{aligned} }$

优缺点：

拉格朗日插值法的公式结构整齐紧凑，在理论分析中十分方便
在计算中，当插值点增加或减少一个时，所对应的基本多项式就需要全部重新计算，于是整个公式都会变化，非常繁琐。
- 这时可以用重心拉格朗日插值法或牛顿插值法来代替。
当插值点比较多的时候，拉格朗日插值多项式的次数可能会很高，因此具有数值不稳定的特点，也就是说尽管在已知的几个点取到给定的数值，但在附近却会和 “实际上” 的值之间有很大的偏差（如下图）。这类现象也被称为龙格现象。
- 解决的办法是分段用较低次数的插值多项式。

Barycentric Form

为了解决数据增多情况下，拉格朗日插值法庞大计算量的问题。可以使用重心拉格朗日形式。首先我们定义一个多项式：

$l(x) = (x-x_0)(x-x_1)\cdots(x-x_k)$

公式 (19) 上下同时乘以 $(x-x_j)$ ，然后将公式 (24) 代进去，可得

$\ell_j = \frac{l(x)}{x-x_j} \cdot \frac{1}{\prod_{i=0,i\ne j}^k (x_j - x_i)}$

然后我们将 $\frac{1}{\prod_{i=0,i\ne j}^k (x_j - x_i)}$ 拿出来，将其定义为重心权：(这一步就是简化的关键)

$w_j = \frac{1}{\prod_{i=0,i\ne j}^k (x_j - x_i)}$

如果此时又加了一个数，那么新的 $w_j$ 只需要再除以 $(x_j-x_i)$

那么原公式就能变换为：

$\ell_j(x) = \ell(x)\frac{w_j}{x-x_j}$

进而得出重心拉格朗日插值：

$L（x）:= \sum_{j = 0}^{k} y_{j} \ell_{j}(x) = l(x) \sum_{j=0}^k \frac{w_j}{x-x_j} y_j$

进一步的我们还能对该公式进行变换，设有函数满足：

$g(x)\equiv 1$

$\forall x,\,g(x)=\ell (x)\sum _{ {j=0} }^{k}{\frac {w_{j} }{x-x_{j} } }$

将 $L(x)$ 除以 $g(x)$ 后可得到：

$L(x)={\frac {\sum _{ {j=0} }^{k}{\frac {w_{j} }{x-x_{j} } }y_{j} }{\sum _{ {j=0} }^{k}{\frac {w_{j} }{x-x_{j} } } } }$

优点

当插值点的个数增加一个时，将每个 $w_{j}$ 都除以 $(x_{j}-x_{ {k+1} })$ ，就可以得到新的重心权 $w_{ {k+1} }$ ，计算复杂度为 ${\mathcal O}(n)$ ，比重新计算每个基本多项式所需要的复杂度 ${\mathcal O}(n^{2})$ 降了一个量级。

Newton 插值

定义：给定一组 $k+1$ 数据 $（x_ {0}，y_ {0}），\ldots，（x_ {j}，y_ {j}），\ldots，（x_ {k}，y_ {k}）$ , 其中没有两个 $\displaystyle x_{j}$ 相同，牛顿插值多项式是：

$N(x):=\sum _{ {j=0} }^{ {k} }a_{ {j} }n_{ {j} }(x)$

其中 $n_{ {j} }(x)$ 为牛顿基本多项式基函数，其表达式为：中

$n_{j}(x):=\prod _{ {i=0} }^{ {j-1} }(x-x_{i}) \space \\ j>0，n_{0}(x)\equiv 1$

而 $a_j := [y_{0},\ldots ,y_{j}]$ 作为基函数的系数，而 $[y_{0},\ldots ,y_{j}]$ 表示差商（也叫均差，是递归除法过程）

均差定义有两种方式：

向前均差

${\begin{aligned}{\mathopen {[} }y_{\nu }]&=y_{\nu },\quad \nu \in \{0,\ldots ,n\}\\{\mathopen {[} } y_{\nu },\ldots ,y_{\nu +j}]&={\frac {[y_{\nu +1},\ldots ,y_{\nu +j}]-[y_{\nu },\ldots ,y_{\nu +j-1}]}{x_{\nu +j}-x_{\nu } } },\quad \nu \in \{0,\ldots ,n-j\},\ j\in \{1,\ldots ,n\}\\\end{aligned} }$

向后均差 (我们主要使用这种)
${\begin{aligned}{\mathopen {[} }y_{\nu }]&=y_{\nu },\quad \nu \in \{0,\ldots ,n\}\\{\mathopen {[} }y_{\nu },\ldots ,y_{\nu -j}]&={\frac {[y_{\nu },\ldots ,y_{\nu -j+1}]-[y_{\nu -1},\ldots ,y_{\nu -j}]}{x_{\nu }-x_{\nu -j} } },\quad \nu \in \{j,\ldots ,n\},\ j\in \{1,\ldots ,n\}\\\end{aligned} }$

递归的过程通过下图来理解：

$\begin{aligned}\mathopen[y_0] &= y_0 \\ \mathopen[y_0,y_1] &= \frac{y_1-y_0}{x_1-x_0} \\ \mathopen[y_0,y_1,y_2] &= \frac{\mathopen[y_1,y_2]-\mathopen[y_0,y_1]}{x_2-x_0} \\ \mathopen[y_0,y_1,y_2,y_3] &= \frac{\mathopen[y_1,y_2,y_3]-\mathopen[y_0,y_1,y_2]}{x_3-x_0} \\ \mathopen[y_0,y_1,\dots,y_n] &= \frac{\mathopen[y_1,y_2,\dots,y_n]-\mathopen[y_0,y_1,\dots,y_{n-1}]}{x_n-x_0} \end{aligned}$

$\begin{matrix} x_0 & [y_0] = y_0 & & & \\ & & [y_0,y_1] & & \\ x_1 & [y_1] = y_1 & & [y_0,y_1,y_2] & \\ & & [y_1,y_2] & & [y_0,y_1,y_2,y_3]\\ x_2 & [y_2] = y_2 & & [y_1,y_2,y_3] & \\ & & [y_2,y_3] & & \\ x_3 & [y_3] = y_3 & & & \\ \end{matrix}$

然后将 $n_{ {j} }(x)$ 和 $a_j$ 带入方程就可以获得，牛顿多项式的这种形式：

$N(x)=[y_{0}]+[y_{0},y_{1}](x-x_{0})+\cdots +[y_{0},\ldots ,y_{k}](x-x_{0})(x-x_{1})\cdots (x-x_{ {k-1} })$

Example：

已知它在五个点的值为 $(-\frac{3}{2},-14.1014) ,(-\frac{3}{4},-0.931596) ,(0,0),(\frac{3}{4},0.931596)(\frac{3}{2},14.1014)$ ，求牛顿多项式插值。（构造目标为 $f(x) = \tan (x)$ ）

首先计算出差商表

${\begin{matrix}-{\tfrac {3}{2} }&-14.1014&&&&\\&&17.5597&&&\\-{\tfrac {3}{4} }&-0.931596&&-10.8784&&\\&&1.24213&&4.83484&\\0&0&&0&&0\\&&1.24213&&4.83484&\\{\tfrac {3}{4} }&0.931596&&10.8784&&\\&&17.5597&&&\\{\tfrac {3}{2} }&14.1014&&&&\\\end{matrix} }$

然后就能够写出多项式：

$-14.1014+17.5597(x+{\tfrac {3}{2} })-10.8784(x+{\tfrac {3}{2} })(x+{\tfrac {3}{4} })+4.83484(x+{\tfrac {3}{2} })(x+{\tfrac {3}{4} })(x)+0(x+{\tfrac {3}{2} })(x+{\tfrac {3}{4} })(x)(x-{\tfrac {3}{4} }) \\ =-0.00005-1.4775x-0.00001x^{2}+4.83484x^{3}$

这里我们能够观察到，数据点的增多并不会使得所有计算需要重新进行，只需要计算新的差商，然后多加一个多项式。

但是牛顿插值也会使得整体的多项式次数过高。

# Function approximation

给出一组离散的点，需要确定一个函数来逼近原函数。由于离散数据通常是由观察或测试得到的，所以不可避免的会有误差。我们需要的逼近原函数的手段要满足如下两个条件：

不要求过所有的点（可以消除误差影响）
尽可能表现数据的趋势，靠近这些点

用数学的语言来说即是，需要在给定的函数空间 Φ 上找到函数 ϕ，使得 ϕ 到原函数 $f$ 的距离最小。这里的距离指的是某种度量，不同的度量对应着不同的拟合方法。则函数 ϕ(x) 称为 $f(x)$ 在空间 Φ 上的拟合曲线。

$R_2 = \sqrt{\sum_{i=0}^m(\phi(x_i) - f(x_i))^2}$

一般我们采用最小二乘法来处理这一类问题，这里我们首先给出离散内积的概念，内积这个计算概念主要是将公式中的项抽离出来的，所以不需要理解他的几何概念。

定义：函数 $f,g$ 的关于离散点列 $\{x_i\}_{i=0}^m$ 的离散内积为：

$(f,g)_h = \sum_{i=0}^n f(x_i)g(x_i)$

上述定义中的下标 h 表示对离散内积与离散范数的指代

定义：函数 $f$ 的离散范数为：

$||f||_h = \sqrt {(f,f)_h}$

然后我们将上面离散内积和离散范数运用到最小二乘法中：

设 $\Phi=span\{\phi_0,\phi_1,\cdots,\phi_n\}$

$\phi(x) = a_0\phi_0(x) + a_1\phi_1(x) + \cdots + a_n\phi_n(x)$

进一步最小二乘为：

${\begin{aligned}||f(x)-\phi(x)||_h = ||f(x) - a_0\phi_0(x) + a_1\phi_1(x) + \cdots + a_n\phi_n(x) ||_h \end{aligned} }$

然后我们需要获取关于系数 $\{a_0,a_1,\cdots,a_n\}$ 最小，我们可以计算 2 范数

${\begin{aligned}||f(x)-\phi(x)||_h^2 & = ||f(x) - a_0\phi_0(x) + a_1\phi_1(x) + \cdots + a_n\phi_n(x) ||_h^2\\ & = ||f||_h^2 - 2f(x)[(a_0\phi_0(x) + a_1\phi_1(x) + \cdots + a_n\phi_n(x))] + ||a_0\phi_0(x) + a_1\phi_1(x) + \cdots + a_n\phi_n(x)||_h^2 \\ & = ||f||_h^2 - 2\sum_{k=0}^n a_k(f,\phi_k)_h + \sum_{i,k =0}^n a_ia_k(\phi_i,\phi_k)_h \end{aligned} }$

我们将这个函数变成 $Q(a_i)$ 的函数：

$Q(a_i) = ||f||_h^2 - 2\sum_{k=0}^n a_k(f,\phi_k)_h + \sum_{i,k =0}^n a_ia_k(\phi_i,\phi_k)_h$

为了使得系数的值最小，因此我们对函数求一阶导数，获得函数的极值点：

$\frac{\partial Q}{\partial a_i} = 0 , i= 0,1,\cdots,n \\ (f,\phi_i)_h = \sum_{k =0}^n a_k(\phi_i,\phi_k)_h$

然后改为矩阵形式：

$\left[ \begin{matrix} (\phi_0,\phi_0)_h & \cdots & (\phi_0,\phi_n)_h \\ \vdots &\ddots& \vdots \\ (\phi_n,\phi_0)_h & \cdots & (\phi_n,\phi_n)_h \end{matrix}\right] \left[ \begin{matrix} a_{0} \\ \vdots\\ a_{n} \end{matrix}\right] = \left[ \begin{matrix} (f,\phi_0)_h \\ \vdots\\ (f,\phi_n)_h \\ \end{matrix}\right]$

Example：

取 $Φ$ 为线性多项式空间，函数空间的基为 $\{1, x, x^2\}$ , 拟合曲线为 $y = a_0 + a_1x + a_2x^2$ ，则法方
程为:

$\left[ \begin{matrix} (1,1)_h & (1,x)_h & (1,x^2)_h \\ (x,1)_h & (x,x)_h & (x,x^2)_h \\ (x^2,1)_h & (x^2,x)_h & (x^2,x^2)_h \\ \end{matrix}\right] \left[ \begin{matrix} a_{0} \\ a_{1} \\ a_{2} \end{matrix}\right] = \left[ \begin{matrix} (f,1)_h \\ (f,x)_h \\ (f,x^2)_h \\ \end{matrix}\right]$

最小二乘拟合（岭回归正则项） $A\{a_0,a_1,\cdots,a_n\}$ ，函数表达式：

$min||Y - A\Phi||^2 + \mu ||A||_2^2$

其中 $\mu$ 为权重，就是对参数的值的大小的权重控制。

依据同样的思想，稀疏正则化：

$min ||Y - A\Phi||^2 + \mu||W||_0$

$||W||_0$ 表示非零的元素。

拟合的问题：

欠拟合
- 选取适合的基函数去拟合
过拟合
- 数据去噪
  - 剔除训练样本中噪声
- 数据增广
- 增加样本数，或者增加样本的代表性和多样性
- 模型简化
  - 预测模型过于复杂，拟合了训练样本中的噪声
  - 选用更简单的模型，或者对模型进行裁剪
- 正则约束
  - 适当的正则项，比如方差正则项、稀疏正则项

Kernel Module — Char Device Basic II

Thu, 22 Apr 2021 15:25:00 +0800

# Kernel Module — Char Device Basic II

Goal

上一篇介绍了一般字符驱动的开发逻辑，而这一篇主要是讲一般的字符型驱动以外的，其他类字符型驱动设备的开发逻辑，以及内核里非常巧妙的内核无锁环形缓存区 KFIFO 的使用和具体的实现逻辑。

Misc 驱动开发逻辑
Misc 驱动的适用范围
KFIFO 的使用

Preconditions

了解 Make
了解 C
了解 Bash 语法
了解上一篇的内容

# MISC Char Device

Miscellaneous Devices：其他设备，也就是指没有在 Linux Kernel Document 中写明的驱动类型，都可以用 Misc 机制来注册和管理驱动。因为有时人们需要编写 “小型” 设备驱动程序，以支持自定义的 hack（硬件或软件），而 Misc 的好处就是简化了我们对 Module 开发的步骤，从注册到创建设备节点都一站式完成，使得整个流程非常顺滑。但是 Misc 驱动也有自己缺陷，就是无法注册多个设备节点

MISC 机制的内容

miscdevice ：管理着所有信息

	struct miscdevice {
	int minor; // 标志为动态分配
	const char *name; // 模块名
	const struct file_operations *fops; // 对应我们的函数集
	struct list_head list;
	struct device *parent;
	struct device *this_device; // 这是注册完返回的设备
	const struct attribute_group **groups;
	const char *nodename;
	umode_t mode;
	};

注册和注销
- int misc_register(struct miscdevice *misc) ：注册一个 misc 设备
- void misc_deregister(struct miscdevice *misc) ：注销一个 misc 设备

赋值：

	static struct miscdevice mydemo_device_misc_d = {
	.minor = MISC_DYNAMIC_MINOR,
	.name = DEMO_NAME,
	.fops = &demo_fops
	};

# Kernel Data Struct

KFIFO
- 内核无锁环形缓冲区
- 原理：实现一个读指针（指向可读区域），一个写指针（指向可写区域）在一个环形的缓冲区中操作
- 实现：能够在一个读进程和一个写进程并发的场景下，无须加锁来保证数据的安全，当然还是提供了加锁的操作的（例如加了自旋锁的 in 和 out）
- 操作：
  - 注册：
    - DEFINE_KFIFO(fifo, type, size) ：声明和初始化一个 FIFO
    - kfifo_init(fifo, buffer, size) ：声明和初始化一个 FIFO
    - kfifo_alloc(fifo, size, gfp_mask) ：请求一个 FIFO 的 buffer
  - 操作：
    - kfifo_is_full ：是否满
    - kfifo_is_empty : 是否空
    - kfifo_len ：获得 fifo 已经使用的元素个数
    - kfifo_avail ：获得 fifo 没有使用的个数
    - kfifo_size ：获得 fifo 的大小
    - kfifo_reset ：重置 fifo 的内容
  - 数据迁移：
    - kfifo_from_user(fifo, from, len, copied)
      - fifo ：缓存区的对象
      - from ：读取的地方
      - len ：读取的数量
      - copied ：读取成功的数量，会赋值到这个变量上
    - kfifo_to_user(fifo, to, len, copied)
      - fifo ：缓存区的对象
      - to ：存放的地方
      - len ：读取的数量
      - copied ：读取成功的数量，会赋值到这个变量上
  - 释放： kfifo_free(fifo) 释放一个 fifo 空间
I/O 非阻塞
- 非阻塞：就是不等待，直接操作，要么操作成功，要么返回错误码
- 阻塞：就是会等待，等待条件满足后唤醒
- FLAG：O_NONBLOCK

# Source Code

demo.c

	#include <linux/module.h>
	#include <linux/init.h>
	#include <linux/fs.h>
	#include <linux/miscdevice.h> //misc 机制的头文件
	#include <linux/uaccess.h>
	#include <linux/kfifo.h> // 内核无环缓冲区

	#define DEMO_NAME "kfifodriver"
	static struct device * mydemo_device;
	DEFINE_KFIFO(demo_fifo, char, 64);

	static int demo_open(struct inode * inode,struct file * file)
	{
	// 我们将驱动做成一个设备节点，所以可以用 inode 结构来访问，驱动信息
	int major = MAJOR(inode->i_rdev);
	int minor = MINOR(inode->i_rdev);
	printk(KERN_EMERG"%s: Major Num: %d , Minor Num: %d",__func__,major,minor);
	return 0;
	}
	static int demo_release(struct inode * inode,struct file * file)
	{
	return 0;
	}
	//loff_t 表示当前读写位置的 offset
	static ssize_t demo_read(struct file * file, char __user *buf, size_t buf_count,\
	loff_t *ppos)
	{
	int ret;
	int readed_;
	if(kfifo_is_empty(&demo_fifo))
	{
	if(file->f_flags & O_NONBLOCK)
	return -EAGAIN;
	}
	ret = kfifo_to_user(&demo_fifo,buf, buf_count,&readed_);
	if(ret)
	return -EIO;
	printk(KERN_EMERG"%s readed = %d, pos = %lld \n",__func__,readed_,*ppos);
	return readed_;
	}
	static ssize_t demo_write(struct file * file, const char __user *buf, size_t buf_count,\
	loff_t *ppos)
	{
	int ret;
	int writed_ ;
	if(kfifo_is_full(&demo_fifo))
	{
	if(file->f_flags & O_NONBLOCK)
	return -EAGAIN;
	}
	ret = kfifo_from_user(&demo_fifo,buf, buf_count,&writed_); // 返回没有拷贝成功的字节数
	if (ret)
	return -EIO;
	printk(KERN_EMERG"%s writed = %d, pos = %lld \n",__func__,writed_,*ppos);
	return writed_;
	}
	static const struct file_operations demo_fops =
	{
	.owner = THIS_MODULE,
	.open = demo_open,
	.release = demo_release,
	.read = demo_read,
	.write = demo_write
	};

	static struct miscdevice mydemo_device_misc_d = {
	.minor = MISC_DYNAMIC_MINOR,
	.name = DEMO_NAME,
	.fops = &demo_fops
	};
	static int __init demo_init(void)
	{
	int ret;
	ret = misc_register(&mydemo_device_misc_d);
	if(ret)
	{
	printk(KERN_EMERG"Faild in register misc device");
	return ret;
	}
	mydemo_device = mydemo_device_misc_d.this_device;
	printk(KERN_EMERG"success register misc device: %s\n",DEMO_NAME);
	return 0;
	}

	static void __exit demo_exit(void)
	{
	printk("remove Device\n");
	misc_deregister(&mydemo_device_misc_d);
	}


	module_init(demo_init);
	module_exit(demo_exit);

	// 模块可选信息
	MODULE_LICENSE("GPL");// 许可证声明
	MODULE_AUTHOR("junwide");// 作者声明
	MODULE_DESCRIPTION("This module is a char device");// 模块描述
	MODULE_VERSION("V1.0");// 模块别名
	MODULE_ALIAS("Char Modules");// 模块别名

# Build Code

Makefile

和 Single Module 的 Makefile 一样，不在赘述

# Test

test.c

	#include <stdio.h>
	#include <fcntl.h>
	#include <unistd.h>

	#define DEMO_DEV_NAME "/dev/kfifodriver"

	int main()
	{
	char buffer[64];
	int fd;
	int ret;
	char message[80] = "we come from china";
	char *r_buffer;
	size_t len = sizeof(message);

	fd = open(DEMO_DEV_NAME, O_RDWR \| O_NONBLOCK);
	if (fd < 0) {
	printf("open device %s failded\n", DEMO_DEV_NAME);
	return -1;
	}
	r_buffer = malloc(len*2);
	memset(r_buffer,0,2*len);
	ret = read(fd,r_buffer,2*len);
	printf("read %d bytes\n",ret);
	printf("Context: %s\n",r_buffer);

	ret = write(fd,message,len);
	if( ret != len)
	{
	printf("can not write on device %d ret: %d \n",fd,ret);
	return -1;
	}
	ret = write(fd,message,len);
	if( ret != len)
	printf("can not write on device %d ret: %d \n",fd,ret);

	memset(r_buffer,0,2*len);
	ret = read(fd,r_buffer,2*len);
	printf("read %d bytes\n",ret);
	printf("Context: %s\n",r_buffer);
	close(fd);
	return 0;
	}

编译和安装

Commad命令行

	$ gcc test.c -o test --static
	$ make #编译
	$ sudo make install # 安装并启动
	$ sudo ./test

已经 KFIFO 满了，却没阻塞，再次写入引发错误

# Summary

这一篇主要内容是实现一个简单的 Misc 的驱动，同时能够调用 KFIFO 进行数据在用户态和内核态的传输。具体的 Misc 在内核实现的例子，可以参考内核中硬件看门狗的驱动实现。后面的拓展内容主要是介绍 KFIFO 的原理和实现的。

# More About KFIFO

KFIFO 全称为 Kernel First In First Out ，是内核无锁环形缓冲区，作为内核非常重要的数据结构，它有以下几个非常重要的特点，而这几个特点也将作为我们的切入点来了解这个设计巧妙的数据结构。无锁循环队列的应用范围很广泛，例如：在低频单片机中，串口接收数据（中断模式）可以将 ISR 分为 top half 和 bottom half，top half 负责接收数据并将数据存放到循环队列中，而 bottom half 负责从队列中取出数据并处理数据。用类似以上的实现，可以减少一个锁，从而实现更高的并发度和资源利用率。

高效编程理念
巧用环形缓冲
并行无锁技术

KFIFO数据结构

	struct __kfifo {
	unsigned int in; /* (in &= mask) 就是缓存区的入队索引 */
	unsigned int out; /* (out &= mask) 缓存区的出队索引 */
	unsigned int mask; /* 获取偏移的掩码 */
	unsigned int esize; /* 每个元素所占的字节数 */
	void data; / 指针：指向存放缓存的数据 */
	};

# 高效编程理念

让我们先来看一代码，主要观察高亮的部分的写法。

KFIFO初始化参考链接

	int __kfifo_alloc(struct __kfifo *fifo, unsigned int size,size_t esize, gfp_t gfp_mask)
	{
	/*
	* round up to the next power of 2, since our 'let the indices
	* wrap' technique works only in this case.
	*/
	size = roundup_pow_of_two(size);

	fifo->in = 0;
	fifo->out = 0;
	fifo->esize = esize;

	if (size < 2) {
	fifo->data = NULL;
	fifo->mask = 0;
	return -EINVAL;
	}

	fifo->data = kmalloc_array(esize, size, gfp_mask);

	if (!fifo->data) {
	fifo->mask = 0;
	return -ENOMEM;
	}
	fifo->mask = size - 1;

	return 0;
	}

这里使用了一个 roundup_pow_of_two() 的函数来完成大小的确定，这个函数主要的是作用有：

找出与用户给定 size 最近的 $2^n$ 的数（例如: Size (用户) 7 , 找出的数是 8 ( $2^3$ )）
尽可能快的完成上一步的操作

找数参考链接

	#define roundup_pow_of_two(n) \
	( \
	__builtin_constant_p(n) ? ( \
	((n) == 1) ? 1 : \
	(1UL << (ilog2((n) - 1) + 1)) \
	) : \
	__roundup_pow_of_two(n) \
	)

这里用到了两个方法来实现了高效的操作：

ilog2() 函数调用的是汇编的 bsr 用来找到 n-1 的最高有效的 1 的位置
找到最高有效的 1 的位置后使用位移操作直接获取到有效的大小（ $2^n$ ）

bsr ：bsr %0 %1 x86 汇编的一个指令，用于扫描一个 %1 中数的最高有效的 1 的位置索引，并存到 %0

例如：bsr % a #8 那么 a 中就会存 3

# 巧用环形缓冲

采用环形缓冲区的好处为，当一个数据元素被用掉后，其余数据元素不需要移动其存储位置，从而减少拷贝提高效率。

入队参考链接

	static void kfifo_copy_in(struct __kfifo fifo, const void src,
	unsigned int len, unsigned int off)
	{
	unsigned int size = fifo->mask + 1;
	unsigned int esize = fifo->esize;
	unsigned int l;

	off &= fifo->mask;
	if (esize != 1) { // 这一部分主要是处理数据占大小的，这会影响指针寻址
	off *= esize;
	size *= esize;
	len *= esize;
	}
	l = min(len, size - off);

	memcpy(fifo->data + off, src, l);
	memcpy(fifo->data, src + l, len - l);
	/*
	* make sure that the data in the fifo is up to date before
	* incrementing the fifo->in index counter
	*/
	smp_wmb();
	}

	unsigned int __kfifo_in(struct __kfifo *fifo,
	const void *buf, unsigned int len)
	{
	unsigned int l;

	l = kfifo_unused(fifo);
	if (len > l)
	len = l;

	kfifo_copy_in(fifo, buf, len, fifo->in);
	fifo->in += len;
	return len;
	}

我们先看 kfifo_unused() 这个函数。这个函数主要计算出 kfifo 中还有多少空用空间，主要通过以下两点实现：

in 和 out 都是 unsigned int ，
- 这就使得无论两个的位置如何，相减总能得到两个数之间的差，即 kfifo 中的元素数量
(mask+1) 是整个 kfifo 的大小
- (mask+1) 减去已经使用的元素数量，就能得到未使用的元素数量。

计算空间

	static inline unsigned int kfifo_unused(struct __kfifo *fifo)
	{
	return (fifo->mask + 1) - (fifo->in - fifo->out);
	}

然后看 L31 ，这里做一个取小值，如果剩余的多则要入队的都可以加，如果剩余的少则要入队只能是剩下的个数。

然后就开始到入队的正式过程，也是环形缓冲区的真正体现。我们这里为了便于理解，我们进行以下的假设

数据类型为 char
数据类型所占的字节数 esize 为 1
数据的 size 为 8
已经使用的数量为 2

我们先跳过 L8 的 off &= fifo->mask; ，先假设我们已经知道 in/off 为 6，然后看 L14 ：

l = min(len, size - off) ，这里对应的图中的 Step 1

(size-off) 计算的是偏移后面剩下的个数（包括使用的和未使用的）（这里是 2）
len 就是能够写入数量（这里是 6），这里有一个恒等关系 len >= (size - off)
取小值，是获得写在数据右边的数量。

然后使用 memcpy(fifo->data + off, src, l); 把数据写入到右侧

然后再使用 memcpy(fifo->data, src + l, len - l); 把数据写入到左侧这里对应图中的 Step 2

在 L35 这里直接更新 in 的位置（这里是 10）这里对应图中的 Step 3。然后现在会过头来看我们刚才跳过的 L8 。

如果下一次继续入队两个元素，那么先执行 L8 . off &= fifo->mask;

in = 10 (1010b)
mask = 7 (0111b)
off = 2 (0010b)

这样就完成了偏移的环形，而且不需要额外的判断。如果能够理解入队操作，那么出队操作也是类似的。

# 并行无锁技术

实际上是使用了内存屏障，我们知道编译器编译源代码时，会将源代码进行优化，将源代码的指令进行重排序，以适合于 CPU 的并行执行。然而，内核同步必须避免指令重新排序，优化屏障（Optimization barrier）避免编译器的重排序优化操作，保证编译程序时在优化屏障之前的指令不会在优化屏障之后执行。具体关于内存屏障的讨论，我们会在缓存和内存相关内容时进行讨论，这里只是简单的理解。

软件可通过读写屏障强制内存访问次序。读写屏障像一堵墙，所有在设置读写屏障之前发起的内存访问，必须先于在设置屏障之后发起的内存访问之前完成，确保内存访问按程序的顺序完成。Linux 内核提供的内存屏障 API 函数说明如下表。内存屏障主要用于多处理器系统，使用 smp_xxx 函数。

指令	作用
`smp_rmb()`	适用于多处理器的读内存屏障。
`smp_wmb()`	适用于多处理器的写内存屏障。
`smp_mb()`	适用于多处理器的内存屏障。

Kernel Module — Char Device Driver

Mon, 29 Mar 2021 12:00:00 +0800

# Kernel Module — Char Device Driver

Goal

上文我们基本了解了什么是内核模块和加载类型，并编写自己的第一个模块。而本文开始介绍 Linux 中内核模块中的字符设备驱动，了解字符设备驱动的特点和编写简单的字符驱动。

什么是字符设备
字符设备的特点，常见的设备有
一个字符设备组成的流程
如何查看并创建一个控制节点

Preconditions

了解 Make
了解 C
了解 Bash 语法
了解上一篇的内容

# What is “Device Driver”

设备驱动指的是操作系统和输入输出设备间的粘合剂，驱动负责将操作系统的请求传输，转化成特定物理设备控制器能够理解的命令。而内核模块就是驱动的载体。Linux 系统内核将设备对象的特征进行了抽象，总结除了以下三种模型：

Char Device Driver：
- 特点：是以字节为单位的 I/O 传输，这种字符流的传输率比较低
- 对象：鼠标，键盘，触摸屏
Block Device Driver：
- 特点：是以块为单位传输，这种的传输率比较高
- 对象：磁盘，闪存
Network Device Driver
- 涉及到网络协议层

# Basic Char Device

# Data Structure

字符设备驱动管理的核心对象是以字符为传输流的设备，在 Linux 内核中，使用了一个 struct cdev 来进行描述其属性

主要数据结构

	struct cdev {
	struct kobject kobj; // 这是用于设备驱动模型管理的结构
	struct module *owner; // 字符设备驱动的内核模块对象指针，包含了模块的详细信息
	const struct file_operations *ops; // 字符设备驱动的函数操作集
	struct list_head list; // 一个 List_head 的链表结构，将所有设备驱动串起来
	dev_t dev; // 字符设备的设备号
	unsigned int count; // 同属一个主设备号的次设备号个数
	} __randomize_layout;

__randomize_layout：随机化重排内存排列，这是一种内核安全保护手段

这里有两个重点理解的的内容

dev_t ：字符设备的设备号（是由主设备和次设备号的组成）

主设备号：用来区分是什么类型的设备
次设备号：用来驱分同一类型内的多个设备

两个对应的宏：

MAJOR ：用来获取主设备号
MINOR ：用来获取次设备号

宏操作

	#define MINORBITS 20 // 主设备和次设备的分界（后 20 为次，其他前面为主）
	#define MINORMASK ((1U << MINORBITS) - 1) // 获取次设备号的掩码

	#define MAJOR(dev) ((unsigned int) ((dev) >> MINORBITS))
	#define MINOR(dev) ((unsigned int) ((dev) & MINORMASK))
	#define MKDEV(ma,mi) (((ma) << MINORBITS) \| (mi)) // 创建设备号的宏

file_operations * ：字符设备驱动的函数操作集
- 这是一个结构体指针，这个结构体中包含了常用的函数操作定义
- 这是内核面向对象的体现，统一了上层的调用接口。而我们可以通过对函数指针指向来实现具体功能

这两个是字符设备驱动最核心部分，因为设备号的分配表示内核是否还有相关的资源。同时我们创建操作节点是也是需要依靠设备号来定位具体的设备，因为多个同类设备时使用统一的设备驱动，而之间主要的区分和定位方式就是利用设备号。而函数操作集则是我们实现具体驱动行为的关键，这部分的实现就要依据具体设备的数据手册来实现。

# Init. Framework

有了基本的数据结构，我们来看字符驱动初始化进行流程：

获取设备号：这是注册驱动的基石
- int alloc_chrdev_region(dev_t *dev, unsigned baseminor, unsigned count, const char *name) (推荐使用这个)
  - dev：分配到的设备号输出到 dev
  - baseminor：请求主设备号范围开始的第一个，也就是最小值
  - count：次设备数目
  - name：驱动名
  - 返回值：0 为成功，负数为失败
- int register_chrdev_region(dev_t from, unsigned count, const char *name)
  - from：手动分配设备号的其实设备号（需要自己查阅，系统没有分配的）
  - count：次设备的数量
  - name：驱动名
  - 返回值：0 为成功，负数为失败
- 以上两个 API 均能分配设备号，前者自动分配，后者需要手动
- 两个都通过调用： __register_chrdev_region 来完成分配

分配字符设备的数据结构：这是驱动的核心内容
- cdev_alloc() ：向内核申请字符驱动的数据结构
  - 如果分配失败，那么整个后续无法进行，因此会释放到之前申请到设备号
- 调用： unregister_chrdev_region(dev,count) 来释放回系统
- cdev_init(struct cdev *cdev, const struct file_operations *fops) ：初始化
  - cdev：字符设备对象的数据
  - fops：对应的操作函数集，这里相当于函数重载的意思
    - fops
      static const struct file_operations demo_fops = // 对应的操作函数集
      {
      .owner = THIS_MODULE,
      .open = demo_open,
      .release = demo_release,
      .read = demo_read,
      .write = demo_write
      };
  - 这个函数将字符设备的数据和函数操作关联起来
- cdev_add(struct cdev *p, dev_t dev, unsigned count) ：将字符设备驱动加到系统中
  - p：字符设备对象的指针
  - dev：设备号
  - count：次设备数量
  - 返回值：0 为整个，负数为失败
  - 失败处理：
    - 如果失败了，后续操作也无法执行，所以需要跳转到释放字符设备对象的数据
    - 调用： cdev_del(cdev * p) 将 cdev 从系统中移除，并 freeing cdev 的数据结构
    - 调用： unregister_chrdev_region(dev,count) 来释放回系统
使用完的释放：遵循栈法则，后进先注销
- 先处理：字符设备对象结构
- 后处理：给字符设备分配的设备号

# Source Code

demo.c

	#include <linux/module.h>
	#include <linux/init.h>
	#include <linux/fs.h>
	#include <linux/cdev.h>
	#include <linux/uaccess.h>

	#define DEMO_NAME "demodriver"
	static unsigned int count =1 ; // 在一个主设备号下，次设备数量统计

	struct demoDriver_cdev
	{
	dev_t dev ; // 字符设备的设备号
	struct cdev *pdev; // 字符设备的数据结构
	/* data 可以自定义数据 */
	} demo_ctx = {
	.dev = 0,
	.pdev = NULL,
	};


	static int demo_open(struct inode * inode,struct file * file)
	{
	// 我们将驱动做成一个设备节点，所以可以用 inode 结构来访问，驱动信息
	int major = MAJOR(inode->i_rdev);
	int minor = MINOR(inode->i_rdev);
	printk(KERN_EMERG"%s: Major Num: %d , Minor Num: %d",__func__,major,minor);
	return 0;
	}
	static int demo_release(struct inode * inode,struct file * file)
	{
	return 0;
	}

	static ssize_t demo_read(struct file * file, char __user *buf, size_t lbuf,\
	loff_t *ppos)
	{
	printk(KERN_EMERG"%s enter",__func__);
	return 0;
	}
	static ssize_t demo_write(struct file * file, const char __user *buf, size_t count,\
	loff_t *f_pos)
	{
	printk(KERN_EMERG"%s enter",__func__);
	return 0;
	}
	static const struct file_operations demo_fops =
	{
	.owner = THIS_MODULE,
	.open = demo_open,
	.release = demo_release,
	.read = demo_read,
	.write = demo_write
	};

	static int __init demo_init(void)
	{
	int ret;
	// 系统自动分配一个主设备号，使用这个接口避免冲突，这里需要 4 个参数 cdev，baseminor ，count ，name
	ret = alloc_chrdev_region(&demo_ctx.dev, 0 ,count,DEMO_NAME);
	if(ret)
	{
	printk(KERN_EMERG"Faild in alloc char device region");
	return ret;
	}
	demo_ctx.pdev = cdev_alloc(); // 申请设备数据结构
	if (!demo_ctx.pdev)
	{
	printk(KERN_EMERG"cdev_alloc faild");
	goto unregister_chrdev;
	}
	cdev_init(demo_ctx.pdev,&demo_fops); // 结构体和操作函数的指针建立联系
	ret = cdev_add(demo_ctx.pdev,demo_ctx.dev,count); // 将设备添加到系统中，传入主设备号和次设备数目
	if(ret)
	{
	printk(KERN_EMERG"cdev_add faild");
	goto cdev_fail;
	}
	printk(KERN_EMERG"success register char device: %s\n",DEMO_NAME);
	printk(KERN_EMERG"Major Num: %d , Minor Num: %d",MAJOR(demo_ctx.dev),MINOR(demo_ctx.dev));

	return 0;
	// 如果在注册驱动过程失败，则使用进行注销
	cdev_fail:
	cdev_del(demo_ctx.pdev);
	unregister_chrdev:
	unregister_chrdev_region(demo_ctx.dev,count); // 卸载掉，释放回系统

	return ret;
	}

	static void __exit demo_exit(void)
	{
	printk("remove Device\n");
	if(demo_ctx.pdev)
	cdev_del(demo_ctx.pdev);
	unregister_chrdev_region(demo_ctx.dev,count);
	}


	module_init(demo_init);
	module_exit(demo_exit);

	// 模块可选信息
	MODULE_LICENSE("GPL");// 许可证声明
	MODULE_AUTHOR("junwide");// 作者声明
	MODULE_DESCRIPTION("This module is a char device");// 模块描述
	MODULE_VERSION("V1.0");// 模块别名
	MODULE_ALIAS("Char Modules");// 模块别名

# Build Code

使用和之前一样的 Build Code 通用模板，不在赘述。

# Usage

命令	解释
`make`	编译 Modules 工程
`sudo make install`	将编译后的 Modules 放进系统目录，建立依赖关系，探测启动 modules
`sudo make boot`	将这个 modules 设置为开机自动加载
`sudo make rboot`	将这个 modules 的开机启动删除
`sudo make clean`	清空这个 modules 编译出来的所有东西

# User Code

用户测试代码，其原理就是打开字符设备，读取操作（实际没有读出内容），这里验证的是是否有跳进响应和函数中，

如果有跳进，可以通过 dmesg 进行查看

test.c

	#include <stdio.h>
	#include <fcntl.h>
	#include <unistd.h>

	#define DEMO_DEV_NAME "/dev/demodriver"

	int main()
	{
	char buffer[64];
	int fd;

	fd = open(DEMO_DEV_NAME, O_RDONLY);
	if (fd < 0) {
	printf("open device %s failded\n", DEMO_DEV_NAME);
	return -1;
	}
	read(fd, buffer, 64);
	close(fd);
	return 0;
	}

# Test

这篇我们讨论的驱动需要总共有 3 个文件

demo.c ：驱动模块代码
Makefiele ：构建代码
Test.c ：测试代码

编译驱动代码和测试代码

命令行提示符

		make # 编译驱动代码
		gcc test.c -o test --static #编译测试代码
		sudo chmod 777 test #赋予文件执行权限

载入驱动并查看分配到的主设备号

命令行提示符

		sudo insmod xx.ko
		#使用任意一种查看设备号
		cat /proc/devices #查看设备号
		dmesg # 查看主设备号

创建操作节点并进行测试

命令行提示符

		$ sudo mknod /dev/demodriver c 238 0 #创建设备节点
		$ sudo ./test
		$ dmesg #查看消息

完成测试退出

命令行提示符

		#退出顺序
		$ sudo rmmod _demoDriver
		$ sudo rm /dev/demodriver
		$ sudo make clean

# Summary

本文主要介绍了字符型驱动的知识相关，以及编写一个字符型驱动的全流程和测试过程

# Appendix

函数操作集的重载编写要注意的是：参数要和以下的统一，

file_fops

	struct file_operations {
	struct module *owner;
	loff_t (llseek) (struct file , loff_t, int);
	ssize_t (read) (struct file , char __user , size_t, loff_t );
	ssize_t (write) (struct file , const char __user , size_t, loff_t );
	ssize_t (read_iter) (struct kiocb , struct iov_iter *);
	ssize_t (write_iter) (struct kiocb , struct iov_iter *);
	int (iopoll)(struct kiocb kiocb, bool spin);
	int (iterate) (struct file , struct dir_context *);
	int (iterate_shared) (struct file , struct dir_context *);
	__poll_t (poll) (struct file , struct poll_table_struct *);
	long (unlocked_ioctl) (struct file , unsigned int, unsigned long);
	long (compat_ioctl) (struct file , unsigned int, unsigned long);
	int (mmap) (struct file , struct vm_area_struct *);
	unsigned long mmap_supported_flags;
	int (open) (struct inode , struct file *);
	int (flush) (struct file , fl_owner_t id);
	int (release) (struct inode , struct file *);
	int (fsync) (struct file , loff_t, loff_t, int datasync);
	int (fasync) (int, struct file , int);
	int (lock) (struct file , int, struct file_lock *);
	ssize_t (sendpage) (struct file , struct page , int, size_t, loff_t , int);
	unsigned long (get_unmapped_area)(struct file , unsigned long, unsigned long, unsigned long, unsigned long);
	int (*check_flags)(int);
	int (setfl)(struct file , unsigned long);
	int (flock) (struct file , int, struct file_lock *);
	ssize_t (splice_write)(struct pipe_inode_info , struct file , loff_t , size_t, unsigned int);
	ssize_t (splice_read)(struct file , loff_t , struct pipe_inode_info , size_t, unsigned int);
	int (setlease)(struct file , long, struct file_lock , void );
	long (fallocate)(struct file file, int mode, loff_t offset,
	loff_t len);
	void (show_fdinfo)(struct seq_file m, struct file *f);
	#ifndef CONFIG_MMU
	unsigned (mmap_capabilities)(struct file );
	#endif
	ssize_t (copy_file_range)(struct file , loff_t, struct file *,
	loff_t, size_t, unsigned int);
	loff_t (remap_file_range)(struct file file_in, loff_t pos_in,
	struct file *file_out, loff_t pos_out,
	loff_t len, unsigned int remap_flags);
	int (fadvise)(struct file , loff_t, loff_t, int);
	} __randomize_layout;

	struct file_operations {
	struct module *owner;
	loff_t (llseek) (struct file , loff_t, int);
	ssize_t (read) (struct file , char __user , size_t, loff_t );
	ssize_t (write) (struct file , const char __user , size_t, loff_t );
	ssize_t (read_iter) (struct kiocb , struct iov_iter *);
	ssize_t (write_iter) (struct kiocb , struct iov_iter *);
	int (iopoll)(struct kiocb kiocb, bool spin);
	int (iterate) (struct file , struct dir_context *);
	int (iterate_shared) (struct file , struct dir_context *);
	__poll_t (poll) (struct file , struct poll_table_struct *);
	long (unlocked_ioctl) (struct file , unsigned int, unsigned long);
	long (compat_ioctl) (struct file , unsigned int, unsigned long);
	int (mmap) (struct file , struct vm_area_struct *);
	unsigned long mmap_supported_flags;
	int (open) (struct inode , struct file *);
	int (flush) (struct file , fl_owner_t id);
	int (release) (struct inode , struct file *);
	int (fsync) (struct file , loff_t, loff_t, int datasync);
	int (fasync) (int, struct file , int);
	int (lock) (struct file , int, struct file_lock *);
	ssize_t (sendpage) (struct file , struct page , int, size_t, loff_t , int);
	unsigned long (get_unmapped_area)(struct file , unsigned long, unsigned long, unsigned long, unsigned long);
	int (*check_flags)(int);
	int (setfl)(struct file , unsigned long);
	int (flock) (struct file , int, struct file_lock *);
	ssize_t (splice_write)(struct pipe_inode_info , struct file , loff_t , size_t, unsigned int);
	ssize_t (splice_read)(struct file , loff_t , struct pipe_inode_info , size_t, unsigned int);
	int (setlease)(struct file , long, struct file_lock , void );
	long (fallocate)(struct file file, int mode, loff_t offset,
	loff_t len);
	void (show_fdinfo)(struct seq_file m, struct file *f);
	#ifndef CONFIG_MMU
	unsigned (mmap_capabilities)(struct file );
	#endif
	ssize_t (copy_file_range)(struct file , loff_t, struct file *,
	loff_t, size_t, unsigned int);
	loff_t (remap_file_range)(struct file file_in, loff_t pos_in,
	struct file *file_out, loff_t pos_out,
	loff_t len, unsigned int remap_flags);
	int (fadvise)(struct file , loff_t, loff_t, int);
	} __randomize_layout;