Shall we separate Matrix class and Vector class?

[lin-hitonami]

Currently, ti.Matrix and ti.Vector are the same class. ti.Vector is only a constructor that constructs a ti.Matrix with shape (n, 1).
However, it introduces a problem that some methods which are only meaningful for vectors appear in the API of ti.Matrix, like x(), which returns the first value of the vector. Also, vectors can also access APIs like determinant() which are only meaningful for square matrices.

Therefore, I think maybe we should separate Matrix class and Vector class. I've come up with two ways to separate them.

1. Let Matrix and Vector inherit the same class MatrixBase.

• MatrixBase stores a two-dimensional array. We define operators that apply both to vectors and matrices in this class.

• Matrix is the class for general two-dimensional matrices. We define constructors of special matrices and functions only apply to matrices in this class.

• Vector is the class for row vectors and column vectors, and they are stored as matrices with shapes (1, n) and (n, 1). We define constructors of special vectors and functions only apply to vectors in this class.

  Pros: The changes do not affect users' code.

  Cons: The vectors are stored as matrices, and we have to take care of both row vectors and column vectors.

2. Totally separate Vector class and Matrix class

• Matrix stores a two-dimensional array, and Vector stores a one-dimensional array.

• Define the operators between Matrix and Vector in one of the classes.

• When doing operations like multiplication between a matrix and a vector, the vector is treated as row vector when it is on the left side of the matrix, or column vector otherwise.

  Pros: Vectors are really one-dimensional, and we do not need to deal with two types of vectors.

  Cons: We need to define the operators between Matrix and Vector. Also, the behaviors of some functions may be different from the current Taichi, we might break some of users' code.

[strongoier]

One more supporting argument for separating these two classes: #2683. I vote for way 2 as it is clean and mimics the behavior of numpy.

[k-ye]

Regarding the cons of approach 2, can we make them just inherit some common operators, much like what's been done in https://github.com/taichi-dev/taichi/blob/master/python/taichi/lang/common_ops.py?

+1 for following numpy's strategy, we don't have to re-invent the math here :-)

I'm also curious if the type system can help in this case. Concretely, we have a TensorType, and Matrix and Vector are just the instantiation of TensorType with different shapes.