Skip to content

S
sparrowzz
Commit 2f0140eb by dongshufeng
Options

更新RustScript手册

parent 29af4ad0
正在显示 包含 2631 行增加 和 631 行删除
rustscript/RustScript手册.md
# RustScript 语言规范 # RustScript 语言规范
# RustScript 语言规范 # RustScript 语言规范
## 1. 语言概述 ## 1. 语言概述
RustScript 是一种结合了 Rust 和 MATLAB 语法特征的脚本语言，专为科学计算和矩阵操作设计。它采用基于张量的数据结构，具有强类型推导和函数式编程特征。 RustScript 是一种结合了 Rust 和 MATLAB 语法特征的脚本语言，专为科学计算和矩阵操作设计。它采用基于张量的数据结构，具有强类型推导和函数式编程特征。
## 2. 词法规则 ## 2. 词法规则
### 2.1 标识符 ### 2.1 标识符
```rustscript ```rustscript
// 有效标识符 // 有效标识符
variable_name variable_name
matrix1 matrix1
bus_data bus_data
PQ_bus PQ_bus
``` ```
### 2.2 数值字面量 ### 2.2 数值字面量
```rustscript ```rustscript
// 整数 // 整数
42 42
-17 -17
0 0
// 浮点数 // 浮点数
3.14 3.14
-2.718 -2.718
1.23e-4 1.23e-4
6.022e23 6.022e23
// 科学记数法 // 科学记数法
1.5e10 1.5e10
-2.3E-5 -2.3E-5
``` ```
### 2.3 字符串字面量 ### 2.3 字符串字面量
```rustscript ```rustscript
// 字符串使用双引号 // 字符串使用双引号
"Hello, World!" "Hello, World!"
"Power flow data for IEEE 14 bus" "Power flow data for IEEE 14 bus"
"File path: /data/case14.txt" "File path: /data/case14.txt"
``` ```
### 2.4 数学常量约定 ### 2.4 数学常量约定
- π：pi - π：pi
- 分母为零：NAN - 自然常数：e
- 正无穷大：INF - 分母为零：NAN
- 负无穷大：NEG_INF - 正无穷大：INF
- 负无穷大：NEG_INF
### 2.5 注释
```rustscript ### 2.5 注释
// 单行注释 ```rustscript
/* 多行注释 */ // 单行注释
/* 多行注释 */
/*
* 块注释 /*
* 支持多行 * 块注释
*/ * 支持多行
``` */
```
## 3. 数据类型
## 3. 数据类型
### 3.1 基本数据类型
- `f64`: 64位浮点数（默认数值类型） ### 3.1 基本数据类型
- `i64`: 64位整数 - `f64`: 64位浮点数（默认数值类型）
- `bool`: 布尔值 (`true`, `false`) - `i64`: 64位整数
- `string`: 字符串类型 - `bool`: 布尔值 (`true`, `false`)
- `complex`: 复数类型 - `string`: 字符串类型
- `complex`: 复数类型
**注意：RustScript没有结构体类型，所有数据都基于基本类型和张量。**
**注意：RustScript没有结构体类型，所有数据都基于基本类型和张量。**
### 3.2 复数类型
```rustscript ### 3.2 复数类型
// 复数创建 ```rustscript
z1 = c(3.0, 4.0); // 3 + 4i // 复数创建
z2 = c(0, 1); // i z1 = c(3.0, 4.0); // 3 + 4i
z3 = c(5.0, 0); // 实数 z2 = c(0, 1); // i
z3 = c(5.0, 0); // 实数
// 复数运算
result = z1 + z2 * 2.0; // 复数运算
magnitude = abs(z1); result = z1 + z2 * 2.0;
phase = arg(z1); magnitude = abs(z1);
``` phase = arg(z1);
```
### 3.3 张量类型
```rustscript ### 3.3 张量类型
// 标量 ```rustscript
scalar = 42.0; // 标量
scalar = 42.0;
// 1D 张量（一维张量）- shape为 [n]
vector = [1.0, 2.0, 3.0, 4.0]; // shape: [4] // 1D 张量（一维张量）- shape为 [n]
vector = [1.0, 2.0, 3.0, 4.0]; // shape: [4]
// 2D 张量（二维张量）- shape为 [m, n]
matrix = [ // 2D 张量（二维张量）- shape为 [m, n]
[1.0, 2.0, 3.0], matrix = [
[4.0, 5.0, 6.0], [1.0, 2.0, 3.0],
[7.0, 8.0, 9.0] [4.0, 5.0, 6.0],
]; // shape: [3, 3] [7.0, 8.0, 9.0]
]; // shape: [3, 3]
// 行向量（二维张量）- shape为 [1, n]
row_vector = [[1.0, 2.0, 3.0]]; // shape: [1, 3] // 行向量（二维张量）- shape为 [1, n]
row_vector = [[1.0, 2.0, 3.0]]; // shape: [1, 3]
// 列向量（二维张量）- shape为 [m, 1]
col_vector = [[1.0], [2.0], [3.0]]; // shape: [3, 1] // 列向量（二维张量）- shape为 [m, 1]
col_vector = [[1.0], [2.0], [3.0]]; // shape: [3, 1]
// 3D 张量
tensor3d = [ // 3D 张量
[[1.0, 2.0], [3.0, 4.0]], tensor3d = [
[[5.0, 6.0], [7.0, 8.0]] [[1.0, 2.0], [3.0, 4.0]],
]; // shape: [2, 2, 2] [[5.0, 6.0], [7.0, 8.0]]
``` ]; // shape: [2, 2, 2]
```
**重要区别：**
- **一维张量**：shape为 [n]，在运算时相当于行向量 **重要区别：**
- **二维张量**：包括矩阵、行向量 [1, n]、列向量 [m, 1] - **一维张量**：shape为 [n]，在运算时相当于行向量
- **行向量和列向量都属于二维张量**，但形状不同 - **二维张量**：包括矩阵、行向量 [1, n]、列向量 [m, 1]
- **行向量和列向量都属于二维张量**，但形状不同
### 3.4 数据组织方式
由于没有结构体，复杂数据通过张量和多个相关变量来组织： ### 3.4 数据组织方式
```rustscript 由于没有结构体，复杂数据通过张量和多个相关变量来组织：
// 电力系统数据组织（无结构体方式） ```rustscript
baseMVA = 100; // 基准功率 // 电力系统数据组织（无结构体方式）
bus = [...]; // 母线数据矩阵 baseMVA = 100; // 基准功率
gen = [...]; // 发电机数据矩阵 bus = [...]; // 母线数据矩阵
branch = [...]; // 支路数据矩阵 gen = [...]; // 发电机数据矩阵
branch = [...]; // 支路数据矩阵
// 不是: mpc.baseMVA, mpc.bus 等结构体访问方式
``` // 不是: mpc.baseMVA, mpc.bus 等结构体访问方式
```
## 4. 变量和赋值
## 4. 变量和赋值
### 4.1 变量声明
```rustscript ### 4.1 变量声明
// 变量赋值（类型推导） ```rustscript
baseMVA = 100; // 变量赋值（类型推导）
voltage = 1.06; baseMVA = 100;
name = "RustScript"; voltage = 1.06;
is_valid = true; name = "RustScript";
is_valid = true;
// 张量赋值
vector = [1, 2, 3, 4]; // 张量赋值
matrix = [[1, 2], [3, 4]]; vector = [1, 2, 3, 4];
``` matrix = [[1, 2], [3, 4]];
```
### 4.2 常量声明
```rustscript ### 4.2 常量声明
// 常量定义（约定使用大写） ```rustscript
PI = 3.14159265359; // 常量定义（约定使用大写）
EULER = 2.71828; PI = 3.14159265359;
MAX_ITERATIONS = 1000; EULER = 2.71828;
MAX_ITERATIONS = 1000;
// 电力系统常量示例
PQ = 1; // 电力系统常量示例
PV = 2; PQ = 1;
REF = 3; PV = 2;
NONE = 4; REF = 3;
NONE = 4;
// 母线数据列索引
BUS_I = 0; // 母线数据列索引
BUS_TYPE = 1; BUS_I = 0;
PD = 2; BUS_TYPE = 1;
QD = 3; PD = 2;
``` QD = 3;
```
## 5. 张量操作
## 5. 张量操作
### 5.1 张量索引
```rustscript ### 5.1 张量索引
// 单个元素访问 ```rustscript
element = get(matrix, row, col); // 获取指定位置的单个元素 函数
get
// 注意：不支持 A[0,1] 这样的直接索引方式 语法
// 错误写法：element = matrix[0, 1]; // 不支持 element = get(t, row, col); // 获取指定位置的单个元素
注意：不支持 A[0,1] 这样的直接索引方式
// 负索引（从末尾开始） 输入参数
last_element = get(vector, -1); t - 张量，若为稀疏矩阵，仅能获取非零元
``` row - 行索引，标量
col - 列索引，标量
### 5.2 张量切片 v - 向量
```rustscript 示例
// slice函数用于取矩阵的行列 输入 get([1, 2, 3], 1)
// slice(matrix, row_spec, col_spec) 结果 2
// [0] 代表所有行或所有列
输入 get([[1, 2, 3], [4, 5, 6], [7, 8, 9]], 1, 2)
// 重要：返回类型取决于参数格式 结果 6
// 1. 使用范围参数[start, end] - 返回二维张量 输入 get(sparse([0,0],[0,1],[1,2], 2, 2), 0, 1)
col_2d = slice(a, [0], [1, 2]); // 取第2列所有行，返回3×1列向量(二维张量) 结果 2
row_2d = slice(a, [1, 2], [0]); // 取第2行所有列，返回1×3行向量(二维张量) ```
sub_matrix = slice(matrix, [0,3], [1,4]); // 行0-2，列1-3的子矩阵(二维张量)
### 5.2 张量切片
// 2. 使用单个索引 - 返回一维张量 ```rustscript
col_1d = slice(a, [0], 1); // 取第2列所有行，返回shape为[3]的一维张量 函数
row_1d = slice(a, 1, [0]); // 取第2行所有列，返回shape为[3]的一维张量 slice
语法
// 实际应用示例 slice(t, row_spec, col_spec)
// 假设a是3×3矩阵： 输入参数
a = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]; t - 张量
row_spec - 行索引，数值代表单个索引，[0]代表所有行，[start,end,step]代表范围和步长
// 二维张量切片（保持矩阵结构） col_spec - 列索引，数值代表单个索引，[0]代表所有列，[start,end,step]代表范围和步长
col_vector = slice(a, [0], [1, 2]); // 返回[[2], [5], [8]] - 3×1列向量(二维张量) 返回类型
row_vector = slice(a, [1, 2], [0]); // 返回[[4, 5, 6]] - 1×3行向量(二维张量) 1. 使用范围参数[start, end] - 返回二维张量
col_2d = slice(a, [0], [1, 2]); // 取第2列所有行，返回3×1列向量(二维张量)
// 一维张量切片（扁平化） row_2d = slice(a, [1, 2], [0]); // 取第2行所有列，返回1×3行向量(二维张量)
col_flat = slice(a, [0], 1); // 返回[2, 5, 8] - shape为[3]的一维张量 sub_t = slice(t, [0,3], [1,4]); // 行0-2，列1-3的子矩阵(二维张量)
row_flat = slice(a, 1, [0]); // 返回[4, 5, 6] - shape为[3]的一维张量
2. 使用单个索引 - 返回一维张量
// 电力系统应用示例 col_1d = slice(a, [0], 1); // 取第2列所有行，返回shape为[3]的一维张量
voltage = slice(bus, [0], [VM-1, VM]); // 所有行，VM列(二维张量) row_1d = slice(a, 1, [0]); // 取第2行所有列，返回shape为[3]的一维张量
angle = slice(bus, [0], VA-1); // 所有行，VA列(一维张量) 示例
``` a = [[1, 2, 3], [4, 5, 6], [7, 8, 9]];
输入 slice(a, [0], [1, 2])
### 5.3 张量赋值操作 结果 [[2], [5], [8]]
```rustscript
// assign函数用于对对应位置赋值，要求源张量和目标位置的形状匹配 输入 slice(a, [1, 2], [0])
// assign(target, source, row_spec, col_spec) 结果 [[4, 5, 6]]
// 重要：source的维度必须与目标位置的维度匹配 输入 slice(a, [1, 3], [0, 2])
结果 [[4,5],[7,8]]
// 1. 赋值二维张量 - source必须是匹配的二维张量
b_2d = [[1.0], [2.0], [3.0]]; // 3×1列向量(二维张量) 输入 slice(a, [0, 3, 2], [0, 3, 2])
assign(a, b_2d, [0], [1, 2]); // 正确：b_2d是3×1列向量，匹配slice(a,[0],[1,2]) 结果 [[1,3],[7,9]]
c_2d = [[1.0, 2.0, 3.0]]; // 1×3行向量(二维张量) 输入 slice(a, [0], 1)
assign(a, c_2d, [1, 2], [0]); // 正确：c_2d是1×3行向量，匹配slice(a,[1,2],[0]) 结果 [2, 5, 8]
// 2. 赋值一维张量 - source必须是匹配的一维张量 输入 slice(a, 1, [0])
b_1d = [1.0, 2.0, 3.0]; // shape为[3]的一维张量 结果 [4, 5, 6]
assign(a, b_1d, [0], 1); // 正确：b_1d是一维张量，匹配slice(a,[0],1)
assign(a, b_1d, 1, [0]); // 正确：b_1d是一维张量，匹配slice(a,1,[0]) 电力系统应用示例
voltage = slice(bus, [0], [VM-1, VM]); // 所有行，VM列(二维张量)
// 错误示例（形状不匹配） angle = slice(bus, [0], VA-1); // 所有行，VA列(一维张量)
// assign(a, b_1d, [0], [1, 2]); // 错误：一维张量不能赋值给二维位置 ```
// assign(a, b_2d, [0], 1); // 错误：二维张量不能赋值给一维位置
### 5.3 获取张量指定行列
// 实际应用示例 ```rustscript
voltage = slice(bus, [0], [VM-1, VM]); // 获取电压幅值列(二维张量) 函数
new_voltage = [[1.05], [1.02], [1.01]]; // 新的电压值(二维张量) select
assign(bus, new_voltage, [0], [VM-1, VM]); // 更新电压幅值 语法
select(t, row_spec, col_spec)
angle_flat = slice(bus, [0], VA-1); // 获取电压角度(一维张量) 输入参数
new_angles = [0.0, -2.5, 1.2]; // 新的角度值(一维张量) t - 张量
assign(bus, new_angles, [0], VA-1); // 更新电压角度 row_spec - 行索引，数值代表单个索引，[]代表所有行，向量代表指定多行
``` col_spec - 列索引，数值代表单个索引，[]代表所有列，向量代表指定多列
示例
### 5.4 张量形状和维度说明 a = [[1, 2, 3], [4, 5, 6], [7, 8, 9]];
```rustscript 输入 select(a, [0,1], [2])
// 重要概念区分： 结果 [[3], [6]]
a = [1, 2, 3]; // 一维张量, shape: [3]
b = [[1, 2, 3]]; // 行向量(二维张量), shape: [1, 3] 输入 select(a, [0,2])
c = [[1], [2], [3]]; // 列向量(二维张量), shape: [3, 1] 结果 [[1, 2, 3], [7, 8, 9]]
// 在运算中： 输入 select(a, [], [0,2])
// - 一维张量在运算时相当于行向量 结果 [[1,3], [4,6], [7,9]]
// - 行向量和列向量都属于二维张量，但形状不同
// - slice和assign函数的行为取决于参数格式和返回的张量维度 输入 select(a, 0, [0,2])
结果 [[1,3]]
// 形状检查示例 ```
ndims(a); // 返回 1 (一维张量)
ndims(b); // 返回 2 (二维张量) ### 5.4 张量赋值操作
ndims(c); // 返回 2 (二维张量) ```rustscript
函数
size(a, 0); // 返回 3 assign
size(b, 0); // 返回 1 (行数) 语法
size(b, 1); // 返回 3 (列数) assign(target, source, row_spec, col_spec)
size(c, 0); // 返回 3 (行数) 输入参数
size(c, 1); // 返回 1 (列数) target - 待赋值张量
``` source - 赋值张量
row_spec - 行索引，数值代表单个索引，[0]代表所有行，[start,end,step]代表范围和步长
## 6. 运算符 col_spec - 列索引，数值代表单个索引，[0]代表所有列，[start,end,step]代表范围和步长
重要：source的维度必须与target切片的形状匹配
### 6.1 算术运算符 输入参数示例
```rustscript 1. 赋值二维张量 - source必须是匹配的二维张量
// 标量运算 b_2d = [[1.0], [2.0], [3.0]]; // 3×1列向量(二维张量)
a + b; // 加法 assign(a, b_2d, [0], [1, 2]); // 正确：b_2d是3×1列向量，匹配slice(a,[0],[1,2])
a - b; // 减法
a * b; // 乘法 c_2d = [[1.0, 2.0, 3.0]]; // 1×3行向量(二维张量)
a / b; // 除法 assign(a, c_2d, [1, 2], [0]); // 正确：c_2d是1×3行向量，匹配slice(a,[1,2],[0])
a ^ b; // 幂运算
2. 赋值一维张量 - source必须是匹配的一维张量
// 元素级运算（张量） b_1d = [1.0, 2.0, 3.0]; // shape为[3]的一维张量
A .+ B; // 元素级加法 assign(a, b_1d, [0], 1); // 正确：b_1d是一维张量，匹配slice(a,[0],1)
A .- B; // 元素级减法 assign(a, b_1d, 1, [0]); // 正确：b_1d是一维张量，匹配slice(a,1,[0])
A .* B; // 元素级乘法
A ./ B; // 元素级除法 错误示例（形状不匹配）
A .^ 2; // 元素级幂运算 // assign(a, b_1d, [0], [1, 2]); // 错误：一维张量不能赋值给二维位置
// assign(a, b_2d, [0], 1); // 错误：二维张量不能赋值给一维位置
// 矩阵运算 示例
A * B; // 矩阵乘法 a = [[1, 2, 3], [4, 5, 6], [7, 8, 9]];
A'; // 转置 输入 assign(a, [[-2],[-5],[-8]], [0], [1,2])
inv(A); // 逆矩阵 结果 [[1, -2, 3], [4, -5, 6], [7, -8, 9]]
det(A); // 行列式
``` 输入 assign(a, [[-4,-5,-6]], [1,2], [0])
结果 [[1, 2, 3], [-4, -5, -6], [7, 8, 9]];
### 6.2 比较运算符
```rustscript 输入 assign(a, [[-4,-5],[-7,-8]], [1,3], [0,2])
// 标量比较 结果 [[1, 2, 3], [-4, -5, 6], [-7, -8, 9]]
a == b; // 等于
a != b; // 不等于 输入 assign(a, [[-1,-3],[-7,-9]], [0,3,2], [0,3,2])
a < b; // 小于 结果 [[-1, 2, -3], [4, 5, 6], [-7, 8, -9]]
a <= b; // 小于等于
a > b; // 大于 输入 assign(a, [-2,-5,-8], [0], 1)
a >= b; // 大于等于 结果 [[1,-2,3],[4,-5,6],[7,-8,9]]
// 元素级比较（张量） 输入 assign(a, [-4,-5,-6], 1, [0])
A .== B; // 元素级等于 结果 [[1, 2, 3], [-4, -5, -6], [7, 8, 9]]
A .< B; // 元素级小于
``` 电力系统应用示例
voltage = slice(bus, [0], [VM-1, VM]); // 获取电压幅值列(二维张量)
### 6.3 逻辑运算符 new_voltage = [[1.05], [1.02], [1.01]]; // 新的电压值(二维张量)
```rustscript assign(bus, new_voltage, [0], [VM-1, VM]); // 更新电压幅值
// 标量逻辑
a && b; // 逻辑与 angle_flat = slice(bus, [0], VA-1); // 获取电压角度(一维张量)
a || b; // 逻辑或 new_angles = [0.0, -2.5, 1.2]; // 新的角度值(一维张量)
~~a; // 逻辑非（注意：是两个波浪号） assign(bus, new_angles, [0], VA-1); // 更新电压角度
```
// 元素级逻辑（张量）
A .&& B; // 元素级逻辑与 ### 5.5 张量形状和维度
A .|| B; // 元素级逻辑或 #### 5.5.1 重要概念区分
.~~A; // 元素级逻辑非（两个波浪号） ```rustscript
a = [1, 2, 3]; // 一维张量, shape: [3]
// 实际使用示例 b = [[1, 2, 3]]; // 行向量(二维张量), shape: [1, 3]
bus_gen_status = ~~bus_gen_status; // 逻辑非运算 c = [[1], [2], [3]]; // 列向量(二维张量), shape: [3, 1]
pq = find(bus_type == PQ || ~~bus_gen_status); // 组合逻辑运算
``` 在运算中：
- 一维张量在运算时相当于行向量
## 7. 基本编程语句 - 行向量和列向量都属于二维张量，但形状不同
- slice和assign函数的行为取决于参数格式和返回的张量维度
### 7.1 条件语句 ```
```rustscript #### 5.5.2 获取张量维数
//if语句 ```rustscript
if a ==1{ 函数
b = b+1; ndim
} 语法
ndim(t)
//if-else语句 输入参数
if a ==1{ t - 张量
b = b+1; 示例
}else{ 输入 ndim([1, 2, 3])
b = b+2; 结果 1
}
输入 ndim([[1, 2, 3]])
//if-elseif-else语句 结果 2
if a == 0{
b = b + 1; 输入 ndim([[1], [2], [3]])
}else if a == 1{ 结果 2
b = b + 2; ```
}else{ #### 5.5.3 获取指定维度大小
b = b + 3; ```rustscript
} 函数
``` size
语法
### 7.2 循环语句 size(t, dim)
```rustscript 输入参数
//for语句 t - 张量
for i in 0..10 { dim - 指定维度，若该参数为空则返回各维度大小构成的向量
r = runpf(); 示例
} 输入 size([[1., 0.5, 0.3, 0.2], [0.5, 1., 0.6, 0.5], [0.3, 0.6, 1., 0.7]])
``` 结果 [3,4]
## 8. 函数定义 输入 size([1, 2, 3], 0)
结果 3
### 8.1 基本函数语法
```rustscript 输入 size([[1, 2, 3]], 0)
fn function_name(param1, param2, ...) { 结果 1
// 函数体
return result; 输入 size([[1, 2, 3]], 1)
} 结果 3
// 简化返回语法（最后一个表达式作为返回值） 输入 size([[1], [2], [3]], 0)
fn add(a, b) { 结果 3
a + b
} 输入 size([[1], [2], [3]], 1)
``` 结果 1
```
**重要限制：RustScript函数只能返回一个变量，不支持多返回值。**
## 6. 运算符
### 8.2 函数示例 ### 6.1 算术运算符
```rustscript #### 6.1.1 标量运算
fn make_y_bus(baseMVA, bus, branch) { ##### 6.1.1.1 加法
nb = size(bus, 0); ```rustscript
nl = size(branch, 0); 运算符
+
// 计算导纳矩阵 语法
stat = slice(branch, [0], [BR_STATUS-1, BR_STATUS]); a + b;
Ys = stat ./ (slice(branch, [0], [BR_R-1, BR_R]) ```
+ c(0,1) * slice(branch, [0], [BR_X-1, BR_X])); ##### 6.1.1.2 减法
```rustscript
return Ys; // 只能返回一个值 运算符
} -
``` 语法
a - b;
## 9. 内置函数 ```
##### 6.1.1.3 乘法
### 9.1 数学函数 ```rustscript
```rustscript 运算符
// 基本数学函数 *
sqrt(x), exp(x), log(x), log10(x) 语法
sin(x), cos(x), tan(x) a * b;
asin(x), acos(x), atan(x), atan2(y, x) ```
abs(x), sign(x), floor(x), ceil(x), round(x) ##### 6.1.1.4 除法
```rustscript
// 复数函数 运算符
real(z), imag(z), conj(z), abs(z), arg(z) /
``` 语法
a / b;
### 9.2 矩阵函数 ```
```rustscript ##### 6.1.1.5 幂运算
// 线性代数 ```rustscript
det(A), inv(A), rank(A), trace(A) 运算符
eig(A), svd(A), qr(A), chol(A) ^
norm(A), cond(A) 语法
a ^ b;
// 矩阵操作 ```
transpose(A), diag(A), triu(A), tril(A) #### 6.1.2 元素级运算（张量）
reshape(A, m, n), repmat(A, m, n) ##### 6.1.2.1 元素级加法
``` ```rustscript
运算符
### 9.3 张量操作函数 +
```rustscript 语法
// 形状和尺寸 A + B;
size(tensor, dim) // 获取指定维度大小 输入参数
length(tensor) // 获取元素总数 A - 矩阵
ndims(tensor) // 获取维度数 B - 矩阵
numel(tensor) // 元素个数 若A的形状与B的形状相同，对应元素相加
若A为行向量且长度与B的列数相同，则B的每一行均与A相加，反之亦然
// 张量切片和操作 若A为列向量且长度与B的行数相同，则B的每一列均与A相加，反之亦然
slice(tensor, row_range, col_range) // 张量切片操作 示例
set(tensor, indices, values) // 设置张量元素值 输入 [10,20]+[[1,2],[3,4]]
set2(tensor, indices, values) // 张量元素累加赋值 (相当于 +=) 结果 [[11,22],[13,24]]
// 张量拼接 输入 [[10],[20]]+[[1,2],[3,4]]
horzcat(A, B, ...) // 横向拼接张量 结果 [[11,12],[23,24]]
vertcat(A, B, ...) // 纵向拼接张量
输入 [c(-3,-4),c(-1,-2)]+[[c(1,2),c(3,4)],[c(5,6),c(7,8)]]
// 序列生成 结果 [[c(-2,-2),c(2,2)],[c(2,2),c(6,6)]]
range(start, end) // 生成序列 [start, start+1, ..., end-1] (前闭后开)
linspace(start, end, num) // 在start和end间生成num个等间距点 输入 [2,3]+sparse([0,1,2],[1,0,1],[2,3,6], 3, 2)
结果 [[2,5],[5,3],[2,9]]
// 统计函数 ```
sum(tensor), mean(tensor), std(tensor), var(tensor) ##### 6.1.2.2 元素级减法
max(tensor), min(tensor), median(tensor) ```rustscript
//其中，max()和min()可以如下用法：max(a, [0],1)，min(a, [0],1)，参数和slice函数的定义相同 运算符
-
// 查找函数 语法
find(condition) // 查找满足条件的索引 A - B;
any(tensor), all(tensor) 输入参数
A - 矩阵
// 获取多个元素 B - 矩阵
get_multi(tensor, indices) // 根据索引获取多个元素(可不连续) 若A的形状与B的形状相同，对应元素相减
``` 若A为行向量且长度与B的列数相同，则B的每一行均与A相减，反之亦然
若A为列向量且长度与B的行数相同，则B的每一列均与A相减，反之亦然
### 9.4 稀疏矩阵 示例
```rustscript 输入 [10,20]-[[1,2],[3,4]]
// 创建稀疏矩阵 结果 [[9,18],[7,16]]
sparse(row_indices, col_indices, values, m, n); // 创建m×n稀疏矩阵，其中row_indices, col_indices, values是三个等长的向量，分别指定非零元素的行下标、列下标和值。
输入 [[10],[20]]-[[1,2],[3,4]]
// 稀疏矩阵操作 结果 [[9,8],[17,16]]
full_mat = full(sparse_mat); // 转为密集矩阵
nnz_count = nnz(sparse_mat); // 非零元素个数 输入 [[c(1,2),c(3,4)],[c(5,6),c(7,8)]]-[c(-3,-4),c(-1,-2)]
spy(sparse_mat); // 显示稀疏模式 结果 [[c(4,6),c(4,6)],[c(8,10),c(8,10)]]
```
输入 [2,3]-sparse([0,1,2],[1,0,1],[2,3,6], 3, 2)
### 9.5 张量操作详细示例 结果 [[2,1],[-1,3],[2,3]]
```rustscript ```
// 实际使用示例（来自make_y_bus函数） ##### 6.1.2.3 元素级乘法
nb = size(bus, 0); // 获取母线数量 ```rustscript
nl = size(branch, 0); // 获取支路数量 运算符
.*
// 切片操作 语法
stat = slice(branch, [0], [BR_STATUS-1, BR_STATUS]); // 获取支路状态列 A .* B;
Ys = stat ./ (slice(branch, [0], [BR_R-1, BR_R]) 输入参数
+ c(0,1) * slice(branch, [0], [BR_X-1, BR_X])); A - 矩阵
B - 矩阵
// 查找和设置操作 若A的形状与B的形状相同，对应元素相乘
index = find(tap_col); // 查找非零变比的索引 若A为行向量且长度与B的列数相同，则B的每一行均与A相乘，反之亦然
tap_init = set(ones(nl, 1), index, get_multi(tap_col, index)); 若A为列向量且长度与B的行数相同，则B的每一列均与A相乘，反之亦然
示例
// 序列生成和拼接 输入 [10,20].*[[1,2],[3,4]]
i = horzcat(range(0, nl), range(0, nl)) - 1; // 创建行索引 结果 [[10,40],[30,80]]
j = range(0, nb); // 创建列索引
输入 [[100],[200]].*[[1,2],[3,4]]
// 稀疏矩阵创建 结果 [[100,200],[600,800]]
Yf = sparse(i, horzcat(f, t), upper, nl, nb);
Ybus = sparse(horzcat(f,f,t,t), horzcat(f,t,f,t), 输入 [c(1,2),c(3,4)].*[c(5,6),c(7,8)]
vertcat(Yff,Yft,Ytf,Ytt), nb, nb); 结果 [c(-7,16),c(-11,52)]
```
输入 [2,3].*sparse([0,1,2],[1,0,1],[2,3,6], 3, 2)
## 10. 数据结构示例 结果 [[0,6],[6,0],[0,18]]
```
### 10.1 电力系统数据（基于 case14） ##### 6.1.2.4 元素级除法
```rustscript ```rustscript
// 系统基准功率 运算符
baseMVA = 100; ./
语法
// 母线数据 - 每行必须用[]包围，数字用逗号分隔 A ./ B;
bus = [ 输入参数
[1, 3, 0, 0, 0, 0, 1, 1.06, 0, 0, 1, 1.06, 0.94], A - 矩阵
[2, 2, 21.7, 12.7, 0, 0, 1, 1.045, -4.98, 0, 1, 1.06, 0.94], B - 矩阵
[3, 2, 94.2, 19, 0, 0, 1, 1.01, -12.72, 0, 1, 1.06, 0.94], 若A的形状与B的形状相同，对应元素相除
[4, 1, 47.8, -3.9, 0, 0, 1, 1.019, -10.33, 0, 1, 1.06, 0.94] 若A为行向量且长度与B的列数相同，则B的每一行均与A相除，反之亦然
]; 若A为列向量且长度与B的行数相同，则B的每一列均与A相除，反之亦然
示例
// 发电机数据 输入 [10,20]./[[1,2],[3,4]]
gen = [ 结果 [[10,10],[10/3, 5]]
[1, 232.4, -16.9, 10, 0, 1.06, 100, 1, 332.4, 0],
[2, 40, 42.4, 50, -40, 1.045, 100, 1, 140, 0], 输入 [[100],[200]]./[[1,2],[3,4]]
[3, 0, 23.4, 40, 0, 1.01, 100, 1, 100, 0] 结果 [[100,50],[200/3,50]]
];
输入 [c(-7,16),c(-11,52)]./[c(5,6),c(7,8)]
// 支路数据 结果 [c(1,2),c(3,4)]
branch = [
[1, 2, 0.01938, 0.05917, 0.0528, 0, 0, 0, 0, 0, 1, -360, 360], 输入 sparse([0,1,2],[1,0,1],[2,3,6], 3, 2)./[2,3]
[1, 5, 0.05403, 0.22304, 0.0492, 0, 0, 0, 0, 0, 1, -360, 360], 结果 [[0,2/3],[1.5,0],[0,2]]
[2, 3, 0.04699, 0.19797, 0.0438, 0, 0, 0, 0, 0, 1, -360, 360] ```
]; ##### 6.1.2.5 元素级幂运算
``` ```rustscript
运算符
## 11. 模块系统 .^
语法
### 11.1 模块导入 A .^ n;
```rustscript 输入参数
// 导入整个模块 A - 矩阵
import power_flow; n - 标量
示例
// 导入特定函数 输入 [[1,2],[3,4]].^(-1)
import {newton_pf, fast_decoupled_pf} from power_flow; 结果 [[1,0.5], [1/3.,0.25]]
// 别名导入 输入 [c(1,2),c(3,4)].^3
import newton_pf as newton from power_flow; 结果 [c(-3,4),c(-7,24)]
```
输入 sparse([0,1,2],[1,0,1],[2,3,6], 3, 2).^3
### 11.2 模块定义 结果 [[3, 2, 0], [0, 1, 8], [1, 0, 27], [2, 1, 216]]
```rustscript ```
// 模块文件: power_flow.rs ##### 6.1.2.6 元素级模运算
export fn newton_pf(baseMVA, bus, gen, branch) { ```rustscript
// 实现牛顿拉夫逊潮流计算 运算符
} %
语法
export fn fast_decoupled_pf(baseMVA, bus, gen, branch) { A % B;
// 实现快速解耦潮流计算 输入参数
} A - 矩阵
``` B - 矩阵
若A的形状与B的形状相同，对应元素相模
若A为行向量且长度与B的列数相同，则B的每一行均与A相模，反之亦然
## 12. 与MATLAB的对比 若A为列向量且长度与B的行数相同，则B的每一列均与A相模，反之亦然
示例
### 12.1 主要差异 输入 [10,20]%[[2,3],[4,5]]
结果 [[0,2],[2,0]]
| 特性 | MATLAB | RustScript | 说明 |
|------|---------------------|-----------------------|------| 输入 [[11],[21]]%[[2,3],[4,5]]
| 索引基数 | 1基索引 `A(1,2)` | 0基索引 `A[0,1]` | **重要差异：索引从不同位置开始** | 结果 [[1, 2],[1, 1]]
| 矩阵定义 | `[1 2; 3 4]` | `[[1, 2], [3, 4]]` | 分号分行，逗号分元素 |
| 序列生成 | `0:n-1` | `range(0, n)` | MATLAB包含端点，RustScript前闭后开 | 输入 [7,9]%sparse([0,0,1,1],[0,1,0,1],[2,3,4,6], 2, 2)
| 注释 | `% 注释` | `// 注释` | 注释符号不同 | 结果 [[1,0],[3,3]]
| 字符串 | `'string'` | `"string"` | 引号类型不同 | ```
| 函数定义 | `function y = f(x)` | `fn f(x){ return y;}` | 函数语法不同 | #### 6.1.3 矩阵运算
| 逻辑运算 | `&`, `\|`, `~` | `&&`, `\|\|`, `~~` | 逻辑运算符不同 | ##### 6.1.3.1 矩阵加法
| 结构体 | `struct` | 无结构体，使用张量和变量组织 | RustScript没有结构体概念 | ```rustscript
运算符
### 12.2 索引转换详解 +
语法
**最重要的差异：MATLAB使用1基索引，RustScript使用0基索引** A + B;
输入参数
```matlab A - 矩阵
% MATLAB (1基索引) B - 矩阵
A(1, 1) % 第一个元素 A与B的形状相同
A(1:3, 2) % 第1到3行，第2列 示例
bus(:, i) % 第i列所有行 输入 [[1,2],[3,4]]+[[5,6],[7,8]]
0:n-1 % 生成 [0, 1, 2, ..., n-1] 结果 [[6,8],[10,12]]
```
输入 [[c(-3, -4), c(-1, -2)],[c(-7, -8), c(-5, -6)]]+
```rustscript [[c(1, 2), c(3, 4)],[c(5, 6), c(7, 8)]]
// RustScript (0基索引) 结果 [[c(-2, -2), c(2, 2)],[c(-2, -2), c(2, 2)]]
A[0, 0] // 第一个元素
slice(A, [0,3], [1]) // 第1到3行（0,1,2），第2列（索引1） 输入 [[1,2],[3,4]]+sparse([0,1],[1,0],[2., 3.], 2, 2)
slice(bus, [0], [i-1,i]) // 第i列所有行（需要减1） 结果 [[1,4],[6,4]]
range(0, n) // 生成 [0, 1, 2, ..., n-1] (前闭后开)
``` 输入 sparse([0,1,2],[1,0,1],[2,3,6],3,2)+sparse([0,1,2],[0,0,0],[2,4,6],3,2)
结果 [[3, 2, 0], [0, 0, 2], [0, 1, 2], [1, 0, 7], [2, 0, 6], [2, 1, 6]]
### 12.3 转换示例对比 ```
##### 6.1.3.2 矩阵减法
**MATLAB到RustScript的典型转换：** ```rustscript
运算符
```matlab -
% MATLAB版本 语法
function Ybus = make_y_bus(baseMVA, bus, branch) A - B;
nb = size(bus, 1); % 获取行数 输入参数
f = branch(:, F_BUS); % 从母线 A - 矩阵
t = branch(:, T_BUS); % 到母线 B - 矩阵
A与B的形状相同
% 创建索引（1基） 示例
i = [1:nl, 1:nl]; 输入 [[1,2],[3,4]]-[[7,8],[5,6]]
j = 1:nb; 结果 [[-6,-6],[-2,-2]]
% 稀疏矩阵（MATLAB自动处理1基索引） 输入 [[c(-3, -4), c(-1, -2)],[c(-7, -8), c(-5, -6)]]-
Ybus = sparse(i, j, values, nb, nb); [[c(1, 2), c(3, 4)],[c(5, 6), c(7, 8)]]
end 结果 [[c(-4, -6), c(-4, -6)],[c(-12, -14), c(-12, -14)]]
```
输入 [[1,2],[3,4]]-sparse([0,1],[1,0],[2,3], 2, 2)
```rustscript 结果 [[1,0],[0,4]]
// RustScript版本
fn make_y_bus(baseMVA, bus, branch) { 输入 sparse([0,1,2],[1,0,1],[2,3,6],3,2)-sparse([0,1,2],[0,0,0],[2,4,6],3,2)
nb = size(bus, 0); // 获取行数 结果 [[3, 2, 0], [0, 0, -2], [0, 1, 2], [1, 0, -1], [2, 0, -6], [2, 1, 6]]
f = slice(branch, [0], [F_BUS-1]) - 1; // 从母线（转换为0基） ```
t = slice(branch, [0], [T_BUS-1]) - 1; // 到母线（转换为0基） ##### 6.1.3.3 矩阵标量乘法
```rustscript
// 创建索引（0基） 运算符
i = horzcat(range(0, nl), range(0, nl)); *
j = range(0, nb); 语法
n * A;
// 稀疏矩阵（显式使用0基索引） A * n;
Ybus = sparse(i, j, values, nb, nb); 输入参数
return Ybus; n - 标量
} A - 矩阵
``` 示例
输入 2*[[3],[2]]
### 12.4 转换器的索引处理策略 结果 [[6],[4]]
在MATLAB到RustScript转换过程中，转换器需要特别处理索引： 输入 c(1,2)*[c(1,2),c(3,4)]
结果 [c(-3,4),c(-5,10)]
**Case文件转换（保持原始索引）：**
- Case文件通常包含数据定义，索引值保持不变 输入 2*sparse([1,2],[1,2],[2,3], 3, 3)
- 例如：母线编号仍然是1, 2, 3... 结果 [[3,3,0],[1,1,4],[2,2,6]]
```
**函数转换（转换为0基索引）：** ##### 6.1.3.4 矩阵标量除法
- 函数中的索引操作需要转换：`A(i)` → `A[i-1]` ```rustscript
- 循环变量需要调整：`for i = 1:n` → `for i in range(0, n)` 运算符
- 序列生成需要转换：`1:n` → `range(1, n+1)` 或 `range(0, n)` /
语法
A / n;
输入参数
A - 矩阵
n - 标量
示例
输入 [[3],[2]]/2
结果 [[1.5],[1]]
输入 [c(1,2),c(3,4)]/c(1,2)
结果 [c(1,0),c(0.44,0.08)]
输入 sparse([1,2],[1,2],[2,3], 3, 3)/2
结果 [[3,3,0],[1,1,1],[2,2,1.5]]
```
##### 6.1.3.5 矩阵乘法
```rustscript
运算符
*
语法
A * B;
输入参数
A - 矩阵
B - 矩阵
A的列数需与B的行数相同
示例
输入 [[1,2,3],[4,5,6]]*[[1,2],[3,4],[5,6]]
结果 [[22,28], [49,64]]
输入 [[c(1, 2), c(3, 4), c(5, 6)],[c(7, 8), c(9, 10), c(11, 12)]]*
[[c(1, 2), c(3, 4)],[c(5, 6), c(7, 8)],[c(9, 10), c(11, 12)]]
结果 [[c(-27, 146), c(-33, 188)],[c(-45, 344), c(-51, 458)]]
输入 [[1,2,3],[4,5,6]]*sparse([0,1,2],[1,0,1],[2.0, 3.0, 6.0], 3, 2)
结果 [[6, 20], [15, 44]]
输入 sparse([0,1,2],[1,0,1],[2.0, 3.0, 6.0], 3, 2)*sparse([0,1,1],[1,0,2],[2.0, 4.0, 6.0], 2, 3)
结果 [[3, 3, 0], [0, 0, 8], [0, 2, 12], [1, 1, 6], [2, 0, 24], [2, 2, 36]]
```
##### 6.1.3.6 矩阵右除
```rustscript
运算符
/
语法
A / B;
输入参数
A - 矩阵
B - 方阵
A的列数需与B的行数相同
示例
输入 [[19,22],[43,50]]/[[1,2],[3,4]]
结果 [[-5,8],[-11,18]]
输入 [[c(-548, 232), c(-812, 384)],[c(-1236, 664), c(-1820, 1072)]]/
[[c(1, 2), c(3, 4)],[c(5, 6), c(7, 8)]]
结果 [[c(-12, 42), c(-16, 62)],[c(-20, 98), c(-24, 150)]]
输入 [[19,22],[43,50]]/sparse([0,0,1,1],[0,1,0,1],[1, 2, 3, 4], 2, 2)
结果 [[-5,8],[-11,18]]
输入 sparse([0,0,1,1],[0,1,0,1],[19,22,43,50], 2, 2)/sparse([0,0,1,1],[0,1,0,1],[1,2,3,4], 2, 2)
结果 [[2, 2, 0], [0, 0, -5], [0, 1, 8], [1, 0, -11], [1, 1, 18]]
```
##### 6.1.3.7 矩阵左除
```rustscript
运算符
\
语法
A \ B;
输入参数
A - 方阵
B - 矩阵
A的列数需与B的行数相同
示例
输入 [[2,1],[1,-3]]\[[5],[-1]]
结果 [[2],[1]]
输入 [[c(-12, 42), c(-16, 62)],[c(-20, 98), c(-24, 150)]]\
[[c(-548, 232), c(-812, 384)],[c(-1236, 664), c(-1820, 1072)]]
结果 [[c(1, 2), c(3, 4)],[c(5, 6), c(7, 8)]]
输入 sparse([0,0,1,1],[0,1,0,1],[2,1,1,-3], 2, 2)\[[5],[-1]]
结果 [[2],[1]]
输入 sparse([0,0,1,1],[0,1,0,1],[2,1,1,-3], 2, 2)\sparse([0,1],[0,0],[5,-1], 2, 1)
结果 [[2, 1, 0], [0, 0, 2], [1, 0, 1]]
```
##### 6.1.3.8 矩阵幂
```rustscript
运算符
^
语法
A ^ n;
输入参数
A - 方阵
n - 标量
示例
输入 [[1,2],[3,4]]^0
结果 [[1,0], [0,1]]
输入 [[c(1, 2), c(3, 4)],[c(5, 6), c(7, 8)]]^3
结果 [[c(-548, 232), c(-812, 384)],[c(-1236, 664), c(-1820, 1072)]]
输入 [[1,2],[3,4]]^(-1)
结果 [[-2, 1], [1.5, -0.5]]
输入 sparse([0,1,2],[1,0,1],[2, 3, 6], 3, 3)^3
结果 [[3, 3, 0], [0, 1, 12], [1, 0, 18], [2, 1, 36]]
```
##### 6.1.3.9 转置
```rustscript
运算符
'
语法
A';
输入参数
A - 矩阵
示例
输入 [1, 2, 3]'
结果 [[1], [2], [3]]
输入 [[c(1, 1), c(2, 2)], [c(3, 3), c(4, 4)]]'
结果 [[c(1, 1), c(3, 3)], [c(2, 2), c(4, 4)]]
输入 sparse([0,1,2], [1,0,1], [2, 3, 6], 3, 2)'
结果 [[2, 3, 0], [1, 0, 2], [0, 1, 3], [1, 2, 6]]
```
##### 6.1.3.10 逆矩阵
```rustscript
运算符
^(-1)
语法
A ^ (-1);
输入参数
A - 方阵
示例
输入 [[1,2],[3,4]]^(-1)
结果 [[-2, 1], [1.5, -0.5]]
```
##### 6.1.3.11 行列式
```rustscript
函数
det
语法
det(A);
输入参数
A - 方阵
示例
输入 det([[1,2],[3,4]])
结果 -2
输入 det([[c(1,2),c(3,4)],[c(5,6),c(7,8)]])
结果 c(0,-16)
```
### 6.2 比较运算符
#### 6.2.1 等于
```rustscript
运算符
==
语法
A == B;
输入参数
A - 张量或标量
B - 张量或标量
若A、B均为张量，A、B形状应相同
对于复数，取实部进行比较
返回参数
若A为标量、B为张量，则返回与B形状相同的张量，其中元素为A与B对应元素的比较结果
若A为张量、B为标量，则返回与A形状相同的张量，其中元素为A对应元素与B的比较结果
若A、B均为张量，则返回与二者形状相同的张量，其中元素为A对应元素与B对应元素的比较结果
示例
输入 [[1, 2, 3], [4, 5, 6], [7, 8, 9]]==5
结果 [[0,0,0],[0,1,0],[0,0,0]]
输入 [[1, 2, 3], [4, 5, 6], [7, 8, 9]]==[[2, 2, 2], [4, 4, 4], [9, 9, 9]]
结果 [[0,1,0],[1,0,0],[0,0,1]]
输入 [[c(1,9), c(2,8), c(3,7)],[c(4,6), c(5,5), c(6,4)],[c(7,3), c(8,2), c(9,1)]]==c(4,5)
结果 [[c(0,0), c(0,0), c(0,0)],[c(1,0), c(0,0), c(0,0)],[c(0,0), c(0,0), c(0,0)]]
```
#### 6.2.2 不等于
```rustscript
运算符
!=
语法
A != B;
输入参数
A - 张量或标量
B - 张量或标量
若A、B均为张量，A、B形状应相同
对于复数，取实部进行比较
返回参数
若A为标量、B为张量，则返回与B形状相同的张量，其中元素为A与B对应元素的比较结果
若A为张量、B为标量，则返回与A形状相同的张量，其中元素为A对应元素与B的比较结果
若A、B均为张量，则返回与二者形状相同的张量，其中元素为A对应元素与B对应元素的比较结果
示例
输入 [[1, 2, 3], [4, 5, 6], [7, 8, 9]]!=5
结果 [[1,1,1],[1,0,1],[1,1,1]]
输入 [[1, 2, 3], [4, 5, 6], [7, 8, 9]]!=[[2, 2, 2], [4, 4, 4], [9, 9, 9]]
结果 [[1,0,1],[0,1,1],[1,1,0]]
输入 [[c(1,9), c(2,8), c(3,7)],[c(4,6), c(5,5), c(6,4)],[c(7,3), c(8,2), c(9,1)]]!=c(4,5)
结果 [[c(1,0), c(1,0), c(1,0)],[c(0,0), c(1,0), c(1,0)],[c(1,0), c(1,0), c(1,0)]]
```
#### 6.2.3 小于
```rustscript
运算符
<
语法
A < B;
输入参数
A - 张量或标量
B - 张量或标量
若A、B均为张量，A、B形状应相同
对于复数，取实部进行比较
返回参数
若A为标量、B为张量，则返回与B形状相同的张量，其中元素为A与B对应元素的比较结果
若A为张量、B为标量，则返回与A形状相同的张量，其中元素为A对应元素与B的比较结果
若A、B均为张量，则返回与二者形状相同的张量，其中元素为A对应元素与B对应元素的比较结果
示例
输入 [[1, 2, 3], [4, 5, 6], [7, 8, 9]]<5
结果 [[1,1,1],[1,0,0],[0,0,0]]
输入 [[1, 2, 3], [4, 5, 6], [7, 8, 9]]<[[2, 2, 2], [4, 4, 4], [9, 9, 9]]
结果 [[1,0,0],[0,0,0],[1,1,0]]
输入 [[c(1,9), c(2,8), c(3,7)],[c(4,6), c(5,5), c(6,4)],[c(7,3), c(8,2), c(9,1)]]<c(4,5)
结果 [[c(1,0), c(1,0), c(1,0)],[c(0,0), c(0,0), c(0,0)],[c(0,0), c(0,0), c(0,0)]]
```
#### 6.2.4 小于等于
```rustscript
运算符
<=
语法
A <= B;
输入参数
A - 张量或标量
B - 张量或标量
若A、B均为张量，A、B形状应相同
对于复数，取实部进行比较
返回参数
若A为标量、B为张量，则返回与B形状相同的张量，其中元素为A与B对应元素的比较结果
若A为张量、B为标量，则返回与A形状相同的张量，其中元素为A对应元素与B的比较结果
若A、B均为张量，则返回与二者形状相同的张量，其中元素为A对应元素与B对应元素的比较结果
示例
输入 [[1, 2, 3], [4, 5, 6], [7, 8, 9]]<=5
结果 [[1,1,1],[1,1,0],[0,0,0]]
输入 [[1, 2, 3], [4, 5, 6], [7, 8, 9]]<=[[2, 2, 2], [4, 4, 4], [9, 9, 9]]
结果 [[1,1,0],[1,0,0],[1,1,1]]
输入 [[c(1,9), c(2,8), c(3,7)],[c(4,6), c(5,5), c(6,4)],[c(7,3), c(8,2), c(9,1)]]<=c(4,5)
结果 [[c(1,0), c(1,0), c(1,0)],[c(1,0), c(0,0), c(0,0)],[c(0,0), c(0,0), c(0,0)]]
```
#### 6.2.5 大于
```rustscript
运算符
>
语法
A > B;
输入参数
A - 张量或标量
B - 张量或标量
若A、B均为张量，A、B形状应相同
对于复数，取实部进行比较
返回参数
若A为标量、B为张量，则返回与B形状相同的张量，其中元素为A与B对应元素的比较结果
若A为张量、B为标量，则返回与A形状相同的张量，其中元素为A对应元素与B的比较结果
若A、B均为张量，则返回与二者形状相同的张量，其中元素为A对应元素与B对应元素的比较结果
示例
输入 [[1, 2, 3], [4, 5, 6], [7, 8, 9]]>5
结果 [[0,0,0],[0,0,1],[1,1,1]]
输入 [[1, 2, 3], [4, 5, 6], [7, 8, 9]]>[[2, 2, 2], [4, 4, 4], [9, 9, 9]]
结果 [[0,0,1],[0,1,1],[0,0,0]]
输入 [[c(1,9), c(2,8), c(3,7)],[c(4,6), c(5,5), c(6,4)],[c(7,3), c(8,2), c(9,1)]]>c(4,5)
结果 [[c(0,0), c(0,0), c(0,0)],[c(0,0), c(1,0), c(1,0)],[c(1,0), c(1,0), c(1,0)]]
```
#### 6.2.6 大于等于
```rustscript
运算符
>=
语法
A >= B;
输入参数
A - 张量或标量
B - 张量或标量
若A、B均为张量，A、B形状应相同
对于复数，取实部进行比较
返回参数
若A为标量、B为张量，则返回与B形状相同的张量，其中元素为A与B对应元素的比较结果
若A为张量、B为标量，则返回与A形状相同的张量，其中元素为A对应元素与B的比较结果
若A、B均为张量，则返回与二者形状相同的张量，其中元素为A对应元素与B对应元素的比较结果
示例
输入 [[1, 2, 3], [4, 5, 6], [7, 8, 9]]>=5
结果 [[0,0,0],[0,1,1],[1,1,1]]
输入 [[1, 2, 3], [4, 5, 6], [7, 8, 9]]>=[[2, 2, 2], [4, 4, 4], [9, 9, 9]]
结果 [[0,1,1],[1,1,1],[0,0,1]]
输入 [[c(1,9), c(2,8), c(3,7)],[c(4,6), c(5,5), c(6,4)],[c(7,3), c(8,2), c(9,1)]]>=c(4,5)
结果 [[c(0,0), c(0,0), c(0,0)],[c(1,0), c(1,0), c(1,0)],[c(1,0), c(1,0), c(1,0)]]
```
### 6.3 逻辑运算符
#### 6.3.1 逻辑与
```rustscript
运算符
&&
语法
A && B;
输入参数
A - 张量或标量
B - 张量或标量
若A、B均为张量，A、B形状应相同
对于复数，取实部进行逻辑运算
返回参数
若A为标量、B为张量，则返回与B形状相同的张量，其中元素为A与B对应元素的逻辑运算结果
若A为张量、B为标量，则返回与A形状相同的张量，其中元素为A对应元素与B的逻辑运算结果
若A、B均为张量，则返回与二者形状相同的张量，其中元素为A对应元素与B对应元素的逻辑运算结果
示例
输入 [[1, 0, 3], [0, 5, 6], [7, 0, 9]]&&5
结果 [[1,0,1],[0,1,1],[1,0,1]]
输入 [[1, 0, 3], [0, 5, 6], [7, 0, 9]]&&[[2, 0, 0], [0, 4, 0], [0, 0, 9]]
结果 [[1,0,0],[0,1,0],[0,0,1]]
输入 [[c(1,9), c(0,8), c(0,7)],[c(0,6), c(5,5), c(0,4)],[c(0,3), c(0,2), c(9,1)]]&&c(4,5)
结果 [[c(1,0), c(0,0), c(0,0)],[c(0,0), c(1,0), c(0,0)],[c(0,0), c(0,0), c(1,0)]]
```
#### 6.3.2 逻辑或
```rustscript
运算符
||
语法
A || B;
输入参数
A - 张量或标量
B - 张量或标量
若A、B均为张量，A、B形状应相同
对于复数，取实部进行逻辑运算
返回参数
若A为标量、B为张量，则返回与B形状相同的张量，其中元素为A与B对应元素的逻辑运算结果
若A为张量、B为标量，则返回与A形状相同的张量，其中元素为A对应元素与B的逻辑运算结果
若A、B均为张量，则返回与二者形状相同的张量，其中元素为A对应元素与B对应元素的逻辑运算结果
示例
输入 [[1, 0, 3], [0, 5, 6], [7, 0, 9]]||5
结果 [[1,1,1],[1,1,1],[1,1,1]]
输入 [[1, 0, 3], [0, 5, 6], [7, 0, 9]]||[[2, 0, 0], [0, 4, 0], [0, 0, 9]]
结果 [[1,0,1],[0,1,1],[1,0,1]]
输入 [[c(1,9), c(0,8), c(0,7)],[c(0,6), c(5,5), c(0,4)],[c(0,3), c(0,2), c(9,1)]]||c(4,5)
结果 [[c(1,0), c(1,0), c(1,0)],[c(1,0), c(1,0), c(1,0)],[c(1,0), c(1,0), c(1,0)]]
```
#### 6.3.3 逻辑非
```rustscript
运算符
~~
语法
~~A;
输入参数
A - 张量或标量，对于复数，取实部进行逻辑运算
示例
输入 ~~[[1, 0, 3], [0, 5, 6], [7, 0, 9]]
结果 [[0,1,0],[1,0,0],[0,1,0]]
输入 ~~[[c(1,9), c(0,8), c(0,7)],[c(0,6), c(5,5), c(0,4)],[c(0,3), c(0,2), c(9,1)]]
结果 [[c(0,0), c(1,0), c(1,0)],[c(1,0), c(0,0), c(1,0)],[c(1,0), c(1,0), c(0,0)]]
电力系统实际使用示例
bus_gen_status = ~~bus_gen_status; // 逻辑非运算
pq = find(bus_type == PQ || ~~bus_gen_status); // 组合逻辑运算
```
### 6.4 位运算符
#### 6.4.1 位与
```rustscript
运算符
&
语法
a & b;
输入参数
a - 标量
b - 标量
对于复数，取实部进行位运算
示例
输入 5&3
结果 1
输入 c(6, 8)&c(4, 5)
结果 c(4,0)
```
#### 6.4.2 位或
```rustscript
运算符
|
语法
a | b;
输入参数
a - 标量
b - 标量
对于复数，取实部进行位运算
示例
输入 5|3
结果 7
输入 c(6, 8)|c(4, 5)
结果 c(6,0)
```
#### 6.4.3 位异或
```rustscript
运算符
^^
语法
a ^^ b;
输入参数
a - 标量
b - 标量
对于复数，取实部进行位运算
示例
输入 5^^3
结果 6
输入 c(6, 8)^^c(4, 5)
结果 c(2,0)
```
#### 6.4.4 位取反
```rustscript
运算符
~
语法
~a;
输入参数
a - 标量，对于复数，取实部进行位运算
示例
输入 ~5
结果 -6
输入 ~c(6, 8)
结果 c(-7,0)
```
#### 6.4.5 位左移
```rustscript
运算符
<<
语法
a << b;
输入参数
a - 标量
b - 标量
对于复数，取实部进行位运算
示例
输入 5<<1
结果 10
输入 c(6, 8)<<c(2, 5)
结果 c(24,0)
```
#### 6.4.6 位右移
```rustscript
运算符
>>
语法
a >> b;
输入参数
a - 标量
b - 标量
对于复数，取实部进行位运算
示例
输入 5>>1
结果 2
输入 c(6, 8)>>c(2, 5)
结果 c(1,0)
```
#### 6.4.7 位取值
```rustscript
运算符
@
语法
a @ b;
输入参数
a - 标量
b - 标量
对于复数，取实部进行位运算
示例
输入 5@1
结果 1
输入 c(5, 8)@c(2, 5)
结果 c(0,0)
```
## 7. 基本编程语句
### 7.1 条件语句
```rustscript
//if语句
if a ==1{
b = b+1;
}
//if-else语句
if a ==1{
b = b+1;
}else{
b = b+2;
}
//if-elseif-else语句
if a == 0{
b = b + 1;
}else if a == 1{
b = b + 2;
}else{
b = b + 3;
}
```
### 7.2 循环语句
```rustscript
//for语句
for i in 0..10 {
r = runpf();
}
```
## 8. 函数定义
### 8.1 基本函数语法
```rustscript
fn function_name(param1, param2, ...) {
// 函数体
return result;
}
// 简化返回语法（最后一个表达式作为返回值）
fn add(a, b) {
a + b
}
```
**重要限制：RustScript函数只能返回一个变量，不支持多返回值。**
### 8.2 函数示例
```rustscript
fn make_y_bus(baseMVA, bus, branch) {
nb = size(bus, 0);
nl = size(branch, 0);
// 计算导纳矩阵
stat = slice(branch, [0], [BR_STATUS-1, BR_STATUS]);
Ys = stat ./ (slice(branch, [0], [BR_R-1, BR_R])
+ c(0,1) * slice(branch, [0], [BR_X-1, BR_X]));
return Ys; // 只能返回一个值
}
```
## 9. 内置函数
### 9.1 数学函数
### 9.1.1 根号函数
```rustscript
函数
sqrt
语法
sqrt(x);
输入参数
x - 矩阵或标量，若为矩阵对每个元素分别进行计算
示例
输入 sqrt([[1,4],[9,16])
结果 [[1,2], [3,4]]
输入 [c(-3,4), c(-7,24)]
结果 [c(1,2), c(3,4)]
输入 sqrt(sparse([0,1,2],[1,0,1],[4.,9.,36.], 3, 2))
结果 [[3, 2, 0], [0, 1, 2], [1, 0, 3], [2, 1, 6]]
```
### 9.1.2 自然指数函数
```rustscript
函数
exp
语法
exp(x);
输入参数
x - 矩阵或标量，若为稠密矩阵对每个元素分别进行计算，若为稀疏矩阵仅对非零元进行计算
示例
输入 exp([[1,2],[3,4]])
结果 [[e,e^2],[e^3,e^4]]
输入 exp([c(1., pi/2), c(2, pi)])
结果 [c(0, e), c(-e^2, 0)]
输入 exp(sparse([0,0],[0,1],[1,2], 2, 2))
结果 [[2, 2, 0], [0, 0, e], [0, 1, e^2]]
```
### 9.1.3 自然对数函数
```rustscript
函数
ln
语法
ln(x);
输入参数
x - 矩阵或标量，若为矩阵对每个元素分别进行计算，若为稀疏矩阵仅对非零元进行计算
示例
输入 ln([[1,e],[e^2,e^3]])
结果 [[0,1],[2,3]]
输入 ln([c(0,e), c(-e^2,0)])
结果 [c(1, pi/2), c(2, pi)]
输入 ln(sparse([0,0],[0,1],[1,e], 2, 2))
结果 [[2, 2, 0], [0, 0, 0], [0, 1, 1]]
```
### 9.1.4 常用对数函数
```rustscript
函数
log10
语法
log10(x);
输入参数
x - 矩阵或标量，若为矩阵对每个元素分别进行计算，若为稀疏矩阵仅对非零元进行计算
示例
输入 log10([[1,10],[100,1000]])
结果 [[0.,1.],[2.,3.]]
输入 log10([c(0, 10), c(-100, 0)])
结果 [c(1, 0.0.682188), c(2, 1.364376)]
输入 log10(sparse([0,0],[0,1],[1,10], 2, 2))
结果 [[2, 2, 0], [0, 0, 0], [0, 1, 1]]
```
### 9.1.5 正弦函数
```rustscript
函数
sin
语法
sin(x);
输入参数
x - 矩阵或标量，若为矩阵对每个元素分别进行计算，若为稀疏矩阵仅对非零元进行计算
示例
输入 sin([[0,pi/6],[pi/2,pi]])
结果 [[0,0.5],[1,0]]
输入 sin([c(1, 1), c(0, 1)])
结果 [c(1.298458, 0.634964), c(0, 1.175201)]
输入 sin(sparse([0,0],[0,1],[pi/6,pi/2], 2, 2))
结果 [[2, 2, 0], [0, 0, 0.5], [0, 1, 1]]
```
### 9.1.6 余弦函数
```rustscript
函数
cos
语法
cos(x);
输入参数
x - 矩阵或标量，若为矩阵对每个元素分别进行计算，若为稀疏矩阵仅对非零元进行计算
示例
输入 cos([[0,pi/3],[pi/2,pi]])
结果 [[1,0.5],[0,-1]]
输入 cos([c(1, 1), c(0, 1)])
结果 [c(0.833730, -0.988898), c(1.543081, 0)]
输入 cos(sparse([0,0],[0,1],[pi/3,pi/2], 2, 2))
结果 [[2, 2, 0], [0, 0, 0.5], [0, 1, 0]]
```
### 9.1.7 正切函数
```rustscript
函数
tan
语法
tan(x);
输入参数
x - 矩阵或标量，若为矩阵对每个元素分别进行计算，若为稀疏矩阵仅对非零元进行计算
示例
输入 tan([[0,pi/4],[0.75*pi,pi]])
结果 [[0,1],[-1,0]]
输入 tan([c(1, 1), c(0, 1)])
结果 [c(0.271753, 1.083923), c(0, 0.761594)]
输入 tan(sparse([0,0],[0,1],[pi/4,0.75*pi], 2, 2))
结果 [[2, 2, 0], [0, 0, 1], [0, 1, -1]]
```
### 9.1.8 反正弦函数
```rustscript
函数
asin
语法
asin(x);
输入参数
x - 矩阵或标量，若为矩阵对每个元素分别进行计算，若为稀疏矩阵仅对非零元进行计算
示例
输入 asin([[0,0.5],[1,-0.5]])
结果 [[0,pi/6],[pi/2,-pi/6]]
输入 asin([c(2, 0), c(0, 1)])
结果 [c(pi/2, -ln(2+sqrt(3))), c(0, -ln(sqrt(2)-1))]
输入 asin(sparse([0,0],[0,1],[0.5,1], 2, 2))
结果 [[2, 2, 0], [0, 0, pi/6], [0, 1, pi/2]]
```
### 9.1.9 反余弦函数
```rustscript
函数
acos
语法
acos(x);
输入参数
x - 矩阵或标量，若为矩阵对每个元素分别进行计算，若为稀疏矩阵仅对非零元进行计算
示例
输入 acos([[1,0.5],[0,-1]])
结果 [[0,pi/3],[pi/2,pi]]
输入 acos([c(2, 0), c(0, 1)])
结果 [c(0, -ln(2+sqrt(3))), c(0, -ln(sqrt(2)+1))]
输入 acos(sparse([0,0],[0,1],[0.5,0], 2, 2))
结果 [[2, 2, 0], [0, 0, pi/3], [0, 1, pi/2]]
```
### 9.1.10 反正切函数
```rustscript
函数
atan
语法
atan(x);
输入参数
x - 矩阵或标量，若为矩阵对每个元素分别进行计算，若为稀疏矩阵仅对非零元进行计算
示例
输入 atan([[0,1],[-1,sqrt(3)]])
结果 [[0,pi/4],[-pi/4,pi/3]]
输入 atan([c(1, 0), c(1, 1)])
结果 [c(pi/4, 0), c(1.017222, 0.402359)]
输入 atan(sparse([0,0],[0,1],[1,-1], 2, 2))
结果 [[2, 2, 0], [0, 0, pi/4], [0, 1, -pi/4]]
```
### 9.1.11 双曲正弦函数
```rustscript
函数
sinh
语法
sinh(x);
输入参数
x - 矩阵或标量，若为矩阵对每个元素分别进行计算，若为稀疏矩阵仅对非零元进行计算
示例
输入 sinh([[0,1],[-2,ln(3+sqrt(10))]])
结果 [[0,1.175201],[-3.626860,3]]
输入 sinh([c(1, 1), c(0, pi)])
结果 [c(0.634964, 1.298458), c(0, 0)]
输入 sinh(sparse([0,0],[0,1],[1,-2], 2, 2))
结果 [[2, 2, 0], [0, 0, 1.175201], [0, 1, -3.626860]]
```
### 9.1.12 双曲余弦函数
```rustscript
函数
cosh
语法
cosh(x);
输入参数
x - 矩阵或标量，若为矩阵对每个元素分别进行计算，若为稀疏矩阵仅对非零元进行计算
示例
输入 cosh([[0,1],[-0.5,ln(2+sqrt(3))]])
结果 [[1.,1.543081],[1.127626,2]]
输入 cosh([c(1, 1), c(0, 1)])
结果 [c(0.833730, 0.988898), c(0.540302, 0)]
输入 cosh(sparse([0,0],[0,1],[1,-0.5], 2, 2))
结果 [[2, 2, 0], [0, 0, 1.543081], [0, 1, 1.127626]]
```
### 9.1.13 双曲正切函数
```rustscript
函数
tanh
语法
tanh(x);
输入参数
x - 矩阵或标量，若为矩阵对每个元素分别进行计算，若为稀疏矩阵仅对非零元进行计算
示例
输入 tanh([[0,1],[-2,ln(3)]])
结果 [[0,0.761594],[-0.964028,0.8]]
输入 tanh([c(1, 1), c(0, 1)])
结果 [c(1.083923, 0.271753), c(0, 1.557408)]
输入 tanh(sparse([0,0],[0,1],[1,ln(3)], 2, 2))
结果 [[2, 2, 0], [0, 0, 0.761594], [0, 1, 0.8]]
```
### 9.1.14 双曲反正弦函数
```rustscript
函数
asinh
语法
asinh(x);
输入参数
x - 矩阵或标量，若为矩阵对每个元素分别进行计算，若为稀疏矩阵仅对非零元进行计算
示例
输入 asinh([[0,1],[-2,3]])
结果 [[0, 0.881374],[-1.443635, ln(3+sqrt(10))]]
输入 asinh([c(1, 1), c(0, 1)])
结果 [c(1.061275, 0.666239), c(0, pi/2)]
输入 asinh(sparse([0,0],[0,1],[1,-2], 2, 2))
结果 [[2, 2, 0], [0, 0, 0.881374], [0, 1, -1.443635]]
```
### 9.1.15 双曲反余弦函数
```rustscript
函数
acosh
语法
acosh(x);
输入参数
x - 矩阵或标量，若为矩阵对每个元素分别进行计算，若为稀疏矩阵仅对非零元进行计算
示例
输入 acosh([[1,2],[cosh(3),5]])
结果 [[0,1.316958],[3,ln(5+2*sqrt(6))]]
输入 acosh([c(0, 0), c(0, 1)])
结果 [c(0, pi/2), c(0.881374, pi/2)]
输入 acosh(sparse([0,0],[0,1],[2,cosh(3)], 2, 2))
结果 [[2, 2, 0], [0, 0, 1.316958], [0, 1, 3]]
```
### 9.1.16 双曲反正切函数
```rustscript
函数
atanh
语法
atanh(x);
输入参数
x - 矩阵或标量，若为矩阵对每个元素分别进行计算，若为稀疏矩阵仅对非零元进行计算
示例
输入 atanh([[0,0.5],[-2/3,3/4]])
结果 [[0, 0.549306],[-0.804719,0.5*ln(7)]]
输入 atanh([c(2, 0), c(0, 1)])
结果 [c(0.5*ln(3), -pi/2), c(0, pi/4)]
输入 atanh(sparse([0,0],[0,1],[0.5,-2/3], 2, 2))
结果 [[2, 2, 0], [0, 0, 0.549306], [0, 1, -0.804719]]
```
### 9.1.17 绝对值函数
```rustscript
函数
abs
语法
abs(x);
输入参数
x - 矩阵或标量，若为矩阵对每个元素分别进行计算，若为稀疏矩阵仅对非零元进行计算
示例
输入 abs([[0,-1],[-2,3]])
结果 [[0,1],[2,3]]
输入 abs(sparse([0,0],[0,1],[-1,-2], 2, 2))
结果 [[2, 2, 0], [0, 0, 1], [0, 1, 2]]
```
### 9.1.18 符号函数
```rustscript
函数
signum
语法
signum(x);
输入参数
x - 矩阵或标量，若为矩阵对每个元素分别进行计算，若为稀疏矩阵仅对非零元进行计算
示例
输入 signum([[0,-1],[-2,3]])
结果 [[1,-1],[-1,1]]
输入 signum([c(0,-1), c(-2,3)])
结果 [c(1, 0), c(-1, 0)]
输入 signum(sparse([0,0],[0,1],[-2,3], 2, 2))
结果 [[2, 2, 0], [0, 0, -1], [0, 1, 1]]
```
### 9.1.19 向下取整函数
```rustscript
函数
floor
语法
floor(x);
输入参数
x - 矩阵或标量，若为矩阵对每个元素分别进行计算，若为稀疏矩阵仅对非零元进行计算
示例
输入 floor([[0.6,-2.3],[1.3,-3.6]])
结果 [[0,-3],[1,-4]]
输入 floor([c(0.6,-2.3), c(1.3,-3.6)])
结果 [c(0, 0), c(1, 0)]
输入 floor(sparse([0,0],[0,1],[0.6,-2.3], 2, 2))
结果 [[2, 2, 0], [0, 0, 0], [0, 1, -3]]
```
### 9.1.20 向上取整函数
```rustscript
函数
ceil
语法
ceil(x);
输入参数
x - 矩阵或标量，若为矩阵对每个元素分别进行计算，若为稀疏矩阵仅对非零元进行计算
示例
输入 ceil([[0.6,-2.3],[1.3,-3.6]])
结果 [[1,-2],[2,-3]]
输入 ceil([c(0.6,-2.3), c(1.3,-3.6)])
结果 [c(1, 0), c(2, 0)]
输入 ceil(sparse([0,0],[0,1],[0.6,-2.3], 2, 2))
结果 [[2, 2, 0], [0, 0, 1], [0, 1, -2]]
```
### 9.1.21 四舍五入函数
```rustscript
函数
round
语法
round(x);
输入参数
x - 矩阵或标量，若为矩阵对每个元素分别进行计算，若为稀疏矩阵仅对非零元进行计算
示例
输入 round([[0.6,-2.3],[1.3,-3.6]])
结果 [[1,-2],[1,-4]]
输入 round([c(0.6,-2.3), c(1.3,-3.6)])
结果 [c(1, 0), c(1, 0)]
输入 round(sparse([0,0],[0,1],[0.6,-2.3], 2, 2))
结果 [[2, 2, 0], [0, 0, 1], [0, 1, -2]]
```
### 9.1.22 度转弧度函数
```rustscript
函数
deg2rad
语法
deg2rad(x);
输入参数
x - 矩阵或标量
示例
输入 deg2rad([30, 45])
结果 [pi/6, pi/4]
输入 deg2rad([c(30, 45), c(60, 90)])
结果 [c(pi/6, pi/4), c(pi/3, pi/2)]
输入 deg2rad(sparse([0,0], [0,1], [30,45], 2, 2))
结果 [[2, 2, 0], [0, 0, pi/6], [0, 1, pi/4]]
```
### 9.1.23 弧度转度函数
```rustscript
函数
rad2deg
语法
rad2deg(x);
输入参数
x - 矩阵或标量
示例
输入 rad2deg([pi, pi/2])
结果 [180, 90]
输入 rad2deg([c(pi/6, pi/4), c(pi/3, pi/2)])
结果 [c(30, 45), c(60, 90)]
输入 rad2deg(sparse([0,0], [0,1], [pi/2,pi], 2, 2))
结果 [[2, 2, 0], [0, 0, 90], [0, 1, 180]]
```
### 9.1.24 复数取实部函数
```rustscript
函数
real
语法
real(z);
输入参数
z - 复数矩阵或复数标量，若为矩阵对每个元素分别进行计算，若为稀疏矩阵仅对非零元进行计算
示例
输入 real([c(1, 2), c(3, 4)])
结果 [c(1, 0), c(3, 0)]
输入 real(sparse([c(0,0),c(0,0)],[c(0,0),c(1,0)],[c(1,2),c(3,4)], c(2,0), c(2,0)))
结果 [[c(2,0), c(2,0), c(0,0)], [c(0,0), c(0,0), c(1,0)], [c(0,0), c(1,0), c(3,0)]]
```
### 9.1.25 复数取虚部函数
```rustscript
函数
imag
语法
imag(z);
输入参数
z - 复数矩阵或复数标量，若为矩阵对每个元素分别进行计算，若为稀疏矩阵仅对非零元进行计算
示例
输入 imag([c(1, 2), c(3, 4)])
结果 [c(2, 0), c(4, 0)]
输入 imag(sparse([c(0,0),c(0,0)],[c(0,0),c(1,0)],[c(1,2),c(3,4)], c(2,0), c(2,0)))
结果 [[c(2,0), c(2,0), c(0,0)], [c(0,0), c(0,0), c(2,0)], [c(0,0), c(1,0), c(4,0)]]
```
### 9.1.26 共轭复数函数
```rustscript
函数
conj
语法
conj(z);
输入参数
z - 复数矩阵或复数标量，若为矩阵对每个元素分别进行计算，若为稀疏矩阵仅对非零元进行计算
示例
输入 conj([c(1, 2), c(3, 4)])
结果 [c(1, -2), c(3, -4)]
输入 conj(sparse([c(0,0),c(0,0)],[c(0,0),c(1,0)],[c(1,2),c(3,4)], c(2,0), c(2,0)))
结果 [[c(2,0), c(2,0), c(0,0)], [c(0,0), c(0,0), c(1,-2)], [c(0,0), c(1,0), c(3,-4)]]
```
### 9.1.27 复数模函数
```rustscript
函数
abs
语法
abs(z);
输入参数
z - 复数矩阵或复数标量，若为矩阵对每个元素分别进行计算，若为稀疏矩阵仅对非零元进行计算
示例
输入 abs([c(3, 4), c(5, 12)])
结果 [c(5, 0), c(13, 0)]
输入 abs(sparse([c(0,0),c(0,0)],[c(0,0),c(1,0)],[c(3,4),c(5,12)], c(2,0), c(2,0)))
结果 [[c(2,0), c(2,0), c(0,0)], [c(0,0), c(0,0), c(5,0)], [c(0,0), c(1,0), c(13,0)]]
```
### 9.1.28 复数辐角函数
```rustscript
函数
arg
语法
arg(z);
输入参数
z - 复数矩阵或复数标量，若为矩阵对每个元素分别进行计算，若为稀疏矩阵仅对非零元进行计算
示例
输入 arg([c(sqrt(3), 1), c(1, 1)])
结果 [c(pi/6, 0), c(pi/4, 0)]
输入 arg(sparse([c(0,0),c(0,0)],[c(0,0),c(1,0)],[c(sqrt(3), 1),c(1, 1)], c(2,0), c(2,0)))
结果 [[c(2,0), c(2,0), c(0,0)], [c(0,0), c(0,0), c(pi/6,0)], [c(0,0), c(1,0), c(pi/4,0)]]
```
### 9.2 矩阵函数
### 9.2.1 线性代数
### 9.2.1.1 行列式
```rustscript
函数
det
语法
det(A);
输入参数
A - 方阵
示例
输入 det([[1,2],[3,4]])
结果 -2
输入 det([[c(1,2),c(3,4)],[c(5,6),c(7,8)]])
结果 c(0,-16)
```
### 9.2.1.2 逆矩阵
```rustscript
运算符
^(-1)
语法
A ^ (-1);
输入参数
A - 方阵
示例
输入 [[1,2],[3,4]]^(-1)
结果 [[-2, 1], [1.5, -0.5]]
```
### 9.2.1.3 矩阵的秩
```rustscript
运算符
rank
语法
rank(A);
输入参数
A - 矩阵
示例
输入 rank([[1,2,3],[4,5,6]])
结果 2
```
### 9.2.1.4 矩阵的迹
```rustscript
运算符
trace
语法
trace(A);
输入参数
A - 方阵
示例
输入 trace([[1,2,3],[4,5,6],[7,8,9])
结果 15
输入 trace([[c(1,1), c(2,2), c(3,3)],[c(4,4), c(5,5) ,c(6,6)],[c(7,7), c(8,8), c(9,9)])
结果 c(15,15)
```
### 9.2.1.5 特征值
```rustscript
运算符
eig
语法
eig(A);
输入参数
A - 方阵，大小为N*N
返回参数
输入参数若为实数方阵，返回矩阵中第1列和第2列分别为特征值向量的实部和虚部，第3列至N+2列为右特征向量矩阵的实部，第N+3列至最后1列为右特征向量矩阵的虚部，顺序与特征值向量中元素顺序对应
输入参数若为复数方阵，返回矩阵中第1列为特征值向量，第2列至最后一列为右特征向量矩阵，顺序与特征值向量中元素顺序对应
示例
输入 eig([[4, 1], [2, 3]])
结果 [[5, 0, 0.707107, -0.447214, 0, 0], [2, 0, 0.707107, 0.894427, 0, 0]]
输入 eig([[c(0,0), c(-1,0)],[c(1,0), c(0,0)])
结果 [[c(0, 1), c(0, 0.707107), c(0, -0.707107)],
[c(0, -1), c(0.707107, 0.), c(0.707107, 0)]]
输入 eig([[c(2,0), c(-3,0)],[c(1,0), c(2,0)])
结果 [[c(2, 1.732051), c(0.866025, 0), c(0.866025, 0)],
[c(2, -1.732051), c(0, -0.5), c(0, 0.5)]]
```
### 9.2.1.6 奇异值
```rustscript
运算符
svd
语法
svd(A);
输入参数
A - 矩阵
示例
输入
结果
```
### 9.2.1.7 1范数
```rustscript
函数
norm_l1
语法
norm_l1(A);
输入参数
A - 矩阵
示例
输入 norm_l1([1, -2, 3, -4])
结果 10
输入 norm_l1([[1, -2, 3], [-4, -6, -5]])
结果 21
输入 norm_l1([c(1, 0), c(0, 2), c(-3, 4), c(5, -12)])
结果 21
输入 norm_l1(sparse([0,0,1,1], [0,1,0,1], [1,-2,3,-4], 2, 2))
结果 10
```
### 9.2.1.8 max范数
```rustscript
函数
norm_l1
语法
norm_l1(A);
输入参数
A - 矩阵
示例
输入 norm_max([1, -2, 3, -4])
结果 4
输入 norm_max([[1, -2, 3], [-4, -6, -5]])
结果 6
输入 norm_max([c(1, 0), c(0, 2), c(-3, 4), c(5, -12)])
结果 13
输入 norm_max(sparse([0,0,1,1], [0,1,0,1], [1,-2,3,-4], 2, 2))
结果 4
```
### 9.2.1.9 2范数
```rustscript
函数
norm_l2
语法
norm_l2(A);
输入参数
A - 矩阵
示例
输入 norm_l2([1, -1, 1, 2, -2, 3, -4])
结果 6
输入 norm_l2([[1, -1, 1, 2], [-2, 3, -4, 0]])
结果 6
输入 norm_l2([c(1, -1), c(1, 2), c(-2, 3), c(-4, 0)])
结果 6
输入 norm_l2(sparse([0,0,1], [0,1,0], [1,2,-2], 2, 2))
结果 3
```
### 9.2.1.10 线性方程组求解
```rustscript
函数
linsolve
语法
linsolve(A, b);
输入参数
A - 方阵
b - 向量，仅支持稠密矩阵形式
求解A * x = b
示例
输入 linsolve([[2,1], [1,-3]], [[5], [-1]])
结果 [[2], [1]]
输入 linsolve([[c(2, 0), c(1, 0)], [c(1, 0), c(-3, 0)]], [[c(5, 0)], [c(-1, 0)]])
结果 [[c(2, 0)],[c(1, 0)]]
输入 linsolve(sparse([0,0,1,1], [0,1,0,1], [2,1,1,-3], 2, 2), [[5], [-1]])
结果 [[2], [1]]
```
### 9.2.1.11 线性方程组系数矩阵转置求解
```rustscript
函数
linsolve_t
语法
linsolve_t(A, b);
输入参数
A - 方阵
b - 向量，仅支持稠密矩阵形式
求解A^T * x = b
示例
输入 linsolve_t([[2,1], [3,-1]], [[13], [1]])
结果 [[3.2], [2.2]]
输入 linsolve_t(sparse([0,0,1,1], [0,1,0,1], [2,1,3,-1], 2, 2), [[13], [1]])
结果 [[3.2], [2.2]]
输入 linsolve_t([[c(-12, 42), c(-20, 98)], [c(-16, 62), c(-24, 150)]], [[c(-548, 232)], [c(-1236, 664)]])
结果 [[c(1,2)], [c(5,6)]]
```
### 9.2.1.12
```rustscript
qr(A), chol(A)cond(A)
```
### 9.2.2 矩阵操作
### 9.2.2.1 转置
```rustscript
函数
transpose
语法
transpose(A);
输入参数
A - 矩阵
示例
输入 transpose([1, 2, 3])
结果 [[1], [2], [3]]
输入 transpose([[c(1, 1), c(2, 2)], [c(3, 3), c(4, 4)]])
结果 [[c(1, 1), c(3, 3)], [c(2, 2), c(4, 4)]]
输入 transpose(sparse([0,1,2], [1,0,1], [2, 3, 6], 3, 2))
结果 [[2, 3, 0], [1, 0, 2], [0, 1, 3], [1, 2, 6]]
```
### 9.2.2.2 共轭转置
```rustscript
函数
ctranspose
语法
ctranspose(A);
输入参数
A - 复数矩阵
示例
输入 ctranspose([[c(1, 1), c(2, 2)], [c(3, 3), c(4, 4)]])
结果 [[c(1, -1), c(3, -3)], [c(2, -2), c(4, -4)]]
输入 ctranspose(sparse([0,1,2], [1,0,1], [2, 3, 6], 3, 2))
结果 [[2, 3, 0], [1, 0, -2], [0, 1, -3], [1, 2, -6]]
```
### 9.2.2.3 对角矩阵
```rustscript
运算符
diag
语法
diag(A);
输入参数
A - 向量或张量。若A为张量，返回其对角元向量；若A为向量，返回以A为对角元的对角矩阵
示例
输入 diag([1, 2, 3])
结果 [[1, 0, 0],[0, 2, 0],[0, 0, 3]]
输入 diag([[1, 0.5, 0.3333, 0.25], [0.5, 1, 0.6667, 0.5], [0.3333, 0.6667, 1, 0.75], [0.25, 0.5, 0.75, 1]])
结果 [1, 1, 1, 1]
输入 diag(sparse([0, 1, 2], [1, 1, 2], [2, 3, 6], 3, 3))
结果 [[3, 3, 0], [1, 1, 3], [2, 2, 6]]
```
### 9.2.2.4
```rustscript
triu(A), tril(A)
reshape(A, m, n), repmat(A, m, n)
```
### 9.3 张量操作函数
#### 9.3.1 形状和尺寸
#### 9.3.1.1 获取指定维度大小
```rustscript
函数
size
语法
size(t, dim)
输入参数
t - 张量
dim - 指定维度，若该参数为空则返回各维度大小构成的向量
示例
输入 size([[1., 0.5, 0.3, 0.2], [0.5, 1., 0.6, 0.5], [0.3, 0.6, 1., 0.7]])
结果 [3,4]
输入 size([1, 2, 3], 0)
结果 3
输入 size([[1, 2, 3]], 0)
结果 1
输入 size([[1, 2, 3]], 1)
结果 3
输入 size([[1], [2], [3]], 0)
结果 3
输入 size([[1], [2], [3]], 1)
结果 1
```
#### 9.3.1.2 获取元素总数
```rustscript
函数
length
语法
length(t)
输入参数
t - 张量，若为稀疏矩阵，返回非零元个数
示例
输入 length([1, 2, 3])
结果 3
输入 length([[c(1, 2), c(3, 4)], [c(5, 6), c(7, 8)]])
结果 c(4, 0)
输入 length(sparse([0,0], [0,1], [1,-2], 2, 2))
结果 2
```
#### 9.3.1.3 获取维度数
```rustscript
函数
ndim
语法
ndim(t)
输入参数
t - 张量
示例
输入 ndim([1, 2, 3])
结果 1
输入 ndim([[1, 2, 3]])
结果 2
输入 ndim([[1], [2], [3]])
结果 2
```
#### 9.3.1.4 元素个数
```rustscript
numel(tensor) // 元素个数
```
#### 9.3.2 张量切片和操作
#### 9.3.2.1 张量切片操作
```rustscript
函数
slice
语法
slice(t, row_spec, col_spec)
输入参数
t - 张量
row_spec - 行索引，数值代表单个索引，[0]代表所有行，[start,end,step]代表范围和步长
col_spec - 列索引，数值代表单个索引，[0]代表所有列，[start,end,step]代表范围和步长
返回类型
1. 使用范围参数[start, end] - 返回二维张量
col_2d = slice(a, [0], [1, 2]); // 取第2列所有行，返回3×1列向量(二维张量)
row_2d = slice(a, [1, 2], [0]); // 取第2行所有列，返回1×3行向量(二维张量)
sub_t = slice(t, [0,3], [1,4]); // 行0-2，列1-3的子矩阵(二维张量)
2. 使用单个索引 - 返回一维张量
col_1d = slice(a, [0], 1); // 取第2列所有行，返回shape为[3]的一维张量
row_1d = slice(a, 1, [0]); // 取第2行所有列，返回shape为[3]的一维张量
示例
a = [[1, 2, 3], [4, 5, 6], [7, 8, 9]];
输入 slice(a, [0], [1, 2])
结果 [[2], [5], [8]]
输入 slice(a, [1, 2], [0])
结果 [[4, 5, 6]]
输入 slice(a, [1, 3], [0, 2])
结果 [[4,5],[7,8]]
输入 slice(a, [0, 3, 2], [0, 3, 2])
结果 [[1,3],[7,9]]
输入 slice(a, [0], 1)
结果 [2, 5, 8]
输入 slice(a, 1, [0])
结果 [4, 5, 6]
电力系统应用示例
voltage = slice(bus, [0], [VM-1, VM]); // 所有行，VM列(二维张量)
angle = slice(bus, [0], VA-1); // 所有行，VA列(一维张量)
```
#### 9.3.2.2 设置张量元素值
```rustscript
函数
set
语法
set(t, indices, values)
输入参数
t - 张量
indices - 张量，其中元素表示t按行顺序排列的位置索引
values - 张量，形状应与indices相同，indices中索引位置元素设置为values中的对应值
示例
输入 set([[1, 2], [3, 4]], [2, 0], -3)
结果 [[-3, 2], [-3, 4]]
输入 set([[1, 2], [3, 4]], [2, 0], [-1, -3])
结果 [[-3, 2], [-1, 4]]
输入 set([c(1, 2), c(3, 4), c(5, 6), c(7, 8)], [c(1, 0), c(2, 0)], [c(-3, -4), c(-5, -6)])
结果 [c(1, 2), c(-3, -4), c(-5, -6), c(7, 8)]
输入 set(sparse([0,0],[0,1],[1,2], 2, 2), [1, 3], [3, 4])
结果 [[2, 2, 0], [0, 0, 1], [0, 1, 3], [1, 1, 4]]
```
#### 9.3.2.3 张量元素累加赋值 (相当于 +=)
```rustscript
函数
set2
语法
set2(t, indices, values)
输入参数
t - 张量
indices - 张量，其中元素表示t按行顺序排列的位置索引
values - 张量，形状应与indices相同，indices中索引位置元素设置为values中的对应值
示例
输入 set2([[1, 2], [3, 4]], [2, 0], -3)
结果 [[-2, 2], [0, 4]]
输入 set2([[1, 2], [3, 4]], [2, 0], [-1, -3])
结果 [[-3, 2], [-1, 4]]
输入 set2([c(1, 2), c(3, 4), c(5, 6), c(7, 8)], [c(1, 0), c(2, 0)], [c(-3, -4), c(-5, -6)])
结果 [c(1, 2), c(0, 0), c(0, 0), c(7, 8)]
输入 set2(sparse([0,0],[0,1],[1,2], 2, 2), [1, 3], [3, 4])
结果 [[2, 2, 0], [0, 0, 1], [0, 1, 5], [1, 1, 4]]
```
#### 9.3.3 张量拼接
#### 9.3.3.1 横向拼接张量
```rustscript
函数
horzcat
语法
horzcat(A, B, ...)
输入参数
A - 张量
B - 张量
输入各张量的行数应相同
示例
输入 horzcat([[1, 2, 3], [4, 5, 6]], [[7, 9], [8, 10]])
结果 [[1, 2, 3, 7, 9], [4, 5, 6, 8, 10]]
输入 horzcat([[c(1.1, -1.1), c(2.2, -2.2), c(3.3, -3.3)], [c(4.4, -4.4), c(5.5, -5.5), c(6.6, -6.6)]],
[[c(7, -7), c(8, -8)],[c(9, -9), c(10, -10)]])
结果 [[c(1.1, -1.1), c(2.2, -2.2), c(3.3, -3.3), c(7, -7), c(8, -8)],
[c(4.4, -4.4), c(5.5, -5.5), c(6.6, -6.6), c(9, -9), c(10, -10)]]
```
#### 9.3.3.2 纵向拼接张量
```rustscript
函数
vertcat
语法
vertcat(A, B, ...)
输入参数
A - 张量
B - 张量
输入各张量的列数应相同
示例
输入 vertcat([[1, 2, 3], [4, 5, 6]], [[7, 8, 9], [10, 11, 12]])
结果 [[1, 2, 3], [4, 5, 6], [7, 8, 9], [10, 11, 12]]
输入 vertcat([[c(1.1, -1.1), c(2.2, -2.2), c(3.3, -3.3)], [c(4.4, -4.4), c(5.5, -5.5), c(6.6, -6.6)]],
[[c(7, -7), c(8, -8), c(9, -9)], [c(10, -10), c(11, -11), c(12, -12)]])
结果 [[c(1.1, -1.1), c(2.2, -2.2), c(3.3, -3.3)], [c(4.4, -4.4), c(5.5, -5.5), c(6.6, -6.6)],
[c(7, -7), c(8, -8), c(9, -9)], [c(10, -10), c(11, -11), c(12, -12)]]
```
#### 9.3.4 序列生成
#### 9.3.4.1 生成序列 [start, start+1, ..., end-1] (前闭后开)
```rustscript
range(start, end)
```
#### 9.3.4.2 在start和end间生成num个等间距点
```rustscript
linspace(start, end, num)
```
#### 9.3.5 统计函数
#### 9.3.5.1 按维度求和
```rustscript
函数
sum
语法
sum(t,d)
输入参数
t - 张量
d - 维度，可选参数
示例
输入 sum([[[1.1, 2.2], [3.3, 4.4]], [[5.5, 6.6], [7.7, 8.1]]])
结果 [[6.6, 8.8], [11.0, 12.5]]
输入 sum([[[1.3, 2.2], [3.3, 4.3]], [[5.5, 6.6], [7.7, 8.1]]], 1)
结果 [[4.4, 6.7], [13.2, 14.7]]
输入 sum([[[1.3, 2.2], [3.3, 4.3]], [[5.5, 6.6], [7.7, 8.1]]], 2)
结果 [[3.5, 7.6], [12.1, 15.8]]
输入 sum([[[1.3, 2.2], [3.3, 4.3]], [[5.5, 6.6], [7.7, 8.1]]], [0, 1])
结果 [17.8, 21.2]
输入 sum([[[1.3, 2.2], [3.3, 4.3]], [[5.5, 6.6], [7.7, 8.1]]], [0, 1, 2])
结果 39
输入 sum([[[c(1.1, 1.1), c(2.2, 2.2)], [c(3.3, 3.3), c(4.4, 4.4)]],
[[c(5.5, 5.5), c(6.6, 6.6)], [c(7.7, 7.7), c(8.1, 8.1)]]])
结果 [[c(6.6, 6.6), c(8.8, 8.8)], [c(11.0, 11.0), c(12.5, 12.5)]]
输入 sum(sparse([0,0,1,1],[0,1,0,1],[1,2,3,4], 2, 2), 0)
结果 [3, 7]
```
#### 9.3.5.2 所有元素求和
```rustscript
函数
sum_all
语法
sum_all(t)
输入参数
t - 张量
示例
输入 sum_all([[1, 2], [3, 4]])
结果 10
输入 sum_all([[c(1, 1), c(2, 2)], [c(3, 3), c(4, 4)]])
结果 c(10, 10)
输入 sum_all(sparse([0,0],[0,1],[1,2], 2, 2))
结果 3
```
#### 9.3.5.3 平均值
```rustscript
函数
mean
语法
mean(t)
输入参数
t - 张量
示例
输入 mean([[1, 2], [3, 4]])
结果 10
输入 mean([[c(1,2), c(3,4)],[c(5,6), c(7,8)]])
结果 c(4, 5)
输入 mean(sparse([0,0],[0,1],[1,2], 2, 2))
结果 1.5
```
#### 9.3.5.4 标准差
```rustscript
std(tensor)
```
#### 9.3.5.5 方差
```rustscript
var(tensor)
```
#### 9.3.5.6 最大值
```rustscript
函数
max
语法
max(t, row_spec, col_spec)
输入参数
t - 张量
row_spec - 可选参数，行索引，数值代表单个索引，[0]代表所有行，[start,end,step]代表范围和步长
col_spec - 可选参数，列索引，数值代表单个索引，[0]代表所有列，[start,end,step]代表范围和步长
示例
输入 max([[1, 2], [3, 4]])
结果 4
输入 max([[1, 2], [3, 4]], [0], 0)
结果 3
输入 max([[c(1, 1), c(2, 2)], [c(3, 3), c(4, 4)]])
结果 c(4, 4)
输入 max(sparse([0,0,1,1],[0,1,0,1],[1,2,3,4], 2, 2))
结果 4
```
#### 9.3.5.7 最小值
```rustscript
函数
min
语法
min(t, row_spec, col_spec)
输入参数
t - 张量
row_spec - 可选参数，行索引，数值代表单个索引，[0]代表所有行，[start,end,step]代表范围和步长
col_spec - 可选参数，列索引，数值代表单个索引，[0]代表所有列，[start,end,step]代表范围和步长
示例
输入 min([[1, 2], [3, 4]])
结果 1
输入 min([[1, 2], [3, 4]], [0], 1)
结果 2
输入 min([[c(1, 1), c(2, 2)], [c(3, 3), c(4, 4)]])
结果 c(1, 1)
输入 min(sparse([0,0,1,1],[0,1,0,1],[1,2,3,4], 2, 2))
结果 1
```
#### 9.3.5.8 中位数
```rustscript
median(tensor)
//其中，max()和min()可以如下用法：max(a, [0],1)，min(a, [0],1)，参数和slice函数的定义相同
```
#### 9.3.6 查找函数
#### 9.3.6.1 查找非零元素
```rustscript
函数
find
语法
find(t)
输入参数
t - 张量
示例
输入 find([1, 0, 3, 0])
结果 [0, 2]
输入 find([[c(1, 0), c(0, 0)], [c(0, 3), c(0, 0)]])
结果 [c(0, 0), c(2, 0)]
输入 find(sparse([0,0],[0,1],[1,-2], 2, 2))
结果 [[2, 2, 0], [0, 0, 1], [0, 1, -2]]
```
#### 9.3.6.2 查找最接近指定值的元素
```rustscript
函数
find_nearest
语法
find_nearest(t, v)
输入参数
t - 张量，若为稀疏矩阵，仅查找非零元
v - 标量
示例
输入 find_nearest([1, 2.1, 3], 2)
结果 2.1
输入 find_nearest([c(1, 2), c(1, 3), c(2, 2), c(2, 3)], c[1, 2.6])
结果 c(1, 3)
输入 find_nearest(sparse([0,0],[0,1],[1,-2], 2, 2), -1)
结果 -2
```
#### 9.3.6.3 查找最接近指定值的元素位置
```rustscript
函数
find_nearest_pos
语法
find_nearest_pos(t, v)
输入参数
t - 张量，若为稀疏矩阵，仅查找非零元
v - 标量
若有多个元素与指定值，返回第一个元素位置
示例
输入 find_nearest_pos([4, 3, 1], 2)
结果 [1]
输入 find_nearest_pos([c(1, 2), c(1, 3), c(2, 2), c(2, 3)], c[1, 2.6])
结果 [c(1, 0)]
输入 find_nearest_pos(sparse([0,0],[0,1],[1,-2], 2, 2), -1)
结果 [0, 1]
```
#### 9.3.6.4 检测指定维度是否存在非零元素
```rustscript
函数
any
语法
any(t,d)
输入参数
t - 张量
d - 维度
示例
输入 any([0, 2, 3])
结果 1
输入 any([0, 0, 0])
结果 0
输入 any([[0,1,2], [0, 0, 0], [0, -3, 5]], 0)
结果 [0, 1, 1]
输入 any([[0,1,2], [0, 0, 0], [0, -3, 5]], 1)
结果 [1, 0, 1]
输入 any([c(0, 0), c(0, 2), c(3, 0)])
结果 c(1,0)
输入 any(sparse([0, 1, 2], [1, 0, 1], [2, 3, 6], 3, 3))
结果 [[3, 1, 0], [0, 0, 1], [1, 0, 1], [2, 0, 1]]
```
#### 9.3.6.5 检测张量是否为空
```rustscript
函数
is_empty
语法
is_empty(t)
输入参数
t - 张量。若为稠密矩阵，检测矩阵是否为空；若为稀疏矩阵，则检测是否存在非零元
示例
输入 is_empty([])
结果 1
输入 is_empty([c(0, 0)])
结果 [c(0, 0)]
输入 is_empty(sparse([],[],[], 2, 2))
结果 1
```
#### 9.3.6.6 检测是否无穷数
```rustscript
函数
is_inf
语法
is_inf(t)
输入参数
t - 张量
示例
输入 is_inf([[0, INF], [2, NEG_INF]])
结果 [[0, 1],[0, 1]]
输入 is_inf([c(0, INF), c(NEG_INF, 3), c(4, 5)])
结果 [c(1, 0), c(1, 0), c(0, 0)]
输入 is_inf(sparse([0,0,1], [0,1,0], [0,INF,NEG_INF], 2, 2))
结果 [[2, 2, 0], [0, 0, 0], [0, 1, 1], [1, 0, 1]]
```
#### 9.3.6.7 检测所有元素是否非零
```rustscript
all(tensor)
```
#### 9.3.7 获取多个元素
#### 9.3.7.1 根据索引获取多个元素(可不连续)
```rustscript
函数
get_multi
语法
get_multi(t, indices);
输入参数
t - 张量
indices - 张量，其中元素表示t按行顺序排列的位置索引
示例
输入 get_multi([1, 2, 3, 4], [1, 3])
结果 [2, 4]
输入 get_multi([c(1, 2), c(3, 4), c(5, 6), c(7, 8)], [c(1, 0), c(2, 0)])
结果 [c(3, 4), c(5, 6)]
```
### 9.4 稀疏矩阵
### 9.4.1 创建稀疏矩阵
### 9.4.1.1 由三元组创建稀疏矩阵
```rustscript
函数
sparse
语法
sparse(row, col, v, m, n);
输入参数
row - 向量，行索引
col - 向量，列索引
v - 向量，值
m - 稀疏矩阵行数
n - 稀疏矩阵列数
row、col和v的长度应相等
示例
输入 sparse([0, 1, 2], [1, 0, 1], [2, 3, 6], 3, 2)
结果 [[3, 2, 0], [0, 1, 2], [1, 0, 3], [2, 1, 6]]
```
### 9.4.2 稀疏矩阵操作
### 9.4.2.1 转为稠密矩阵
```rustscript
函数
full
语法
full(t);
输入参数
t - 稀疏矩阵
示例
输入 full(sparse([0, 1, 1], [1, 0, 2], 2, 3))
结果 [[0, 2, 0], [4, 0, 6]]
```
#### 9.4.2.2 非零元素个数
```rustscript
nnz_count = nnz(sparse_mat);
```
#### 9.4.2.3 显示稀疏模式
```rustscript
spy(sparse_mat);
```
### 9.5 张量操作详细示例
```rustscript
// 实际使用示例（来自make_y_bus函数）
nb = size(bus, 0); // 获取母线数量
nl = size(branch, 0); // 获取支路数量
// 切片操作
stat = slice(branch, [0], [BR_STATUS-1, BR_STATUS]); // 获取支路状态列
Ys = stat ./ (slice(branch, [0], [BR_R-1, BR_R])
+ c(0,1) * slice(branch, [0], [BR_X-1, BR_X]));
// 查找和设置操作
index = find(tap_col); // 查找非零变比的索引
tap_init = set(ones(nl, 1), index, get_multi(tap_col, index));
// 序列生成和拼接
i = horzcat(range(0, nl), range(0, nl)) - 1; // 创建行索引
j = range(0, nb); // 创建列索引
// 稀疏矩阵创建
Yf = sparse(i, horzcat(f, t), upper, nl, nb);
Ybus = sparse(horzcat(f,f,t,t), horzcat(f,t,f,t),
vertcat(Yff,Yft,Ytf,Ytt), nb, nb);
```
## 10. 数据结构示例
### 10.1 电力系统数据（基于 case14）
```rustscript
// 系统基准功率
baseMVA = 100;
// 母线数据 - 每行必须用[]包围，数字用逗号分隔
bus = [
[1, 3, 0, 0, 0, 0, 1, 1.06, 0, 0, 1, 1.06, 0.94],
[2, 2, 21.7, 12.7, 0, 0, 1, 1.045, -4.98, 0, 1, 1.06, 0.94],
[3, 2, 94.2, 19, 0, 0, 1, 1.01, -12.72, 0, 1, 1.06, 0.94],
[4, 1, 47.8, -3.9, 0, 0, 1, 1.019, -10.33, 0, 1, 1.06, 0.94]
];
// 发电机数据
gen = [
[1, 232.4, -16.9, 10, 0, 1.06, 100, 1, 332.4, 0],
[2, 40, 42.4, 50, -40, 1.045, 100, 1, 140, 0],
[3, 0, 23.4, 40, 0, 1.01, 100, 1, 100, 0]
];
// 支路数据
branch = [
[1, 2, 0.01938, 0.05917, 0.0528, 0, 0, 0, 0, 0, 1, -360, 360],
[1, 5, 0.05403, 0.22304, 0.0492, 0, 0, 0, 0, 0, 1, -360, 360],
[2, 3, 0.04699, 0.19797, 0.0438, 0, 0, 0, 0, 0, 1, -360, 360]
];
```
## 11. 模块系统
### 11.1 模块导入
```rustscript
// 导入整个模块
import power_flow;
// 导入特定函数
import {newton_pf, fast_decoupled_pf} from power_flow;
// 别名导入
import newton_pf as newton from power_flow;
```
### 11.2 模块定义
```rustscript
// 模块文件: power_flow.rs
export fn newton_pf(baseMVA, bus, gen, branch) {
// 实现牛顿拉夫逊潮流计算
}
export fn fast_decoupled_pf(baseMVA, bus, gen, branch) {
// 实现快速解耦潮流计算
}
```
## 12. 与MATLAB的对比
### 12.1 主要差异
| 特性 | MATLAB | RustScript | 说明 |
|------|---------------------|-----------------------|------|
| 索引基数 | 1基索引 `A(1,2)` | 0基索引 `A[0,1]` | **重要差异：索引从不同位置开始** |
| 矩阵定义 | `[1 2; 3 4]` | `[[1, 2], [3, 4]]` | 分号分行，逗号分元素 |
| 序列生成 | `0:n-1` | `range(0, n)` | MATLAB包含端点，RustScript前闭后开 |
| 注释 | `% 注释` | `// 注释` | 注释符号不同 |
| 字符串 | `'string'` | `"string"` | 引号类型不同 |
| 函数定义 | `function y = f(x)` | `fn f(x){ return y;}` | 函数语法不同 |
| 逻辑运算 | `&`, `\|`, `~` | `&&`, `\|\|`, `~~` | 逻辑运算符不同 |
| 结构体 | `struct` | 无结构体，使用张量和变量组织 | RustScript没有结构体概念 |
### 12.2 索引转换详解
**最重要的差异：MATLAB使用1基索引，RustScript使用0基索引**
```matlab
% MATLAB (1基索引)
A(1, 1) % 第一个元素
A(1:3, 2) % 第1到3行，第2列
bus(:, i) % 第i列所有行
0:n-1 % 生成 [0, 1, 2, ..., n-1]
```
```rustscript
// RustScript (0基索引)
A[0, 0] // 第一个元素
slice(A, [0,3], [1]) // 第1到3行（0,1,2），第2列（索引1）
slice(bus, [0], [i-1,i]) // 第i列所有行（需要减1）
range(0, n) // 生成 [0, 1, 2, ..., n-1] (前闭后开)
```
### 12.3 转换示例对比
**MATLAB到RustScript的典型转换：**
```matlab
% MATLAB版本
function Ybus = make_y_bus(baseMVA, bus, branch)
nb = size(bus, 1); % 获取行数
f = branch(:, F_BUS); % 从母线
t = branch(:, T_BUS); % 到母线
% 创建索引（1基）
i = [1:nl, 1:nl];
j = 1:nb;
% 稀疏矩阵（MATLAB自动处理1基索引）
Ybus = sparse(i, j, values, nb, nb);
end
```
```rustscript
// RustScript版本
fn make_y_bus(baseMVA, bus, branch) {
nb = size(bus, 0); // 获取行数
f = slice(branch, [0], [F_BUS-1]) - 1; // 从母线（转换为0基）
t = slice(branch, [0], [T_BUS-1]) - 1; // 到母线（转换为0基）
// 创建索引（0基）
i = horzcat(range(0, nl), range(0, nl));
j = range(0, nb);
// 稀疏矩阵（显式使用0基索引）
Ybus = sparse(i, j, values, nb, nb);
return Ybus;
}
```
### 12.4 转换器的索引处理策略
在MATLAB到RustScript转换过程中，转换器需要特别处理索引：
**Case文件转换（保持原始索引）：**
- Case文件通常包含数据定义，索引值保持不变
- 例如：母线编号仍然是1, 2, 3...
**函数转换（转换为0基索引）：**
- 函数中的索引操作需要转换：`A(i)` → `A[i-1]`
- 循环变量需要调整：`for i = 1:n` → `for i in range(0, n)`
- 序列生成需要转换：`1:n` → `range(1, n+1)` 或 `range(0, n)`
Markdown 格式
0% 或
您添加了 0 人 到此讨论。请谨慎行事。
请先完成此评论的编辑！
请 注册 或者 后发表评论