# Builtin - 矩阵

## 矩阵运算

## `eye(size[, cols])`

声明：function

创建单位矩阵。传入一个参数时创建 `size x size` 矩阵；传入两个相同的尺寸参数时结果相同

| 参数   | 类型    | 说明                          |
| ------ | ------- | ----------------------------- |
| `size` | integer | 矩阵的行数和列数              |
| `cols` | integer | 可选。列数，省略时使用 `size` |

返回：array

### 示例

范例01：创建三阶单位矩阵

```tsl
value := eye(3);
echo mRows(value), ",", mCols(value), ",", value[0, 0], ",", value[0, 1];
// 输出：3,3,1,0
```

范例02：使用两个尺寸参数创建单位矩阵

```tsl
value := eye(3, 3);
echo mRows(value), ",", mCols(value), ",", value[2, 2];
// 输出：3,3,1
```

## `mCols(matrix, ret_values)`

声明：function

返回矩阵的列数或列下标

| 参数         | 类型           | 说明                                                    |
| ------------ | -------------- | ------------------------------------------------------- |
| `matrix`     | array\|fmarray | 要读取列信息的矩阵                                      |
| `ret_values` | boolean        | 可选。`false` 返回列数，`true` 返回列下标，默认 `false` |

返回：integer\|array

### 示例

范例01：返回 FMArray 的列数

```tsl
value := fmarray[[1, 2], [3, 4], [5, 6]];
echo mCols(value);
// 输出：2
```

范例02：返回 FMArray 的列下标

```tsl
value := fmarray[[1, 2], [3, 4], [5, 6]];
echo trim(toStn(mCols(value, 1)));
// 输出：array(0,1)
```

## `mFind(matrix, exp, ret_values, replace_value)`

声明：function

查找矩阵中符合条件的元素，并可返回元素值或替换原矩阵中的匹配项

| 参数            | 类型           | 说明                                           |
| --------------- | -------------- | ---------------------------------------------- |
| `matrix`        | array\|fmarray | 要查找的矩阵                                   |
| `exp`           | expression     | 可选。匹配条件，省略时查找值为真的元素         |
| `ret_values`    | boolean        | 可选。是否在位置结果后附加元素值，默认 `false` |
| `replace_value` | any            | 可选。用于替换匹配元素的值                     |

返回：array

### 示例

范例01：查找一维数组中值为真的元素位置

```tsl
value := array(0, 2, 0, 4);
echo trim(toStn(mFind(value)));
// 输出：array(1,3)
```

范例02：返回匹配元素的位置和值

```tsl
value := array((1, 2), (3, 4));
result := mFind(value, mCell > 3, true);
echo result[0][0], ",", result[0][1], ",", result[0][2];
// 输出：1,1,4
```

## `mFindSparse(matrix, exp, ret_values, replace_value)`

声明：function

深度遍历数组并查找或替换符合条件的元素

| 参数            | 类型           | 说明                                           |
| --------------- | -------------- | ---------------------------------------------- |
| `matrix`        | array\|fmarray | 要查找的矩阵                                   |
| `exp`           | expression     | 可选。匹配条件，省略时查找值为真的元素         |
| `ret_values`    | boolean        | 可选。是否在位置结果后附加元素值，默认 `false` |
| `replace_value` | any            | 可选。用于替换匹配元素的值                     |

返回：array

### 示例

范例01：查找嵌套数组中的元素

```tsl
value := array(1, array(0, 2), 0);
result := mFindSparse(value, mCell = 2, true);
echo result[0][0], ",", result[0][1], ",", result[0][2];
// 输出：1,1,2
```

## `mInit(shape, init_value)`

声明：function

按尺寸数组创建各单元格值相同的 FMArray

| 参数         | 类型                   | 说明                         |
| ------------ | ---------------------- | ---------------------------- |
| `shape`      | array                  | 各维度长度组成的数组         |
| `init_value` | integer\|int64\|double | 填充值，值类型决定单元格类型 |

返回：fmarray

### 示例

范例01：通过尺寸数组创建二维 FMArray

```tsl
value := mInit(array(2, 3), 1);
echo mRows(value), "\n", mCols(value), "\n", value[1, 2];
// 输出：
// 2
// 3
// 1
```

## `mInit(dimension, ..., init_value)`

声明：function

按依次给出的维度长度创建各单元格值相同的 FMArray

| 参数         | 类型                   | 说明                         |
| ------------ | ---------------------- | ---------------------------- |
| `dimension`  | integer                | 第一维长度                   |
| `...`        | integer                | 其余维度长度                 |
| `init_value` | integer\|int64\|double | 填充值，值类型决定单元格类型 |

返回：fmarray

### 示例

范例01：通过维度参数创建三维 FMArray

```tsl
value := mInit(2, 3, 4, 1.5);
echo mRows(value), "\n", mCols(value), "\n", value[1, 2, 3];
// 输出：
// 2
// 3
// 1.5
```

## `mInitDiag(shape, init_value)`

声明：function

按尺寸数组创建对角元素值相同的 FMArray

| 参数         | 类型                   | 说明                                 |
| ------------ | ---------------------- | ------------------------------------ |
| `shape`      | array                  | 各维度长度组成的数组                 |
| `init_value` | integer\|int64\|double | 对角元素填充值，值类型决定单元格类型 |

返回：fmarray

### 示例

范例01：通过尺寸数组创建二维对角 FMArray

```tsl
value := mInitDiag(array(3, 3), 2);
echo value[0, 0], "\n", value[0, 1], "\n", value[2, 2];
// 输出：
// 2
// 0
// 2
```

## `mInitDiag(dimension, ..., init_value)`

声明：function

按依次给出的维度长度创建对角元素值相同的 FMArray

| 参数         | 类型                   | 说明                                 |
| ------------ | ---------------------- | ------------------------------------ |
| `dimension`  | integer                | 第一维长度                           |
| `...`        | integer                | 其余维度长度                         |
| `init_value` | integer\|int64\|double | 对角元素填充值，值类型决定单元格类型 |

返回：fmarray

### 示例

范例01：通过维度参数创建三维对角 FMArray

```tsl
value := mInitDiag(2, 3, 4, 2);
echo value[1, 1, 1], "\n", value[1, 2, 1];
// 输出：
// 2
// 0
```

## `mRand(shape, random_info)`

声明：function

按尺寸数组创建随机数 FMArray

| 参数          | 类型  | 说明                                                         |
| ------------- | ----- | ------------------------------------------------------------ |
| `shape`       | array | 各维度长度组成的数组                                         |
| `random_info` | array | 可选。随机数分布及其参数，省略时生成 `0` 到 `1` 之间的随机数 |

返回：fmarray

### 示例

范例01：通过尺寸数组创建随机数 FMArray

```tsl
value := mRand(array(2, 3));
echo dataType(value), "\n", mRows(value), "\n", mCols(value);
// 输出：
// 27
// 2
// 3
```

## `mRand(dimension, ..., random_info)`

声明：function

按依次给出的维度长度创建随机数 FMArray

| 参数          | 类型    | 说明                                                         |
| ------------- | ------- | ------------------------------------------------------------ |
| `dimension`   | integer | 第一维长度                                                   |
| `...`         | integer | 其余维度长度                                                 |
| `random_info` | array   | 可选。随机数分布及其参数，省略时生成 `0` 到 `1` 之间的随机数 |

返回：fmarray

### 示例

范例01：创建服从标准正态分布的二维 FMArray

```tsl
value := mRand(2, 3, array("normal", 0, 1));
echo dataType(value), "\n", mRows(value), "\n", mCols(value);
// 输出：
// 27
// 2
// 3
```

## `mRows(matrix, ret_values)`

声明：function

返回矩阵的行数或行下标

| 参数         | 类型           | 说明                                                    |
| ------------ | -------------- | ------------------------------------------------------- |
| `matrix`     | array\|fmarray | 要读取行信息的矩阵                                      |
| `ret_values` | boolean        | 可选。`false` 返回行数，`true` 返回行下标，默认 `false` |

返回：integer\|array

### 示例

范例01：返回 FMArray 的行数

```tsl
value := fmarray[[1, 2], [3, 4], [5, 6]];
echo mRows(value);
// 输出：3
```

范例02：返回 FMArray 的行下标

```tsl
value := fmarray[[1, 2], [3, 4], [5, 6]];
echo trim(toStn(mRows(value, 1)));
// 输出：array(0,1,2)
```

## `mSize(matrix, ret_values)`

声明：function

返回矩阵各维度的长度或下标

| 参数         | 类型           | 说明                                                              |
| ------------ | -------------- | ----------------------------------------------------------------- |
| `matrix`     | array\|fmarray | 要读取尺寸信息的矩阵                                              |
| `ret_values` | boolean        | 可选。`false` 返回各维度长度，`true` 返回各维度下标，默认 `false` |

返回：array

### 示例

范例01：返回三维 FMArray 的各维度长度

```tsl
value := fmarray[
    [[1, 2], [3, 4]],
    [[5, 6], [7, 8]],
    [[9, 10], [11, 12]]
];
echo trim(toStn(mSize(value)));
// 输出：array(3,2,2)
```

范例02：返回三维 FMArray 的各维度下标

```tsl
value := fmarray[
    [[1, 2], [3, 4]],
    [[5, 6], [7, 8]],
    [[9, 10], [11, 12]]
];
indexes := mSize(value, 1);
echo trim(toStn(indexes[0])), "\n";
echo trim(toStn(indexes[1])), "\n";
echo trim(toStn(indexes[2]));
// 输出：
// array(0,1,2)
// array(0,1)
// array(0,1)
```

## `mSwap(fm, first_dimension, second_dimension)`

声明：function

交换多维 FMArray 的两个维度

| 参数               | 类型    | 说明                 |
| ------------------ | ------- | -------------------- |
| `fm`               | fmarray | 要转置的多维 FMArray |
| `first_dimension`  | integer | 第一个维度下标       |
| `second_dimension` | integer | 第二个维度下标       |

返回：fmarray

### 示例

范例01：交换二维 FMArray 的行列维度

```tsl
value := fmarray[[1, 2], [3, 4], [5, 6]];
swapped := mSwap(value, 0, 1);
echo mRows(swapped), "\n", mCols(swapped), "\n", swapped[1, 2];
// 输出：
// 2
// 3
// 6
```

## `mt_Addition(a, b, c)`

声明：function

求N×M阶矩阵A与N×M阶矩阵B的和矩阵，即C=A+B

| 参数 | 类型  | 说明                                    |
| ---- | ----- | --------------------------------------- |
| `a`  | array | 实型二维数组，体积为N×M。被加矩阵       |
| `b`  | array | 实型二维数组，体积为N×M。加矩阵         |
| `c`  | array | 实型二维数组，体积为N×M。返回的结果矩阵 |

返回：integer

### 示例

```tsl
a := array((3.0, -3.0), (5.0, -5.0));
b := array((-2.0, 4.0), (1.0, 8.0));
c := nil;
status := mt_Addition(a, b, c);
writeLn(status);
writeLn(toStn(c[0][0]), ",", toStn(c[0][1]));
writeLn(toStn(c[1][0]), ",", toStn(c[1][1]));
// 输出：
// 0
// 1.0,1.0
// 6.0,3.0
```

## `mt_decompose_chol(a, ra, flag)`

声明：function

cholesky分解基础函数;如果不担心效率可以使用公用函数chol

| 参数   | 类型  | 说明                                      |
| ------ | ----- | ----------------------------------------- |
| `a`    | array | 待分解的方正矩阵(二维数字数组,行列数相同) |
| `ra`   | array | 分解结果返回                              |
| `flag` | bool  | object                                    |

返回：integer

### 示例

```tsl
a := array((4.0, 0.0), (0.0, 9.0));
factor := nil;
flag := nil;
status := mt_decompose_chol(a, factor, flag);
writeLn(status);
writeLn(toStn(factor[0][0]), ",", toStn(factor[0][1]));
writeLn(toStn(factor[1][0]), ",", toStn(factor[1][1]));
// 输出：
// 0
// 2.0,0.0
// 0.0,3.0
```

## `mt_decompose_eig(a, wr, wi, vr)`

声明：function

计算特征值及特征向量

| 参数 | 类型  | 说明                              |
| ---- | ----- | --------------------------------- |
| `a`  | array | 需要被计算的n\*m矩阵              |
| `wr` | array | 变参返回A的特征值的实部，一维数组 |
| `wi` | array | 变参返回A的特征值的虚部，一维数组 |
| `vr` | array | 变参返回A的特征向量，二维数组     |

返回：integer

### 示例

```tsl
a := array((2.0, 0.0), (0.0, 3.0));
real_values := nil;
imag_values := nil;
vectors := nil;
status := mt_decompose_eig(a, real_values, imag_values, vectors);
writeLn(status);
writeLn(toStn(real_values[0]), ",", toStn(real_values[1]));
writeLn(toStn(imag_values[0]), ",", toStn(imag_values[1]));
writeLn(toStn(vectors[0][0]), ",", toStn(vectors[0][1]));
writeLn(toStn(vectors[1][0]), ",", toStn(vectors[1][1]));
// 输出：
// 0
// 2.0,3.0
// 0.0,0.0
// 1.0,0.0
// 0.0,1.0
```

## `mt_decompose_ldl(a, ra, p)`

声明：function

ldl 分解基础函数,如果a正定L\*D\*`L=A;

| 参数 | 类型  | 说明                                                                                                                                                                                                                                                                                               |
| ---- | ----- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `a`  | array | 待分解的方正矩阵(二维数字数组,行列数相同)                                                                                                                                                                                                                                                          |
| `ra` | array | 分解结果返回,包括,三角矩阵,对角矩阵                                                                                                                                                                                                                                                                |
| `p`  | array | 分解结果的行列信息.a如果为正定矩阵那么p为1到length(a)递增序列.此时,ra的下三角为 L矩阵,对角元为D矩阵.当p为非递增序列,时表示行列置换信息.如果p\[i\]=k>0 and k<> i+1,那么a的i行和k-1行互换,i列与k-1列互换,p\[i\]=k<0 那么d在此处为2\*2的块,在ra的i-1,i行列的4个元,a的第i行和k-1行互换,i列和k-1列互换. |

返回：integer

### 示例

```tsl
a := array((4.0, 2.0), (2.0, 3.0));
factor := nil;
permutation := nil;
status := mt_decompose_ldl(a, factor, permutation);
writeLn(status);
writeLn(toStn(factor[0][0]), ",", toStn(factor[0][1]));
writeLn(toStn(factor[1][0]), ",", toStn(factor[1][1]));
writeLn(permutation[0], ",", permutation[1]);
// 输出：
// 0
// 4.0,2.0
// 0.5,2.0
// 1,2
```

## `Mt_decompose_lu(h, l, u)`

声明：function

进行lu分解，H方阵，则可以得到下三角阵L，上三角矩阵U

| 参数 | 类型  | 说明                 |
| ---- | ----- | -------------------- |
| `h`  | array | 需要被分解的对称矩阵 |
| `l`  | array | 下三角阵             |
| `u`  | array | 上三角阵             |

返回：integer

### 示例

```tsl
a := array((4.0, 3.0), (6.0, 3.0));
lower := nil;
upper := nil;
status := Mt_decompose_lu(a, lower, upper);
writeLn(status);
writeLn(toStn(lower[0][0]), ",", toStn(lower[0][1]));
writeLn(toStn(lower[1][0]), ",", toStn(lower[1][1]));
writeLn(toStn(upper[0][0]), ",", toStn(upper[0][1]));
writeLn(toStn(upper[1][0]), ",", toStn(upper[1][1]));
// 输出：
// 0
// 1.0,0.0
// 1.5,1.0
// 4.0,3.0
// 0.0,-1.5
```

## `mt_decompose_qr(m, q, r, e, qr_type)`

声明：function

E缺省的时候，对矩阵进行QR分解,M=Q :\*R，不缺省E的时候对矩阵进行QRe分解，M:\*e=Q:\*R.该分解使得R矩阵的对角元按绝对值从大倒小排列

| 参数      | 类型  | 说明                                                                                                    |
| --------- | ----- | ------------------------------------------------------------------------------------------------------- |
| `m`       | array | 待分解矩阵                                                                                              |
| `q`       | array | 可选。变参返回正交矩阵Q                                                                                 |
| `r`       | array | 可选。变参返回上三角矩阵R                                                                               |
| `e`       | array | 可选。变参返回列置换矩阵E，默认E的结构是一个方阵，当有qr_Type参数时，0:E方阵，1:E为1维数组，2:忽略E参数 |
| `qr_type` | any   | 可选。整数，为0,1,2之一，用于设定E参数的行为                                                            |

返回：integer

### 示例

```tsl
a := array((1.0, 0.0), (0.0, 1.0));
q := nil;
r := nil;
e := nil;
status := mt_decompose_qr(a, q, r, e, 0);
writeLn(status);
writeLn(toStn(q[0][0]), ",", toStn(q[0][1]), ",", toStn(q[1][0]), ",", toStn(q[1][1]));
writeLn(toStn(r[0][0]), ",", toStn(r[0][1]), ",", toStn(r[1][0]), ",", toStn(r[1][1]));
writeLn(toStn(e[0][0]), ",", toStn(e[0][1]), ",", toStn(e[1][0]), ",", toStn(e[1][1]));
// 输出：
// 0
// 1.0,0.0,0.0,1.0
// 1.0,0.0,0.0,1.0
// 1.0,0.0,0.0,1.0
```

## `mt_decompose_svd(a, u, s, d)`

声明：function

矩阵的奇异值(SVD)分解

| 参数 | 类型  | 说明                                |
| ---- | ----- | ----------------------------------- |
| `a`  | array | 待分解的m\*n矩阵                    |
| `u`  | array | 变参返回A的左奇异向量矩阵，二维数组 |
| `s`  | array | 变参返回A的奇异值，一维数组         |
| `d`  | array | 变参返回A的右奇异向量矩阵，二维数组 |

返回：integer

### 示例

```tsl
a := array((3.0, 0.0), (0.0, 2.0));
left := nil;
singular_values := nil;
right := nil;
status := mt_decompose_svd(a, left, singular_values, right);
writeLn(status);
writeLn(toStn(left[0][0]), ",", toStn(left[0][1]), ",", toStn(left[1][0]), ",", toStn(left[1][1]));
writeLn(toStn(singular_values[0]), ",", toStn(singular_values[1]));
writeLn(toStn(right[0][0]), ",", toStn(right[0][1]), ",", toStn(right[1][0]), ",", toStn(right[1][1]));
// 输出：
// 0
// 1.0,0.0,0.0,1.0
// 3.0,2.0
// 1.0,0.0,0.0,1.0
```

## `mt_iv_Gauss_Jordan(a, x)`

声明：function

用高斯-约当(Gauss-Jordan)法求解n阶方阵A的逆矩阵

| 参数 | 类型  | 说明                                  |
| ---- | ----- | ------------------------------------- |
| `a`  | array | 实型二维数组，体积为N×N。原矩阵       |
| `x`  | array | 实型二维数组，体积为N×N。返回的逆矩阵 |

返回：integer

### 示例

```tsl
a := array((4.0, 7.0), (2.0, 6.0));
inverse := nil;
status := mt_iv_Gauss_Jordan(a, inverse);
writeLn(status);
writeLn(toStn(inverse[0][0]), ",", toStn(inverse[0][1]));
writeLn(toStn(inverse[1][0]), ",", toStn(inverse[1][1]));
// 输出：
// 0
// 0.6,-0.7
// -0.2,0.4
```

## `mt_iv_Ldl(a, x)`

声明：function

求n阶对称正定矩阵A的逆矩阵

| 参数 | 类型  | 说明                                                |
| ---- | ----- | --------------------------------------------------- |
| `a`  | array | 实型二维数组，体积为N×N。原矩阵，必须为一个对称矩阵 |
| `x`  | array | 实型二维数组，体积为N×N。返回的逆矩阵               |

返回：integer

### 示例

```tsl
a := array((4.0, 2.0), (2.0, 3.0));
inverse := nil;
status := mt_iv_Ldl(a, inverse);
writeLn(status);
writeLn(toStn(inverse[0][0]), ",", toStn(inverse[0][1]));
writeLn(toStn(inverse[1][0]), ",", toStn(inverse[1][1]));
// 输出：
// 0
// 0.375,-0.25
// -0.25,0.5
```

## `mt_Multiplication(a, b, c)`

声明：function

求N×M阶矩阵A与M×L阶矩阵B的乘积矩阵，即C=A×B

| 参数 | 类型  | 说明                                    |
| ---- | ----- | --------------------------------------- |
| `a`  | array | 实型二维数组，体积为N×M。被乘矩阵       |
| `b`  | array | 实型二维数组，体积为M×L。乘矩阵         |
| `c`  | array | 实型二维数组，体积为N×L。返回的结果矩阵 |

返回：integer

### 示例

```tsl
a := array((1.0, 2.0, 3.0, 4.0), (5.0, 6.0, 7.0, 8.0));
b := array((3.0, -3.0), (-2.0, 4.0), (1.0, 8.0), (-1.0, -3.0));
c := nil;
status := mt_Multiplication(a, b, c);
writeLn(status);
writeLn(toStn(c[0][0]), ",", toStn(c[0][1]));
writeLn(toStn(c[1][0]), ",", toStn(c[1][1]));
// 输出：
// 0
// -2.0,17.0
// 2.0,41.0
```

## `mt_Subtraction(a, b, c)`

声明：function

求N×M阶矩阵A与N×M阶矩阵B的差矩阵，即C=A-B

| 参数 | 类型  | 说明                                    |
| ---- | ----- | --------------------------------------- |
| `a`  | array | 实型二维数组，体积为N×M。被减矩阵       |
| `b`  | array | 实型二维数组，体积为N×M。减矩阵         |
| `c`  | array | 实型二维数组，体积为N×M。返回的结果矩阵 |

返回：integer

### 示例

```tsl
a := array((3.0, -3.0), (5.0, -5.0));
b := array((-2.0, 4.0), (1.0, 8.0));
c := nil;
status := mt_Subtraction(a, b, c);
writeLn(status);
writeLn(toStn(c[0][0]), ",", toStn(c[0][1]));
writeLn(toStn(c[1][0]), ",", toStn(c[1][1]));
// 输出：
// 0
// 5.0,-7.0
// 4.0,-13.0
```

## `mt_Transposition(a, c)`

声明：function

求m×n阶矩阵A的转置矩阵，即C=

| 参数 | 类型  | 说明                                          |
| ---- | ----- | --------------------------------------------- |
| `a`  | array | 实型二维数组，体积为N×M。转置前矩阵           |
| `c`  | array | 实型二维数组，体积为M×N。返回转置后的结果矩阵 |

返回：integer

### 示例

```tsl
a := array((3.0, -3.0, 11.0), (5.0, -5.0, 8.0));
transposed := nil;
status := mt_Transposition(a, transposed);
writeLn(status);
writeLn(toStn(transposed[0][0]), ",", toStn(transposed[0][1]));
writeLn(toStn(transposed[1][0]), ",", toStn(transposed[1][1]));
writeLn(toStn(transposed[2][0]), ",", toStn(transposed[2][1]));
// 输出：
// 0
// 3.0,5.0
// -3.0,-5.0
// 11.0,8.0
```

## `mt_va_Cholesky(a, v)`

声明：function

求对称正定矩阵的行列式值平方根

| 参数 | 类型  | 说明                                                |
| ---- | ----- | --------------------------------------------------- |
| `a`  | array | 实型二维数组，体积为N×N。原矩阵，必须为一个对称矩阵 |
| `v`  | float | 实型数。返回矩阵行列式值的平方根                    |

返回：integer

### 示例

```tsl
a := array((4.0, 0.0), (0.0, 9.0));
root_determinant := nil;
status := mt_va_Cholesky(a, root_determinant);
writeLn(status);
writeLn(toStn(root_determinant));
// 输出：
// 0
// 6.0
```

## `mt_va_Gauss_Jordan(a, v)`

声明：function

用高斯-约当(Gauss-Jordan)法求解n阶方阵A的行列式值

| 参数 | 类型  | 说明                      |
| ---- | ----- | ------------------------- |
| `a`  | array | 实型二维数组，体积为N×N。 |
| `v`  | float | 实型数。返回的行列式值    |

返回：integer

### 示例

```tsl
a := array((3.0, 1.0), (5.0, 2.0));
determinant := nil;
status := mt_va_Gauss_Jordan(a, determinant);
writeLn(status);
writeLn(toStn(determinant));
// 输出：
// 0
// 1.0
```

## `nils(size_or_rows[, cols_or_fields])`

声明：function

创建元素为 `nil` 的一维或二维数组。传入一个参数时创建一维数组；传入两个参数时创建二维数组。第二个参数可以是列数或列名数组

| 参数             | 类型           | 说明                                         |
| ---------------- | -------------- | -------------------------------------------- |
| `size_or_rows`   | integer\|array | 一维长度、二维行数或行标数组                 |
| `cols_or_fields` | integer\|array | 可选。二维列数或列名数组，省略时创建一维数组 |

返回：array

### 示例

范例01：创建一维空值数组

```tsl
value := nils(3);
echo length(value), ",", value[2] = nil;
// 输出：3,1
```

范例02：创建二维空值数组

```tsl
value := nils(2, 3);
echo mRows(value), ",", mCols(value), ",", value[1, 2] = nil;
// 输出：2,3,1
```

## `ones(size_or_rows[, cols_or_fields])`

声明：function

创建元素为 `1` 的一维或二维数组。传入一个参数时创建一维数组；传入两个参数时创建二维数组。第二个参数可以是列数或列名数组

| 参数             | 类型           | 说明                                         |
| ---------------- | -------------- | -------------------------------------------- |
| `size_or_rows`   | integer\|array | 一维长度、二维行数或行标数组                 |
| `cols_or_fields` | integer\|array | 可选。二维列数或列名数组，省略时创建一维数组 |

返回：array

### 示例

范例01：创建一维全一数组

```tsl
value := ones(3);
echo length(value), ",", value[2];
// 输出：3,1
```

范例02：创建二维全一数组

```tsl
value := ones(2, 3);
echo mRows(value), ",", mCols(value), ",", value[1, 2];
// 输出：2,3,1
```

## `rand(size_or_rows[, cols_or_fields])`

声明：function

创建元素为随机数的一维或二维数组。传入一个参数时创建一维数组；传入两个参数时创建二维数组。随机数默认位于 `0` 到 `1` 之间。第二个参数可以是列数或列名数组

| 参数             | 类型           | 说明                                         |
| ---------------- | -------------- | -------------------------------------------- |
| `size_or_rows`   | integer\|array | 一维长度、二维行数或行标数组                 |
| `cols_or_fields` | integer\|array | 可选。二维列数或列名数组，省略时创建一维数组 |

返回：array

### 示例

范例01：创建二维随机数组并检查取值范围

```tsl
value := rand(2, 3);
echo mRows(value), ",", mCols(value), ",", value[0, 0] >= 0, ",", value[0, 0] <= 1;
// 输出：2,3,1,1
```

## `zeros(size_or_rows[, cols_or_fields])`

声明：function

创建元素为 `0` 的一维或二维数组。传入一个参数时创建一维数组；传入两个参数时创建二维数组。第二个参数可以是列数或列名数组；第一个参数也可以使用行标数组

| 参数             | 类型           | 说明                                         |
| ---------------- | -------------- | -------------------------------------------- |
| `size_or_rows`   | integer\|array | 一维长度、二维行数或行标数组                 |
| `cols_or_fields` | integer\|array | 可选。二维列数或列名数组，省略时创建一维数组 |

返回：array

### 示例

范例01：创建一维全零数组

```tsl
value := zeros(3);
echo length(value), ",", value[2];
// 输出：3,0
```

范例02：创建二维全零数组

```tsl
value := zeros(2, 3);
echo mRows(value), ",", mCols(value), ",", value[1, 2];
// 输出：2,3,0
```

范例03：使用行标和列名创建数据表数组

```tsl
value := zeros(array("L1", "L2"), array("F1", "F2"));
echo value["L1"]["F1"];
// 输出：0
```