给自学游戏和图形开发者的数学符号指南

之前补数学知识的时候,看到数学符号就头大,前几天在 Github 上发现了这篇文章,尝试翻译了一下,现在全文贴到这里。

由于原文会持续更新,可以到我的 github 上 watch 这个项目,我会随原文进行更新。

https://github.com/nshen/math-as-code/blob/master/README-zh.md

正文:

math-as-code

译注:译者英文与数学水平都非常有限,尝试翻译,如有错误请指正。英文原版 在此。

这是一份通过对比数学符号和 JavaScript 代码来帮助开发者更容易了解数学符号的参考。

动机:学术论文可能会吓着自学游戏和图形的程序猿:)

这个指南还没有完成。如果你发现错误或者想要贡献,请open a ticket或发一个 PR。

注意: 简洁起见,有些代码示例使用了npm 包。你可以到他们的 GitHub repos 来查看实现的详细情况。

前言

数学符号可以表示不同的意思,这取决于作者,上下文和所学习的领域(线性代数,集合理论,等等)。这份指南也许不会涵盖符号的所有用法。在某些情况,会引用一些真实材料(博客文章,出版物等等)来演示某个符号的实际用法。

更完整的列表,请看Wikipedia - List of Mathematical Symbols

简单起见,这里许多的代码示例都操作浮点数值,并不是数字健壮的(numerically robust)。为什么这会是一个问题的更多细节请看Robust Arithmetic Notes 作者是 Mikola Lysenko。

目录

变量名约定

有很多命名约定取决于上下文和所学领域,他们并不太一致。然而在一些文献中你会发现变量名遵循一些模式,例如:

  • s - 斜体小写字母用做标量 (例如一个数字)
  • x - 粗体小写字母用做向量 (例如一个 2D 点)
  • A - 粗体大写字母用做矩阵 (例如一个 3D 变换)
  • θ - 斜体小写希腊字母用做常量和特殊变量 (例如 欧拉角 θ, theta)

本指南也基于这个格式。

等号

有很多符号很像等号 = 。这里有些常见的例子:

  • = 表示相等 (值相同)
  • 表示不相等 (值不同)
  • 表示约等于 (π ≈ 3.14159
  • := 表示定义 (A 被定义为 B)

在 JavaScript 中:

js

// 相等
2 === 3;
 
// 不相等
2 !== 3;
 
// 约等于
almostEqual(Math.PI, 3.14159, 1e-5);
 
function almostEqual(a, b, epsilon) {
  return Math.abs(a - b) <= epsilon;
}

你也许看过 :==:= 符号用来表示 定义1

例如,下边定义 x 为 2kj 的别名。

equals1

在 JavaScript 中,我们用 var定义 变量和提供别名:

js

var x = 2 * k * j;

然而,这里的 x 值是可变的,仅是当时的一个快照。在某些有预处理器语言中的 #define 语句才比较接近于数学中的 定义

在 JavaScript (ES6) 中,更精确的 定义 ,应该有点类似这样:

js

const f = (k, j) => 2 * k * j;

与此不同的是,下边这句表示的是相等:

equals2

上边的等式也可以解释为一个 断言:

js

console.assert(x === 2 * k * j);

平方根与复数

一个平方根运算是这种形式:

squareroot

在编程语言中我们使用 sqrt 函数, 像这样:

js

var x = 9;
console.log(Math.sqrt(x));
//=> 3

复数是 complex 形式的表达式, 其中 a 是实数部分, b 是虚数部分。 虚数 i 的定义为:

imaginary.

JavaScript 没有内置复数的功能,但有一些库支持复数算法。例如, mathjs:

js

var math = require("mathjs");
 
var a = math.complex(3, -1);
//=> { re: 3, im: -1 }
 
var b = math.sqrt(-1);
//=> { re: 0, im: -1 }
 
console.log(math.multiply(a, b).toString());
//=> '1 + 3i'

这个库还支持字符串表达式求值, 所以上边的可以写为:

js

console.log(math.eval("(3 - i) * i").toString());
//=> '1 + 3i'

其他实现:

点 & 叉

· 和叉 × 符号根据上下文的不同有不同的用法。

他们可能看上去很明显,但在进入下一部分之前,理解他们之间微妙的不同是非常重要的。

标量乘法

两个符号都可以表示简单的标量之间的乘法。下边的写法意思相同:

dotcross1

在编程语言中,我们倾向用星号表示相乘:

js

var result = 5 * 4;

通常,使用乘法符号只是为了避免意义模糊(例如两个数字之间的)。这里,我们可以完全省略:

dotcross2

如果这些变量表示的是标量,则代码应该这样写:

js

var result = 3 * k * j;

向量乘法

表示向量和标量之间相乘,或两向量的逐元素相乘(element-wise multiplication),我们不用点 · 或叉 × 符号。 这些符号在线性代数中有不同的意思,后边讨论。

让我们用之前的例子,但用在向量上。对于向量的逐元素相乘(element-wise vector multiplication)来说,你可能会看到用一个空心点来表示 Hadamard product2

dotcross3

某些时候,作者可能会显式定义一个不同的符号,例如圆中点 或实心圈 3

这是对应的代码,使用数组 [x, y] 来表示 2D 向量。

js

var s = 3;
var k = [1, 2];
var j = [2, 3];
 
var tmp = multiply(k, j);
var result = multiplyScalar(tmp, s);
//=> [ 6, 18 ]

multiplymultiplyScalar 函数应该这样:

js

function multiply(a, b) {
  return [a[0] * b[0], a[1] * b[1]];
}
 
function multiplyScalar(a, scalar) {
  return [a[0] * scalar, a[1] * scalar];
}

同样的,矩阵相乘也不用 ·× 符号。 矩阵乘法会在后边章节提到.

点乘

点符号 · 可用来表示两向量之间的 点乘 。 由于其值是一个标量,通常被叫做 标量积(scalar product)

dotcross4

这在线性代数和 3D 向量中是非常常见的,代码类似这样:

js

var k = [0, 1, 0];
var j = [1, 0, 0];
 
var d = dot(k, j);
//=> 0

结果为 0 告诉我们两向量互相垂直. 这是 3 元素向量的 点乘 函数:

js

function dot(a, b) {
  return a[0] * b[0] + a[1] * b[1] + a[2] * b[2];
}

叉乘

叉乘符号 × 可以用来表示两向量的 叉乘

dotcross5

在代码中,应该是这样:

js

var k = [0, 1, 0];
var j = [1, 0, 0];
 
var result = cross(k, j);
//=> [ 0, 0, -1 ]

这里得到结果为 [ 0, 0, -1 ],这个向量同时垂直于 kj

我们的叉乘 cross 函数:

js

function cross(a, b) {
  var ax = a[0],
    ay = a[1],
    az = a[2],
    bx = b[0],
    by = b[1],
    bz = b[2];
 
  var rx = ay * bz - az * by;
  var ry = az * bx - ax * bz;
  var rz = ax * by - ay * bx;
  return [rx, ry, rz];
}

向量乘法,叉乘,点乘的其他实现:

西格玛(sigma)

大写希腊字母 Σ (Sigma) 用来表示 总和 Summation。 换句话说就是对一些数字求和。

sigma

这里, i=1 是说从 1 西格玛上边的数字100为止。这些分别为上下边界。 "E" 右边的 i 告诉我们求和的是什么。代码:

js

var sum = 0;
for (var i = 1; i <= 100; i++) {
  sum += i;
}

sum 的结果为 5050

提示: 对于整数,这个特殊形式可以优化为:

js

var n = 100; // 上边界
var sum = (n * (n + 1)) / 2;

这里有另一个例子,这里的 i ,或 “想要求和的东西” 是不同的:

sum2

代码:

js

var sum = 0;
for (var i = 1; i <= 100; i++) {
  sum += 2 * i + 1;
}

sum 的结果为 10200

这个符号可被嵌套,非常像嵌套一个 for 循环。 你应该先求和最右边的西格玛, 除非作者加入括号改变了顺序。然而下边的例子,由于我们处理有限的和,顺序就不重要了。

sigma3

代码:

js

var sum = 0;
for (var i = 1; i <= 2; i++) {
  for (var j = 4; j <= 6; j++) {
    sum += 3 * i * j;
  }
}

这里,sum 值为 135

大写 Pi

大写 Pi 或 “大 Pi” 与 西格玛 非常接近, 不同的是我们用乘法取得一系列数字的乘积。

看下边:

capitalPi

代码应该类似这样:

js

var value = 1;
for (var i = 1; i <= 6; i++) {
  value *= i;
}

value 结果应得到 720

管道(pipes)

管道符号,就是 竖线(bars),根据上下文不同,可以表示不同意思。下边的是 3 种常见用途 绝对值, 欧几里得模, 和 行列式

这 3 种特性都是描述对象的 长度(length)

绝对值

pipes1

对于数字 x, |x| 表示 x 的绝对值。代码为:

js

var x = -5;
var result = Math.abs(x);
// => 5

欧几里得模(Euclidean norm)

pipes4

对于向量 v‖v‖v欧几里得模(Euclidean norm) 。也叫做向量的 "量级(magnitude)" 或 "长度(length)" 。

通常用双竖线表示来避免与绝对值 符号混淆,但有些时候也会看见单竖线。

pipes2

这里的例子用数组 [x, y, z] 来表示一个 3D 向量。

js

var v = [0, 4, -3];
length(v);
//=> 5

length 函数:

js

function length(vec) {
  var x = vec[0];
  var y = vec[1];
  var z = vec[2];
  return Math.sqrt(x * x + y * y + z * z);
}

其他实现:

行列式

pipes3

对于一个矩阵 A|A| 表示矩阵 A行列式(determinant)

这是一个计算 2x2 矩阵行列式的例子,矩阵用一个 column-major 格式的扁平数数组表示。

js

var determinant = require("gl-mat2/determinant");
 
var matrix = [1, 0, 0, 1];
var det = determinant(matrix);
//=> 1

实现:

帽子

在几何里,字母上的 “帽子” 符号用来表示一个单位向量。例如,这是向量 a 的单位向量。

hat

在笛卡尔空间中,单位向量的长度为 1。意思是向量的每个部分都在 -1.0 到 1.0 之间。这里我们 归一化(normalize) 一个 3D 向量为单位向量。

js

var a = [0, 4, -3];
normalize(a);
//=> [ 0, 0.8, -0.6 ]

这是 归一化(normalize) 函数,接收一个 3D 向量参数:

js

function normalize(vec) {
  var x = vec[0];
  var y = vec[1];
  var z = vec[2];
  var squaredLength = x * x + y * y + z * z;
 
  if (squaredLength > 0) {
    var length = Math.sqrt(squaredLength);
    vec[0] = vec[0] / length;
    vec[1] = vec[1] / length;
    vec[2] = vec[2] / length;
  }
  return vec;
}

其他实现:

属于

集合理论中,“属于”符号 可以被用来描述某物是否为集合中的一个元素。例如:

element1

这里我们有一个数字集 A { 3, 9, 14 } 而且我们说 3 是“属于”这个集合的。

在 ES5 种一个简单的实现应该这样:

js

var A = [3, 9, 14];
 
A.indexOf(3) >= 0;
//=> true

然而,可以用只能保存唯一值的Set,这样更精确。这是 ES6 的一个特性。

js

var A = new Set([3, 9, 14]);
 
A.has(3);
//=> true

反向的 意义相同,只是顺序改变:

element2

你可以使用 "不属于" 符号 像这样:

element3

常见数字集

你可能在一些公式中看见一些大黑板粗体字。他们一般是用来描述集合的。

例如,我们可以描述 k属于 集的一个元素。

real

下边列出一些常见集和他们的符号。

实数(real numbers)

描述 实数(real numbers) 的集合。他们包括整数,有理数,无理数。

JavaScript 认为整数和浮点数为相同类型,所以下边将是一个 k ∈ ℝ 的简单测试:

js

function isReal(k) {
  return typeof k === "number" && isFinite(k);
}

注意: 实数也是 有限数(finite)非无限的(not infinite)

有理数(rational numbers)

有理数是可以被表示为分数,或 比率(类似)的实数。有理数不能以 0 作分母。

这意味着所有的整数都是有理数,因为可以看成分母为 1。

换句话说无理数就是不能表示为比率的数,例如 π (PI)。

整数(integers)

一个整数,是没有小数部分的实数。可为正也可以为负。

在 JavaScript 中的简单测试应该这样:

js

function isInteger(n) {
  return typeof n === "number" && n % 1 === 0;
}

自然数(natural numbers)

自然数是正整数或非负整数。取决于所学领域和上下文,集合中可能包含也可能不包含 0,所以可以是下边任意一种集合。

js

{ 0, 1, 2, 3, ... }
{ 1, 2, 3, 4, ... }

前者在计算机科学中更常见,例如:

js

function isNaturalNumber(n) {
  return isInteger(n) && n >= 0;
}

复数

复数是实数域虚数的组合,被视为 2D 平面上的一个坐标。更详细的信息请看A Visual, Intuitive Guide to Imaginary Numbers

函数

函数 是数学的基本特性,其概念很容易转换成代码。

函数把输入输出值联系起来。例如下边是一个函数:

function1

我们可以给函数一个 名字 。一般来说我们用 ƒ 来描述一个函数,但也可以命名为 A(x) 或其他什么。

function2

在代码中,我们可以给函数命名为 square 写出来应该类似这样:

js

function square(x) {
  return Math.pow(x, 2);
}

有时函数没有名字,而是直接写出输出值。

function3

在上边的例子中,x 是输入值,y 是输出值,他们是平方的关系。

像编程语言一样,函数也可以有多个参数。他们在数学中被称为 arguments,并且函数接受的参数数量被称为函数的 arity

function4

代码:

js

function length(x, y) {
  return Math.sqrt(x * x + y * y);
}

分段函数

有些函数根据输入值 x 的不同会有不同的关系。

下边的函数 f 根据不同的输入值选择两个不同的“子函数”。

piecewise1

abc def

这非常接近于代码中的if / else。右边的条件经常被写为**"for x < 0"** 或 "if x = 0"。如果条件为 true,就使用其左边的函数。

在分段函数中,"otherwise""elsewhere" 类似于代码中的 else

js

function f(x) {
  if (x >= 1) {
    return (Math.pow(x, 2) - x) / x;
  } else {
    return 0;
  }
}

通用函数

有些函数名在数学中是普遍存在的。在一个程序员的角度看,这些应该类似于编程语言中的“内置”函数(就像 JavaScript 中的 parseInt )。

一个例子就是 sgn 函数。这是 正负号 函数,或者叫 符号 函数。让我们用分段函数来描述它:

sgn

代码中,应该这样:

js

function sgn(x) {
  if (x < 0) return -1;
  if (x > 0) return 1;
  return 0;
}

此函数作为独立的 module 在这里signum

其他类似函数的例子还有: sincostan

函数符号

在某些著作中,函数可以被更明确的符号定义。例如,让我们回到之前提到的 square 函数。

function2

也可以写为以下形式:

mapsto

带尾巴的箭头通常意思为“映射到”,如,将 x 映射到 x2

有时,不是很常见,这个符号也用来描述函数的 domaincodomain。对 ƒ 更正式的定义可以写为:

funcnot

函数的 domaincodomain 分别跟他的 inputoutput 类型有点像。这里有另一个例子,使用了我们之前输出整数的 sgn 函数。

domain2

这里的箭头(没有尾巴)用来映射一个 集合 到另一个。

在 JavaScript 和其他动态类型语言中,你也许会用文档 和/或 运行时检查来解释和验证函数的输入/输出。例子:

js

/**
 * Squares a number.
 * @param  {Number} a real number
 * @return {Number} a real number
 */
function square(a) {
  if (typeof a !== "number") {
    throw new TypeError("expected a number");
  }
  return Math.pow(a, 2);
}

有些工具例如flowtype尝试将静态类型带入到 JavaScript 中。

其他语言,例如 Java,允许真正的方法重载(overloading),它们基于函数输入输出的静态类型。这更接近于数学领域:使用不同 domain 的两个函数是不同的。

撇号(prime)

撇号 () 通常用在变量名上,用来描述某物很类似,而不用另起个名来描述它。也可以描述经过一些变换后的“下一个值”。

例如,如果我们有一个 2D 点 (x, y) ,然后旋转它,你会把旋转后的点命名为*(x′, y′)*。 或者将矩阵 M转置矩阵 命名为 M′

在代码中,我们通常的分配一个描述更详细的变量名,例如transformedPosition

作为数学函数,撇号通常描述为函数的 衍生(derivative) 函数。衍生物会在未来的章节解释。我们来看一个之前的函数:

function2

它的衍生物函数(derivative)可以写为一个带撇号的函数:

prime1

代码:

js

function f(x) {
  return Math.pow(x, 2);
}
 
function fPrime(x) {
  return 2 * x;
}

多个撇号可以用来表示第二个衍生函数(derivative) ƒ′′ 或 第三个衍生函数(derivative)ƒ′′′ ,之后更高的数字,一般作者会用罗马数字 ƒIV 或上标数字 ƒ(n) 表示。

向下取整和向上取整(floor & ceiling)

⌊x⌋⌈x⌉ 这种特殊的括号分别用来表示floorceil 函数。

floor

ceil

代码:

js

Math.floor(x);
Math.ceil(x);

当这两个符号混合⌊x⌉,它通常表示一个取整到最近的整数的函数。

round

代码:

js

Math.round(x);

箭头

箭头通常用来表示函数符号。这里还有一些在其他领域中的用法可以看看。

实质蕴含(material implication)

优势被用作表示实质蕴涵(material implication)的逻辑。意思是如果 A 是 true,那么 B 也是 true。

material1

解释为代码应该为:

js

if (A === true) {
  console.assert(B === true);
}

箭头可以是左右任何方向 ,也可以双向。当 A ⇒ B 并且 B ⇒ A,就是他们是相等的:

material-equiv

等式(equality)

在数学中, < > 与代码中的使用方法一样:分别为 小于, 大于, 小于等于大于等于

js

50 > 2 === true;
2 < 10 === true;
3 <= 4 === true;
4 >= 4 === true;

偶尔会看到在这些符号上加了一条斜线,来表示 ,比如, k 不 "大于" j.

ngt

通常用来表示 明显(significant) 不相等。这是说 k 是有数量级(order of magnitude)的大于 j

orderofmag

在数学中,数量级(order of magnitude) 是相当明确的;不只是“相当大的不同”而已。上边的一个简单例子:

js

orderOfMagnitude(k) > orderOfMagnitude(j);

下边是我们的 orderOfMagnitude 函数,使用了Math.trunc (ES6)。

js

function log10(n) {
  // logarithm in base 10
  return Math.log(n) / Math.LN10;
}
 
function orderOfMagnitude(n) {
  return Math.trunc(log10(n));
}
Note: This is not numerically robust.

这里是在 ES5 下使用math-trunc 的 polyfill。

与(conjunction) & 或(disjunction)

另一种箭头在逻辑中的使用是与(conjunction) 和 或(disjunction) 。他们分别类似于程序员的 ANDOR操作。

下边展示了与(conjunction), 逻辑中的AND.

and

在 JavaScript 中,我们使用 && 假设 k 是一个自然数,那么这个逻辑意味着 k 等于 3:

js

if (k > 2 && k < 4) {
  console.assert(k === 3);
}

由于双边都相等 ,所以也说明下边成立:

js

if (k === 3) {
  console.assert(k > 2 && k < 4);
}

下箭头 是逻辑或(disjunction),就像 OR 操作符一样。

logic-or

代码:

js

A || B;

逻辑非(logical negation)

有时候,¬, ~! 符号都用来表示逻辑 NOT。例如,只有在 A 为 false 的时候,¬A 为 true。

这里是一个使用 not 符号简单的例子:

negation

翻译成代码的例子:

js

if (x !== y) {
  console.assert(!(x === y));
}

注意: 根据上下文的不同,波浪线 ~ 可以有很多种不同的意思。例如,行等价(row equivalence)(矩阵理论)或相同数量级(same order of magnitude) (在等式(equality)章节讨论过)。

区间(intervals)

有时函数会处理被一些值限定范围的实数,这样的约束可以用*区间(interval)*来表示。

例如我们可以表示 0 和 1 之间的数,让他们包含或不包含 0 和 1:

  • 不包含 0 或 1: interval-opened-left-opened-right
  • 包含 0 但不包含 1: interval-closed-left-opened-right
  • 不包含 0 但包含 1: interval-opened-left-closed-right
  • 包含 0 和 1: interval-closed-left-closed-right

例如我们指出一个点 x 在 3D 单位立方体中,我们可以说:

interval-unit-cube

在代码中我们可以用两个元素大小的一维数组表示区间:

js

var nextafter = require("nextafter");
 
var a = [nextafter(0, Infinity), nextafter(1, -Infinity)]; // 开区间
var b = [nextafter(0, Infinity), 1]; // 左闭右开区间
var c = [0, nextafter(1, -Infinity)]; // 左开右闭区间
var d = [0, 1]; // 闭区间

区间与集合运算结合符使用:

  • 交集(intersection) e.g. interval-intersection
  • 并集(union) e.g. interval-union
  • 差集(difference) e.g. interval-difference-1 还有 interval-difference-2

代码:

js

var Interval = require("interval-arithmetic");
var nexafter = require("nextafter");
 
var a = Interval(3, nexafter(5, -Infinity));
var b = Interval(4, 6);
 
Interval.intersection(a, b);
// {lo: 4, hi: 4.999999999999999}
 
Interval.union(a, b);
// {lo: 3, hi: 6}
 
Interval.difference(a, b);
// {lo: 3, hi: 3.9999999999999996}
 
Interval.difference(b, a);
// {lo: 5, hi: 6}

见:

更多...

喜欢这份指南?提出更多的特性的建议或给我们发 Pull Request!

贡献

关于怎样贡献详见 CONTRIBUTING.md

License

MIT, 详见 LICENSE.md