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)
