向量

在 Taichi 中，向量有两种表述形式：

  • 作为临时局部变量，一个由 n 个标量组成的 n 分量向量。
  • 作为全局张量(global tensor)的构成元素。比如，一个由 n 分量向量组成的N-维数组构成的全局张量。

事实上，向量 是 矩阵 的一个别名， 只不过向量的 m = 1 (m 代指列）。 请参阅 Matrices 和 张量与矩阵 以获得更多信息。

声明向量

全局张量中的向量

ti.Vector.``var(n, dt, shape = None, offset = None)

参数:
  • n – （标量) 向量中的分量数目
  • dt – （数据类型) 分量的数据类型
  • shape – （可选，标量或元组）张量的形状（其中的元素是向量）, 请参阅 张量与矩阵
  • offset – （可选，标量或元组）请参阅 Coordinate offsets

例如, 这里我们创建了一个5x4的张量，张量中的元素都是3维的向量:

  1. # Python 作用域
  2. a = ti.Vector.var(3, dt=ti.f32, shape=(5, 4))

注解

在 Python 作用域中, ti.var 声明 Tensors of scalars, 而 ti.Vector 声明了由向量构成的张量。

临时局部变量向量

ti.``Vector([x, y, …])

参数:
  • x – （标量）向量的第一个分量
  • y – （标量）向量的第二个分量

例如, 我们可以使用 (2, 3, 4)创建一个三维向量:

  1. # Taichi 作用域
  2. a = ti.Vector([2, 3, 4])

访问向量的分量

全局张量中的向量

a[p, q, ...][i]

参数:
  • a – （向量张量）
  • p – （标量) 张量的行索引
  • q – （标量) 张量的列索引
  • i – （标量) 向量内分量的索引

这里提取出了向量 a[6, 3] 的第一个分量:

  1. x = a[6, 3][0]
  3. # 或者
  4. vec = a[6, 3]
  5. x = vec[0]

注解

始终 使用两组方括号来访问张量中向量里的标量元素。

  • 第一组方括号负责定位张量中的向量;
  • 第二组方括号负责定位向量中的标量。

特别的，对0维张量第一组方括号应该使用 [None] 。

临时局部变量向量

a[i]

参数:
  • a – （向量）向量
  • i – 指定访问下标

例如，这里我们提取出了向量 a 的第一个分量:

  1. x = a[0]

同理，将 a 的第二个分量设置为 4:

  1. a[1] = 4

TODO: add descriptions about a(i, j)

相关方法

a.``norm(eps = 0)

参数:
  • a – （向量）
  • eps – （可选，标量） sqrt 的安全保护值，通常为0。详见下面注解。
返回:

（标量）向量的大小、长度、范数

例如:

  1. a = ti.Vector([3, 4])
  2. a.norm() # sqrt(3*3 + 4*4 + 0) = 5

a.norm(eps) 相当于 ti.sqrt(a.dot(a) + eps)

注解

例如可以通过设置 eps = 1e-5 ，对可微编程中零向量上的梯度值计算进行保护。

a.``norm_sqr()

参数:a – （向量）
返回:（标量）向量的大小、长度、范数的平方

例如:

  1. a = ti.Vector([3, 4])
  2. a.norm_sqr() # 3*3 + 4*4 = 25

a.norm_sqr() 相当于 a.dot(a)

a.``normalized()

参数:a – （向量）
返回:（向量）向量 a 的标准化/单位向量

例如:

  1. a = ti.Vector([3, 4])
  2. a.normalized() # [3 / 5, 4 / 5]

a.normalized() 相当于 a / a.norm()。

a.``dot(b)

参数:
  • a – （向量）
  • b – （向量）
返回:

（标量） a 和 b 之间点乘（内积）的结果

例如:

  1. a = ti.Vector([1, 3])
  2. b = ti.Vector([2, 4])
  3. a.dot(b) # 1*2 + 3*4 = 14

a.``cross(b)

参数:
  • a – （向量，2 或 3 分量）
  • b – （向量，和 a 形状一样）
返回:

标量（对于输入是2维向量），或者3维向量（对于输入是3维向量）这是 a 和 b 之间叉乘的结果

我们使用的坐标系统是右手系, 例如:

  1. a = ti.Vector([1, 2, 3])
  2. b = ti.Vector([4, 5, 6])
  3. c = ti.cross(a, b)
  4. # c = [2*6 - 5*3, 4*3 - 1*6, 1*5 - 4*2] = [-3, 6, -3]
  6. p = ti.Vector([1, 2])
  7. q = ti.Vector([4, 5])
  8. r = ti.cross(a, b)
  9. # r = 1*5 - 4*2 = -3

a.``outer_product(b)

参数:
  • a – （向量）
  • b – （向量）
返回:

（矩阵） a 和 b 之间张量积的结果

例如:

  1. a = ti.Vector([1, 2])
  2. b = ti.Vector([4, 5, 6])
  3. c = ti.outer_product(a, b) # 注意: c[i, j] = a[i] * b[j]
  4. # c = [[1*4, 1*5, 1*6], [2*4, 2*5, 2*6]]

注解

与 ti.cross 不同，这里 a 和 b 不再要求必须是2分量或3分量的向量。

a.``cast(dt)

参数:
  • a – （向量）
  • dt – （数据类型）
返回:

（向量）将向量 a 中分量的数据类型转化为类型 dt

例如:

  1. # Taichi 作用域
  2. a = ti.Vector([1.6, 2.3])
  3. a.cast(ti.i32) # [2, 3]

注解

向量是只有一列的特殊矩阵。实际上，ti.Vector 只是 ti.Matrix 的别名。

元数据

a.``n

参数:a – （向量或向量张量）
返回:（标量）返回向量 a 的维度

例如:

  1. # Taichi 作用域
  2. a = ti.Vector([1, 2, 3])
  3. a.n  # 3
  • ::
    # Python-scope a = ti.Vector.var(3, dt=ti.f32, shape=()) a.n # 3

    • TODO: add element wise operations docs