[Doc] Update math module

docs/lang/articles/math/math.md → docs/lang/articles/math/math_module.md

@@ -7,16 +7,14 @@ sidebar_position: 1
 
 Taichi provides a built-in `math` module that supports frequently used mathematical functions and utility functions, including:
 
-+ Commonly-used mathematical functions that are analogous to those in Python's built-in `math` module.
-+ Small vector and matrix types that are analogous to those in the [OpenGL shading language](https://www.khronos.org/opengl/wiki/OpenGL_Shading_Language)(GLSL).
-+ Some GLSL-standard functions.
-+ Complex number operations of 2D vectors.
-
-
+- Commonly-used mathematical functions that are analogous to those in Python's built-in `math` module.
+- Small vector and matrix types that are analogous to those in the [OpenGL shading language](https://www.khronos.org/opengl/wiki/OpenGL_Shading_Language) (GLSL).
+- Some GLSL-standard functions.
+- Complex number operations in the form of 2D vectors.
 
 ## Mathematical functions
 
-Taichi's `math` module has a large overlap with Python's built-in `math` module. You need to call the functions in the Taichi scope. For example:
+You must call the mathematical functions provided by Taichi's `math` module from within the Taichi scope. For example:
 
 ```python
 import taichi as ti
@@ -33,7 +31,7 @@ def test():
     ...
 ```
 
-These functions also accept vectors and matrices as arguments, and they apply to them element-wise:
+These functions also take vectors and matrices as arguments and operate on them element-wise:
 
 ```python
 @ti.kernel
@@ -49,34 +47,33 @@ def test():
 
 :::note
 
-Difference between Taichi's math module and Python's built-in math module:
+Taichi's math module overlaps to a large extent with Python's built-in math module. Ensure that you follow a few extra rules when using Taichi's math module:
 
-- Functions in Taichi's math module must be called from within the Taichi scope.
-- Functions in Taichi's math module also accept vectors/matrices as arguments.
-- The precision of a function in Taichi's math module depends on the value of `default_fp` and backend specified in the `ti.init()` method call.
+- You must call the functions provided by Taichi's math module from within the Taichi scope.
+- Functions in Taichi's math module also take vectors or matrices as arguments.
+- The precision of a function in Taichi's math module depends on the settings of `default_fp` and `arch` (backend) in `ti.init()`.
 
 :::
 
 ## Small vector and matrix types
 
-Taichi's math module supplies a few small vector and matrix types:
+Taichi's math module provides a few small vector and matrix types:
 
 
-+ `vec2/vec3/vec4` for 2D/3D/4D floating-point vector types.
-+ `ivec2/ivec3/ivec4` for 2D/3D/4D integer vector types.
-+ `uvec2/uvec3/uvec4` for 2D/3D/4D unsigned integer vector types.
-+ `mat2/mat3/mat4` for 2D/3D/4D floating-point square matrix types.
+- `vec2/vec3/vec4`: 2D/3D/4D floating-point vector types.
+- `ivec2/ivec3/ivec4`: 2D/3D/4D integer vector types.
+- `uvec2/uvec3/uvec4`: 2D/3D/4D unsigned integer vector types.
+- `mat2/mat3/mat4`: 2D/3D/4D floating-point square matrix types.
 
-
-These vector/matrix types are created with the two template functions `ti.types.vector()` and `ti.types.matrix()`. For example, `vec2` is defined in the following way:
+To create one of the vector/matrix types above, use template function `ti.types.vector()` or `ti.types.matrix()`. For example, `vec2` is defined as follows:
 
 ```python
 vec2 = ti.types.vector(2, float)
 ```
 
-The number of precision bits of such a type is determined by `default_fp` or `default_ip` in the `ti.init()` method call. For example, if `ti.init(default_fp=ti.f64)` is called, then `vec2/vec3/vec4` and `mat2/mat3/mat4` will all have 64-bit floating-point precision in the Taichi scope.
+The number of precision bits of such a type is determined by `default_fp` or `default_ip` in the `ti.init()` method call. For example, if `ti.init(default_fp=ti.f64)` is called, then `vec2/vec3/vec4` and `mat2/mat3/mat4` defined in the Taichi scope all have a 64-bit floating-point precision.
 
-These types can be used to instantiate vectors and matrices or annotate the data types of function arguments and struct members. See [type system](../type_system/type.md) for more information. Here we emphasize that they have very flexible initialization routines:
+You can use these types to instantiate vectors/matrices or annotate data types for function arguments and struct members. See the [Type System](../type_system/type.md) for more information. Here we emphasize that they have very flexible initialization routines:
 
 ```python
 mat2 = ti.math.mat2
@@ -104,17 +101,18 @@ u = v.wzyx  # vec4(4, 3, 2, 1)
 u = v.rraa  # vec4(1, 1, 2, 2)
 ```
 
-### Relationship between `ti.Vector`, `ti.types.vector` and `ti.math.vec3`
+### Relations between `ti.Vector`, `ti.types.vector` and `ti.math.vec3`
+
+- `ti.Vector` is a function that accepts a 1D array and returns a matrix instance that has only one column. For example, `ti.Vector([1, 2, 3, 4, 5])`.
+- `ti.types.vector` is a function that accepts an integer and a primitive type and returns a vector type. For example: `vec5f = ti.types.vector(5, float)`. `vec5f` can then be used to instantiate 5D vectors or annotate data types of function arguments and struct members:
 
-+ `ti.Vector` is a function that accepts a 1D array and returns a matrix instance that has only one column. For example, `ti.Vector([1, 2, 3, 4, 5])`.
-+ `ti.types.vector` is a function that accepts an integer and a primitive type, and returns a vector type. For example: `vec5f = ti.types.vector(5, float)`. `vec5f` can then be used to instantiate 5D vectors or annotate data types in function arguments and struct members:
     ```python
     @ti.kernel
     def test(v: vec5f):
         print(v.xyz)
     ```
     Unlike `ti.Vector`, whose input data must be a 1D array, vector types created by `ti.types.vector()` have more flexible ways to initialize, as explained above.
-+ `ti.math.vec3` is simply created by `vec3 = ti.types.vector(3, float)`.
+- `ti.math.vec3` is created by `vec3 = ti.types.vector(3, float)`.
 
 
 ## GLSL-standard functions
@@ -143,9 +141,9 @@ Texture support in Taichi is implemented in the `ti.types.texture_types` module.
 
 ## Complex number operations
 
-Taichi's math module also supports basic complex arithmetic in the form of 2D vectors.
+Taichi's math module also supports basic complex arithmetic operations on 2D vectors.
 
-You can use a 2D vector of type `ti.math.vec2` to represent a complex number, the addtion/subtraction of complex numbers are just addtion/subtraction of 2D vectors, and multiplication and division can be performed by calling `ti.math.cmul` and `ti.math.cdiv`:
+You can use a 2D vector of type `ti.math.vec2` to represent a complex number. In this way, additions and subtractions of complex numbers come in the form of 2D vector additions and subtractions. You can call `ti.math.cmul()` and `ti.math.cdiv()` to conduct multiplication and division of complex numbers:
 
 ```python
 import taichi as ti
@@ -160,7 +158,7 @@ def test():
     w = tm.cdiv(x, y)  #  vec2(2, 0) = 2+0j
 ```
 
-You can also compute the power, logarithm and exponetial of a complex number:
+You can also compute the power, logarithm, and exponential of a complex number:
 
 ```python