def func(): print(ti.cast(1234.5, dt))
def one(dt, n): import taichi as ti return ti.Matrix([[ti.cast(1, dt) for _ in range(n)] for _ in range(n)])
def identity(dt, n): import taichi as ti return ti.Matrix([[ti.cast(int(i == j), dt) for j in range(n)] for i in range(n)])
def fill_field(dst: ti.template()): for I in ti.grouped(dst): dst[I] = ti.cast(0.7, dtype)
def fill_const(dst: ti.template()): for i in x: dst[i] = ti.cast(0.7, dtype)
def post_process_udf(self, bit_pic: ti.template(), n: ti.i32, coff: ti.f32, offset: ti.f32): for i, j in self.output_pic: self.output_pic[i, j] = vec3( ti.cast(ti.sqrt(bit_pic[n, i, j][2]) * coff + offset, ti.u32))
def splat(t: ti.i32): for i in range(n_particles): pos = ti.cast(x[t, i] * visualize_resolution, ti.i32) screen[pos[0], pos[1]][0] += 0.1
def sample_max(x, p): p = clamp(p) p_grid = p * inv_dx - stagger I = ti.cast(ti.floor(p_grid), ti.f32) return max(x[I], x[I + vec(1, 0)], x[I + vec(0, 1)], x[I + vec(1, 1)])
def run_cast_i32(): x[0] = ti.cast(a[0], ti.i32) x[1] = ti.cast(b[0], ti.i32)
def voxelize_triangles(self, num_triangles: ti.i32, triangles: ti.ext_arr()): for i in range(num_triangles): jitter_scale = ti.cast(0, self.precision) if ti.static(self.precision is ti.f32): jitter_scale = 1e-4 else: jitter_scale = 1e-8 # We jitter the vertices to prevent voxel samples from lying precicely at triangle edges jitter = ti.Vector([ -0.057616723909439505, -0.25608986292614977, 0.06716309129743714 ]) * jitter_scale a = ti.Vector([triangles[i, 0], triangles[i, 1], triangles[i, 2] ]) + jitter b = ti.Vector([triangles[i, 3], triangles[i, 4], triangles[i, 5] ]) + jitter c = ti.Vector([triangles[i, 6], triangles[i, 7], triangles[i, 8] ]) + jitter bound_min = ti.Vector.zero(self.precision, 3) bound_max = ti.Vector.zero(self.precision, 3) for k in ti.static(range(3)): bound_min[k] = min(a[k], b[k], c[k]) bound_max[k] = max(a[k], b[k], c[k]) p_min = int(ti.floor(bound_min[0] * self.inv_dx)) p_max = int(ti.floor(bound_max[0] * self.inv_dx)) + 1 p_min = max(self.padding, p_min) p_max = min(self.res[0] - self.padding, p_max) q_min = int(ti.floor(bound_min[1] * self.inv_dx)) q_max = int(ti.floor(bound_max[1] * self.inv_dx)) + 1 q_min = max(self.padding, q_min) q_max = min(self.res[1] - self.padding, q_max) normal = ((b - a).cross(c - a)).normalized() if abs(normal[2]) < 1e-10: continue a_proj = ti.Vector([a[0], a[1]]) b_proj = ti.Vector([b[0], b[1]]) c_proj = ti.Vector([c[0], c[1]]) for p in range(p_min, p_max): for q in range(q_min, q_max): pos2d = ti.Vector([(p + 0.5) * self.dx, (q + 0.5) * self.dx]) if inside_ccw(pos2d, a_proj, b_proj, c_proj) or inside_ccw( pos2d, a_proj, c_proj, b_proj): base_voxel = ti.Vector([pos2d[0], pos2d[1], 0]) height = int(-normal.dot(base_voxel - a) / normal[2] * self.inv_dx + 0.5) height = min(height, self.res[1] - self.padding) inc = 0 if normal[2] > 0: inc = 1 else: inc = -1 self.fill(p, q, height, inc)
def set_f64(v: ti.f64): y[None] = ti.cast(v, ti.f32)
def add_particle2D(self, x, y, material): self._add_particle2D(ti.cast(x, ti.f32), ti.cast(y, ti.f32), material) self.n_particles += 1
def cook_image_type(x): x = ti.cast(x, ti.f32) return x
def unit(n, i, dt=None): import taichi as ti if dt is None: dt = int assert 0 <= i < n return Matrix([ti.cast(int(j == i), dt) for j in range(n)])
def func() -> ti.f16: a = ti.cast(23.0, ti.f64) b = ti.cast(4.0, ti.f64) return ti.cast(a * b, ti.f16)
def run_cast_u32(): y[0] = ti.cast(a[0], ti.u32) y[1] = ti.cast(b[0], ti.u32)
def compute_mean_of_boundary_edges() -> ti.i32: total = 0.0 for i in range(n): total += x[i] + x[i] * x[i] result = total / ti.cast(n, ti.i32) return result
def run_cast_int(): x[0] = ti.cast(a[None], ti.i32) x[1] = ti.cast(b[None], ti.i32)
def __ti_float__(self): import taichi as ti return ti.cast(self, ti.get_runtime().default_fp)
def run_cast_uint(): y[0] = ti.cast(a[None], ti.u32) y[1] = ti.cast(b[None], ti.u32)
def __ti_float__(self): import taichi as ti _taichi_skip_traceback = 1 return ti.cast(self, float)
def func(): z[None] = ti.cast(1e13, ti.f64) / ti.cast(1e10, ti.f64) + 1e-3
def fill_array(dst: ti.any_arr()): for i in dst: dst[i] = ti.cast(0.7, dtype)
def func(x: int, y: int) -> float: return ti.cast(x, float) * float(y)
def zero(dt, n, m=1): import taichi as ti return ti.Matrix([[ti.cast(0, dt) for _ in range(m)] for _ in range(n)])
def func(x: float, y: float) -> int: return ti.cast(x, int) * int(y)
def unit(n, i, dt=None): import taichi as ti if dt is None: dt = ti.get_runtime().default_ip assert 0 <= i < n return ti.Matrix([ti.cast(int(j == i), dt) for j in range(n)])
def func(): z[None] = ti.cast(1e9, ti.f32) / ti.cast(1e6, ti.f32) + 1e-3
def tensor_to_image(tensor: template(), arr: ext_arr()): for I in ti.grouped(tensor): t = ti.cast(tensor[I], ti.f32) arr[I, 0] = t arr[I, 1] = t arr[I, 2] = t
def f_eq(self, i, j, k): eu = ti.cast(self.e[k, 0], ti.f32) * self.vel[i, j][0] + ti.cast( self.e[k, 1], ti.f32) * self.vel[i, j][1] uv = self.vel[i, j][0]**2.0 + self.vel[i, j][1]**2.0 return self.w[k] * self.rho[i, j] * (1.0 + 3.0 * eu + 4.5 * eu**2 - 1.5 * uv)