# Frequently Asked Questions

## Can I enable auto compeletion for Taichi?

Yes, Taichi's Python user-facing APIs should work natively with any language server for Python.

Take VSCode as an example, you can install `Python`

or `Pylance`

extensions to get language support like signature help with type information, code completion etc.

If it doesn't work out of box after installing the extension, please make sure the right Python interpreter is selected by:

- invoke command palette (
`Shift + Command + P (Mac) / Ctrl + Shift + P (Windows/Linux)`

) - find
`Python: Select Interpreter`

- make sure you select the path to the Python interpreter you're using with a
`taichi`

package installed

### Why does my `pip`

complain `package not found`

when installing Taichi?

You may have a Python interpreter with an unsupported version. Currently, Taichi only supports Python 3.7/3.8/3.9/3.10 (64-bit) . For more information about installation-specific issues, please check Installation Troubleshooting.

### Does Taichi provide built-in constants such as `ti.pi`

?

There is no built-in constant such as `pi`

. We recommended using `math.pi`

directly.

### Outer-most loops in Taichi kernels are by default parallel. How can I **serialize** one of them?

A solution is to add an additional *ghost* loop with only one iteration outside the loop you want to serialize.

`for _ in range(1): # This "ghost" loop will be "parallelized", but with only one thread. Therefore, the containing loop below is serialized.`

for i in range(100): # The loop you want to serialize

...

### What is the most convenient way to load images into Taichi fields?

One feasible solution is `field.from_numpy(ti.tools.imread('filename.png'))`

.

### Can Taichi interact with **other Python packages** such as `matplotlib`

?

Yes, Taichi supports many popular Python packages. Taichi provides helper functions such as `from_numpy`

and `to_numpy`

to transfer data between Taichi fields and NumPy arrays, so that you can also use your favorite Python packages (e.g., `numpy`

, `pytorch`

, `matplotlib`

) together with Taichi as below:

`import taichi as ti`

pixels = ti.field(ti.f32, (1024, 512))

import numpy as np

arr = np.random.rand(1024, 512)

pixels.from_numpy(arr) # load numpy data into taichi fields

import matplotlib.pyplot as plt

arr = pixels.to_numpy() # store taichi data into numpy arrays

plt.imshow(arr)

plt.show()

import matplotlib.cm as cm

cmap = cm.get_cmap('magma')

gui = ti.GUI('Color map')

while gui.running:

render_pixels()

arr = pixels.to_numpy()

gui.set_image(cmap(arr))

gui.show()

Besides, you can also pass numpy arrays or torch tensors into a Taichi kernel as arguments. See Interacting with external arrays for more details.

### How do I declare a field with a **dynamic length**?

The `dynamic`

SNode supports variable-length fields. It acts similarly to `std::vector`

in C++ or `list`

in Python.

##### tip

An alternative solution is to allocate a large enough `dense`

field, with a corresponding 0-D field
`field_len[None]`

tracking its length. In practice, programs allocating memory using `dynamic`

SNodes may be less efficient than using `dense`

SNodes, due to dynamic data structure
maintenance overheads.

### How do I program on less structured data structures (such as graphs and tetrahedral meshes) in Taichi?

These structures have to be decomposed into 1D Taichi fields. For example, when representing a graph, you can allocate two fields, one for the vertices and the other for the edges. You can then traverse the elements using `for v in vertices`

or `for v in range(n)`

.

### How to install Taichi on a server without Internet access?

Follow these steps to install Taichi on a server without Internet access.

- From a computer with Internet access, pip download Taichi, ensuring that this computer has the same operating system as the target server:

`pip download taichi`

*This command downloads the wheel package of Taichi and all its dependencies.*

- Copy the downloaded
*.whl packages to your local server and install each with the following command. Note that you*must* complete all dependency installation before installing Taichi.

`python -m pip install xxxx.whl`

### Can I integrate Taichi and Houdini?

The answer is an unequivocal Yes! Our contributors managed to embed taichi_elements, a multi-material continuum physics engine, into Houdini as an extension, combining Houdini's flexibility in preprocessing with Taichi's strength in high-performance computation.

You can follow the instructions provided here.

### How do I accurately initialize a vector or matrix with `f64`

precision when my default floating-point precision (`default_fp`

) is `f32`

?

To better understand the question, look at the program below:

`import taichi as ti`

ti.init()

@ti.kernel

def foo():

A = ti.Vector([0.2, 0.0], ti.f64)

print('A =', A)

B = ti.Vector([ti.f64(0.2), 0.0], ti.f64)

print('B =', B)

foo()

You get the following output:

`A = [0.200000002980, 0.000000000000]`

B = [0.200000000000, 0.000000000000]

You may notice the value of `A`

is slightly different from `[0.2, 0]`

. This is because, by default, your float literals are converted to `ti.f32`

, and `0.2`

in `ti.f32`

precision becomes `0.200000002980`

. If you expect `A`

and `B`

to have `ti.f64`

precision, use `ti.f64(0.2)`

to preserve more effective digits here so that `0.2`

keeps its `ti.f64`

type.

Alternatively, if you can afford having all floating-point operations in `f64`

precision, you can directly initialize Taichi with `ti.init(..., default_fp=ti.f64)`

.

### Why does it always return an error when I pass a list from the Python scope to a Taichi kernel?

A Taichi kernel **cannot** take a Python list directly. You need to use NumPy arrays as a bridge.

For example, the following code snippet does not work:

`import taichi as ti`

import numpy as np

ti.init()

x = ti.field(ti.i32, shape=3)

array = [10, 20, 30]

@ti.kernel

def test(arr: list):

for i in range(3):

x[i] = arr[i]

test(array)

You need to import NumPy:

`import taichi as ti`

import numpy as np

ti.init(arch=ti.cpu)

x = ti.field(ti.i32, shape=3)

array = np.array([10, 20, 30])

@ti.kernel

def test(arr: ti.types.ndarray()):

for i in range(3):

x[i] = arr[i]

test(array)