面向数据对象式编程

Taichi是一种 面向数据的 编程(DOP)语言。 但是，单纯的DOP会使模块化变得困难。

为了允许代码模块化，Taichi从面向对象编程(OOP)中借鉴了一些概念。

为了方便起见，我们将称此混合方案为 面向数据对象式编程 (ODOP)。

待办事项：此处应有更多文档。

一个简单的例子：

  1. import taichi as ti
  3. ti.init()
  5. @ti.data_oriented
  6. class Array2D:
  7.   def __init__(self, n, m, increment):
  8.     self.n = n
  9.     self.m = m
  10.     self.val = ti.var(ti.f32)
  11.     self.total = ti.var(ti.f32)
  12.     self.increment = increment
  13.     ti.root.dense(ti.ij, (self.n, self.m)).place(self.val)
  14.     ti.root.place(self.total)
  16.   @staticmethod
  17.   @ti.func
  18.   def clamp(x):  # Clamp to [0, 1)
  19.       return max(0, min(1 - 1e-6, x))
  21.   @ti.kernel
  22.   def inc(self):
  23.     for i, j in self.val:
  24.       ti.atomic_add(self.val[i, j], self.increment)
  26.   @ti.kernel
  27.   def inc2(self, increment: ti.i32):
  28.     for i, j in self.val:
  29.       ti.atomic_add(self.val[i, j], increment)
  31.   @ti.kernel
  32.   def reduce(self):
  33.     for i, j in self.val:
  34.       ti.atomic_add(self.total, self.val[i, j] * 4)
  36. arr = Array2D(128, 128, 3)
  38. double_total = ti.var(ti.f32, shape=())
  40. ti.root.lazy_grad()
  42. arr.inc()
  43. arr.inc.grad()
  44. assert arr.val[3, 4] == 3
  45. arr.inc2(4)
  46. assert arr.val[3, 4] == 7
  48. with ti.Tape(loss=arr.total):
  49.   arr.reduce()
  51. for i in range(arr.n):
  52.   for j in range(arr.m):
  53.     assert arr.val.grad[i, j] == 4
  55. @ti.kernel
  56. def double():
  57.   double_total[None] = 2 * arr.total
  59. with ti.Tape(loss=double_total):
  60.   arr.reduce()
  61.   double()
  63. for i in range(arr.n):
  64.   for j in range(arr.m):
  65.     assert arr.val.grad[i, j] == 8