增加大模型调用脚本

llm_test/readfile.py

+import os
+cwd = os.getcwd()
+print(cwd)
+
+from pathlib import Path
+
+current_path = Path.cwd()
+parent_dir = current_path.parent
+file_path = parent_dir / 'rustscript' / 'RustScript手册.md'
+
+print(file_path)
+
+content = file_path.read_text(encoding='utf-8')
+print(content)
+
+import os
+# 升级方舟 SDK 到最新版本 pip install -U 'volcengine-python-sdk[ark]'
+from volcenginesdkarkruntime import Ark
+
+client = Ark(
+    # 从环境变量中读取您的方舟API Key
+    api_key="906ae4a7-49f1-44f7-a2e4-5b9c0bc54948",
+    # 深度思考模型耗费时间会较长，请您设置较大的超时时间，避免超时，推荐30分钟以上
+    timeout=1800,
+    )
+
+response = client.chat.completions.create(
+    # 替换 <Model> 为您的Model ID
+    model="doubao-seed-1-6-251015",
+    messages=[
+        {"role": "user", "content": "根据RustScript手册，用RustScript的语法，实现电力系统潮流计算\n" + content}
+    ],
+     thinking={
+         "type": "disabled" # 不使用深度思考能力,
+         # "type": "enabled" # 使用深度思考能力
+         # "type": "auto" # 模型自行判断是否使用深度思考能力
+     },
+)
+
+
+print(response.choices[0].message.content)

llm_test/runpf

+// 潮流计算模块 - power_flow.rs
+fn newton_pf(baseMVA, bus, gen, branch, max_iter, tol) {
+    /*
+    牛顿-拉夫逊法潮流计算
+    参数:
+      baseMVA: 基准功率
+      bus: 母线数据矩阵
+      gen: 发电机数据矩阵
+      branch: 支路数据矩阵
+      max_iter: 最大迭代次数
+      tol: 收敛容差
+    返回:
+      [收敛标志, 迭代次数, 电压幅值, 电压相角, 系统损耗]
+    */
+
+    // 常量定义（使用0基索引）
+    BUS_I = 0;      // 母线编号
+    BUS_TYPE = 1;   // 母线类型
+    PD = 2;         // 有功负荷
+    QD = 3;         // 无功负荷
+    GS = 4;         // 电导
+    BS = 5;         // 电纳
+    VM = 7;         // 电压幅值
+    VA = 8;         // 电压相角
+
+    GEN_BUS = 0;    // 发电机所连母线
+    PG = 1;         // 发电机有功
+    QG = 2;         // 发电机无功
+
+    F_BUS = 0;      // 支路首端母线
+    T_BUS = 1;      // 支路末端母线
+    BR_R = 2;       // 支路电阻
+    BR_X = 3;       // 支路电抗
+    BR_B = 4;       // 支路电纳
+
+    // 母线类型常量
+    PQ = 1;
+    PV = 2;
+    REF = 3;
+
+    // 获取系统规模
+    nb = size(bus, 0);      // 母线数量
+    ng = size(gen, 0);      // 发电机数量
+    nl = size(branch, 0);   // 支路数量
+
+    // 1. 形成节点导纳矩阵Ybus
+    Ybus = zeros(nb, nb);
+
+    for k in 0..nl {
+        // 获取支路参数
+        f = get(branch, k, F_BUS) - 1;  // 转换为0基索引
+        t = get(branch, k, T_BUS) - 1;  // 转换为0基索引
+        r = get(branch, k, BR_R);
+        x = get(branch, k, BR_X);
+        b = get(branch, k, BR_B);
+
+        // 计算支路导纳
+        if r == 0 && x == 0 {
+            y = 0;
+        } else {
+            z = r + c(0, 1) * x;
+            y = 1 / z;
+        }
+
+        // 更新节点导纳矩阵
+        // Yff
+        Yff = get(Ybus, f, f) + y + c(0, 0.5) * b;
+        assign(Ybus, [[Yff]], [f, f+1], [f, f+1]);
+
+        // Yft
+        Yft = get(Ybus, f, t) - y;
+        assign(Ybus, [[Yft]], [f, f+1], [t, t+1]);
+
+        // Ytf
+        Ytf = get(Ybus, t, f) - y;
+        assign(Ybus, [[Ytf]], [t, t+1], [f, f+1]);
+
+        // Ytt
+        Ytt = get(Ybus, t, t) + y + c(0, 0.5) * b;
+        assign(Ybus, [[Ytt]], [t, t+1], [t, t+1]);
+    }
+
+    // 添加母线并联导纳
+    for i in 0..nb {
+        gs = get(bus, i, GS);
+        bs = get(bus, i, BS);
+        Yii = get(Ybus, i, i) + c(gs, bs);
+        assign(Ybus, [[Yii]], [i, i+1], [i, i+1]);
+    }
+
+    // 2. 初始化电压
+    Vm = slice(bus, [0], [VM-1, VM]);  // 电压幅值（二维张量）
+    Va = slice(bus, [0], [VA-1]);      // 电压相角（一维张量）
+
+    // 3. 确定节点类型和索引
+    bus_type = slice(bus, [0], [BUS_TYPE-1, BUS_TYPE]);
+
+    // 统计各类节点数量
+    pq_count = 0;
+    pv_count = 0;
+
+    for i in 0..nb {
+        bus_type_i = get(bus_type, i, 0);
+        if bus_type_i == PQ {
+            pq_count = pq_count + 1;
+        } else if bus_type_i == PV {
+            pv_count = pv_count + 1;
+        }
+    }
+
+    // 创建PQ和PV节点索引
+    pq_idx = zeros(pq_count);
+    pv_idx = zeros(pv_count);
+
+    pq_count_temp = 0;
+    pv_count_temp = 0;
+
+    for i in 0..nb {
+        bus_type_i = get(bus_type, i, 0);
+        if bus_type_i == PQ {
+            assign(pq_idx, [i], [pq_count_temp, pq_count_temp+1], [0]);
+            pq_count_temp = pq_count_temp + 1;
+        } else if bus_type_i == PV {
+            assign(pv_idx, [i], [pv_count_temp, pv_count_temp+1], [0]);
+            pv_count_temp = pv_count_temp + 1;
+        }
+    }
+
+    // 合并PV和PQ节点索引
+    n = pv_count + pq_count;  // 待求变量总数
+    pvpq_idx = zeros(n);
+
+    for i in 0..pv_count {
+        val = get(pv_idx, i);
+        assign(pvpq_idx, [val], [i, i+1], [0]);
+    }
+
+    for i in 0..pq_count {
+        val = get(pq_idx, i);
+        assign(pvpq_idx, [pv_count + i, pv_count + i+1], [0], [val]);
+    }
+
+    // 4. 计算节点注入功率
+    // 4.1 计算负荷
+    Pd = slice(bus, [0], [PD-1]);  // 有功负荷
+    Qd = slice(bus, [0], [QD-1]);  // 无功负荷
+
+    // 4.2 计算发电
+    Pg = zeros(nb);
+    Qg = zeros(nb);
+
+    for g in 0..ng {
+        bus_i = get(gen, g, GEN_BUS) - 1;  // 转换为0基索引
+        pg_val = get(gen, g, PG) / baseMVA;
+        qg_val = get(gen, g, QG) / baseMVA;
+
+        // 累加发电功率
+        current_pg = get(Pg, bus_i);
+        assign(Pg, [current_pg + pg_val], [bus_i, bus_i+1], [0]);
+
+        current_qg = get(Qg, bus_i);
+        assign(Qg, [current_qg + qg_val], [bus_i, bus_i+1], [0]);
+    }
+
+    // 4.3 计算净注入功率
+    P = Pg - Pd;
+    Q = Qg - Qd;
+
+    // 5. 牛顿-拉夫逊迭代
+    converged = 0;  // 0表示未收敛，1表示收敛
+    iter = 0;
+
+    while iter < max_iter {
+        // 5.1 计算节点注入功率
+        // 创建复电压向量
+        V = zeros(1, nb);
+        for i in 0..nb {
+            V_i = c(get(Vm, i, 0), 0) * exp(c(0, 1) * get(Va, i));
+            assign(V, [[V_i]], [0, 1], [i, i+1]);
+        }
+
+        // 计算节点电流
+        I = Ybus * transpose(V);
+        S = V .* conj(I);
+
+        // 计算功率不平衡量
+        P_calc = real(S);
+        Q_calc = imag(S);
+
+        dP = P - P_calc;
+        dQ = Q - Q_calc;
+
+        // 5.2 构建雅可比矩阵
+        // 初始化雅可比矩阵
+        J = zeros(n, n);
+
+        // 5.2.1 计算雅可比矩阵元素
+        for i in 0..n {
+            bus_i = get(pvpq_idx, i);
+            Vi = get(V, 0, bus_i);
+
+            for j in 0..n {
+                bus_j = get(pvpq_idx, j);
+                Yij = get(Ybus, bus_i, bus_j);
+                Vj = get(V, 0, bus_j);
+
+                // 计算相角差
+                theta_ij = arg(Vi) - arg(Vj) - arg(Yij);
+
+                if i < pv_count {
+                    // PV节点行（对应有功方程）
+                    if j < pv_count {
+                        // PV节点列（对应相角变量）
+                        if i == j {
+                            // 对角线元素 Hii
+                            sum_val = 0;
+                            for k in 0..nb {
+                                if k != bus_i {
+                                    Yik = get(Ybus, bus_i, k);
+                                    Vk = get(V, 0, k);
+                                    theta_ik = arg(Vi) - arg(Vk) - arg(Yik);
+                                    sum_val = sum_val + abs(Vi) * abs(Vk) * abs(Yik) * sin(theta_ik);
+                                }
+                            }
+                            Hii = -abs(Vi)^2 * imag(Yij) - sum_val;
+                            assign(J, [[Hii]], [i, i+1], [j, j+1]);
+                        } else {
+                            // 非对角线元素 Hij
+                            Hij = abs(Vi) * abs(Vj) * abs(Yij) * sin(theta_ij);
+                            assign(J, [[Hij]], [i, i+1], [j, j+1]);
+                        }
+                    } else {
+                        // PQ节点列（对应电压幅值变量）
+                        if bus_i == bus_j {
+                            // 对角线元素 Nii
+                            sum_val = 0;
+                            for k in 0..nb {
+                                if k != bus_i {
+                                    Yik = get(Ybus, bus_i, k);
+                                    Vk = get(V, 0, k);
+                                    theta_ik = arg(Vi) - arg(Vk) - arg(Yik);
+                                    sum_val = sum_val + abs(Vk) * abs(Yik) * cos(theta_ik);
+                                }
+                            }
+                            Nii = abs(Vi) * real(Yij) + sum_val;
+                            assign(J, [[Nii]], [i, i+1], [j, j+1]);
+                        } else {
+                            // 非对角线元素 Nij
+                            Nij = -abs(Vi) * abs(Yij) * cos(theta_ij);
+                            assign(J, [[Nij]], [i, i+1], [j, j+1]);
+                        }
+                    }
+                } else {
+                    // PQ节点行（对应无功方程）
+                    if j < pv_count {
+                        // PV节点列（对应相角变量）
+                        if bus_i == bus_j {
+                            // 对角线元素 Jii
+                            sum_val = 0;
+                            for k in 0..nb {
+                                if k != bus_i {
+                                    Yik = get(Ybus, bus_i, k);
+                                    Vk = get(V, 0, k);
+                                    theta_ik = arg(Vi) - arg(Vk) - arg(Yik);
+                                    sum_val = sum_val + abs(Vk) * abs(Yik) * sin(theta_ik);
+                                }
+                            }
+                            Jii = abs(Vi) * real(Yij) - sum_val;
+                            assign(J, [[Jii]], [i, i+1], [j, j+1]);
+                        } else {
+                            // 非对角线元素 Jij
+                            Jij = abs(Vi) * abs(Yij) * sin(theta_ij);
+                            assign(J, [[Jij]], [i, i+1], [j, j+1]);
+                        }
+                    } else {
+                        // PQ节点列（对应电压幅值变量）
+                        if i == j {
+                            // 对角线元素 Lii
+                            sum_val = 0;
+                            for k in 0..nb {
+                                if k != bus_i {
+                                    Yik = get(Ybus, bus_i, k);
+                                    Vk = get(V, 0, k);
+                                    theta_ik = arg(Vi) - arg(Vk) - arg(Yik);
+                                    sum_val = sum_val + abs(Vk) * abs(Yik) * cos(theta_ik);
+                                }
+                            }
+                            Lii = abs(Vi) * imag(Yij) + sum_val;
+                            assign(J, [[Lii]], [i, i+1], [j, j+1]);
+                        } else {
+                            // 非对角线元素 Lij
+                            Lij = -abs(Vi) * abs(Yij) * cos(theta_ij);
+                            assign(J, [[Lij]], [i, i+1], [j, j+1]);
+                        }
+                    }
+                }
+            }
+        }
+
+        // 5.3 构建不平衡量向量
+        F = zeros(n, 1);
+
+        // PV节点的不平衡量（有功）
+        for i in 0..pv_count {
+            bus_i = get(pv_idx, i);
+            val = get(dP, bus_i);
+            assign(F, [[val]], [i, i+1], [0, 1]);
+        }
+
+        // PQ节点的不平衡量（有功和无功）
+        for i in 0..pq_count {
+            bus_i = get(pq_idx, i);
+            // 有功不平衡量
+            val_p = get(dP, bus_i);
+            assign(F, [[val_p]], [pv_count + i, pv_count + i+1], [0, 1]);
+
+            // 无功不平衡量
+            val_q = get(dQ, bus_i);
+            assign(F, [[val_q]], [pv_count + i, pv_count + i+1], [0, 1]);
+        }
+
+        // 5.4 求解修正方程
+        dx = linsolve(J, F);
+
+        // 5.5 更新电压
+        // 更新相角
+        for i in 0..n {
+            bus_i = get(pvpq_idx, i);
+            dtheta = get(dx, i, 0);
+            current_angle = get(Va, bus_i);
+            assign(Va, [current_angle + dtheta], [bus_i, bus_i+1], [0]);
+        }
+
+        // 更新电压幅值（仅PQ节点）
+        for i in 0..pq_count {
+            bus_i = get(pq_idx, i);
+            dV = get(dx, pv_count + i, 0);
+            current_voltage = get(Vm, bus_i, 0);
+            assign(Vm, [[current_voltage + dV]], [bus_i, bus_i+1], [0, 1]);
+        }
+
+        // 5.6 检查收敛条件
+        max_mismatch = 0;
+
+        // 检查PV节点的有功不平衡量
+        for i in 0..pv_count {
+            bus_i = get(pv_idx, i);
+            mismatch = abs(get(dP, bus_i));
+            if mismatch > max_mismatch {
+                max_mismatch = mismatch;
+            }
+        }
+
+        // 检查PQ节点的有功和无功不平衡量
+        for i in 0..pq_count {
+            bus_i = get(pq_idx, i);
+            mismatch_p = abs(get(dP, bus_i));
+            mismatch_q = abs(get(dQ, bus_i));
+
+            if mismatch_p > max_mismatch {
+                max_mismatch = mismatch_p;
+            }
+
+            if mismatch_q > max_mismatch {
+                max_mismatch = mismatch_q;
+            }
+        }
+
+        // 判断是否收敛
+        if max_mismatch < tol {
+            converged = 1;
+            break;
+        }
+
+        iter = iter + 1;
+    }
+
+    // 6. 计算系统损耗
+    // 重新计算复电压
+    V = zeros(1, nb);
+    for i in 0..nb {
+        V_i = c(get(Vm, i, 0), 0) * exp(c(0, 1) * get(Va, i));
+        assign(V, [[V_i]], [0, 1], [i, i+1]);
+    }
+
+    // 计算节点注入功率
+    I = Ybus * transpose(V);
+    S = V .* conj(I);
+
+    // 计算系统总损耗
+    P_loss = sum_all(real(S));
+    Q_loss = sum_all(imag(S));
+
+    // 7. 返回结果
+    // 创建结果矩阵
+    result_rows = 3 + nb + nb;
+    result = zeros(result_rows, 1);
+
+    // 收敛标志
+    assign(result, [[converged]], [0, 1], [0, 1]);
+
+    // 迭代次数
+    assign(result, [[iter]], [1, 2], [0, 1]);
+
+    // 电压幅值
+    for i in 0..nb {
+        vm_val = get(Vm, i, 0);
+        assign(result, [[vm_val]], [2 + i, 2 + i+1], [0, 1]);
+    }
+
+    // 电压相角（弧度）
+    for i in 0..nb {
+        va_val = get(Va, i);
+        assign(result, [[va_val]], [2 + nb + i, 2 + nb + i+1], [0, 1]);
+    }
+
+    // 系统有功损耗
+    assign(result, [[P_loss]], [2 + nb + nb, 2 + nb + nb+1], [0, 1]);
+
+    return result;
+}
+
+// 潮流计算示例函数
+fn run_power_flow_example() {
+    // 系统基准功率
+    baseMVA = 100;
+
+    // 最大迭代次数和收敛容差
+    max_iter = 10;
+    tol = 1e-6;
+
+    // 母线数据（IEEE 4节点系统示例）
+    bus = [
+        [1, 3, 0, 0, 0, 0, 1, 1.06, 0, 0, 1, 1.06, 0.94],
+        [2, 1, 20, 10, 0, 0, 1, 1.0, 0, 0, 1, 1.06, 0.94],
+        [3, 2, 45, 15, 0, 0, 1, 1.0, 0, 0, 1, 1.06, 0.94],
+        [4, 1, 40, 5, 0, 0, 1, 1.0, 0, 0, 1, 1.06, 0.94]
+    ];
+
+    // 发电机数据
+    gen = [
+        [1, 0, 0, 0, 0, 1.06, 100, 1, 100, 0],
+        [3, 50, 0, 0, 0, 1.0, 100, 1, 100, 0]
+    ];
+
+    // 支路数据
+    branch = [
+        [1, 2, 0.01, 0.03, 0, 0, 0, 0, 0, 0, 1, -360, 360],
+        [1, 3, 0.02, 0.05, 0, 0, 0, 0, 0, 0, 1, -360, 360],
+        [2, 3, 0.03, 0.08, 0, 0, 0, 0, 0, 0, 1, -360, 360],
+        [2, 4, 0.015, 0.04, 0, 0, 0, 0, 0, 0, 1, -360, 360],
+        [3, 4, 0.025, 0.06, 0, 0, 0, 0, 0, 0, 1, -360, 360]
+    ];
+
+    // 运行潮流计算
+    result = newton_pf(baseMVA, bus, gen, branch, max_iter, tol);
+
+    // 解析结果
+    converged = get(result, 0, 0);
+    iterations = get(result, 1, 0);
+    nb = size(bus, 0);
+
+    // 输出结果
+    print_str = "潮流计算结果:";
+    print(print_str);
+
+    if converged == 1 {
+        print_str = "收敛状态: 已收敛";
+        print(print_str);
+    } else {
+        print_str = "收敛状态: 未收敛";
+        print(print_str);
+    }
+
+    print_str = "迭代次数: " + iterations;
+    print(print_str);
+
+    // 电压幅值损耗
+    loss = get(result, 2 + nb + nb, 0);
+    print_str = "系统有功损耗: " + loss + " MW";
+    print(print_str);
+
+
+    // 母线电压结果
+    print_str = "母线电压结果:";
+    print(print_str);
+    print_str = "母线\t电压幅值(pu)\t相角(度)";
+    print(print_str);
+
+    for i in 0..nb {
+        bus_num = i + 1;  // 转换为1基编号
+        vm = get(result, 2 + i, 0);
+        va_rad = get(result, 2 + nb + i, 0);
+        va_deg = rad2deg(va_rad);
+
+
+        // 四舍五入到4位小数
+        vm_int = floor(vm * 10000);
+        vm_str = vm_int / 10000;
+
+        // 四舍五入到2位小数
+        va_int = floor(va_deg * 100);
+        va_str = va_int / 100;
+
+        print_str = bus_num + "\t" + vm_str + "\t\t" + va_str;
+        print(print_str);
+    }
+
+    return result;
+}
+
+println(run_power_flow_example())
\ No newline at end of file

llm_test/test.md

+根据RustScript语法规范，以下是实现电力系统潮流计算的完整代码。该实现包含导纳矩阵构建、牛顿-拉夫逊法潮流计算及快速解耦潮流计算三个核心功能。
+
+```rustscript
+/*
+电力系统潮流计算实现（RustScript版本）
+包含功能：
+1. 导纳矩阵构建 (make_y_bus)
+2. 牛顿-拉夫逊法潮流计算 (newton_pf)
+3. 快速解耦潮流计算 (fast_decoupled_pf)
+*/
+
+// 常量定义
+PQ = 1;       // PQ节点
+PV = 2;       // PV节点
+REF = 3;      // 平衡节点
+NONE = 4;     // 无节点类型
+
+// 母线数据列索引
+BUS_I = 0;
+BUS_TYPE = 1;
+PD = 2;
+QD = 3;
+GS = 4;
+BS = 5;
+BUS_AREA = 6;
+VM = 7;
+VA = 8;
+BASE_KV = 9;
+ZONE = 10;
+VMAX = 11;
+VMIN = 12;
+
+// 发电机数据列索引
+GEN_BUS = 0;
+PG = 1;
+QG = 2;
+QMAX = 3;
+QMIN = 4;
+VSET = 5;
+MBASE = 6;
+GEN_STATUS = 7;
+PMAX = 8;
+PMIN = 9;
+
+// 支路数据列索引
+F_BUS = 0;
+T_BUS = 1;
+BR_R = 2;
+BR_X = 3;
+BR_B = 4;
+RATE_A = 5;
+RATE_B = 6;
+RATE_C = 7;
+TAP = 8;
+SHIFT = 9;
+BR_STATUS = 10;
+ANGMIN = 11;
+ANGMAX = 12;
+
+// 导纳矩阵构建函数
+fn make_y_bus(baseMVA, bus, branch) {
+    nb = size(bus, 0);  // 母线数量
+    nl = size(branch, 0);  // 支路数量
+    
+    // 提取支路数据
+    f = slice(branch, [0], [F_BUS-1]) - 1;  // 从母线（转换为0基）
+    t = slice(branch, [0], [T_BUS-1]) - 1;  // 到母线（转换为0基）
+    r = slice(branch, [0], [BR_R-1]);       // 电阻
+    x = slice(branch, [0], [BR_X-1]);       // 电抗
+    b = slice(branch, [0], [BR_B-1]);       // 电纳
+    stat = slice(branch, [0], [BR_STATUS-1]);  // 支路状态
+    tap = slice(branch, [0], [TAP-1]);      // 变比
+    shift = slice(branch, [0], [SHIFT-1]);  // 移相角
+    
+    // 计算导纳
+    z = r + c(0, 1) * x;
+    y_series = stat ./ z;  // 串联导纳
+    y_shunt = c(0, 1) * b / 2.0;  // 并联导纳
+    
+    // 处理变压器变比和移相角
+    tap_col = slice(branch, [0], [TAP-1, TAP]);  // 变比列
+    tap_idx = find(tap_col != 0);  // 非零变比索引
+    tap_vec = set(ones(nl, 1), tap_idx, get_multi(tap_col, tap_idx));  // 变比向量
+    tap_complex = tap_vec .* exp(c(0, 1) * shift * pi / 180.0);  // 复变比
+    
+    // 计算导纳矩阵元素
+    Yff = y_series ./ (tap_complex .* conj(tap_complex)) + y_shunt;
+    Yft = -y_series ./ conj(tap_complex);
+    Ytf = -y_series ./ tap_complex;
+    Ytt = y_series + y_shunt;
+    
+    // 创建稀疏导纳矩阵
+    Ybus = sparse(
+        horzcat(f, f, t, t), 
+        horzcat(f, t, f, t), 
+        vertcat(Yff, Yft, Ytf, Ytt), 
+        nb, nb
+    );
+    
+    return Ybus;
+}
+
+// 牛顿-拉夫逊法潮流计算
+fn newton_pf(baseMVA, bus, gen, branch) {
+    // 初始化参数
+    tol = 1e-6;  // 收敛 tolerance
+    max_iter = 20;  // 最大迭代次数
+    nb = size(bus, 0);  // 母线数量
+    
+    // 构建导纳矩阵
+    Ybus = make_y_bus(baseMVA, bus, branch);
+    
+    // 初始化电压向量
+    V = slice(bus, [0], [VM-1]) .* exp(c(0,1) * slice(bus, [0], [VA-1]) * pi / 180.0);
+    
+    // 确定节点类型
+    bus_type = slice(bus, [0], [BUS_TYPE-1]);
+    ref = find(bus_type == REF);  // 平衡节点
+    pv = find(bus_type == PV);    // PV节点
+    pq = find(bus_type == PQ);    // PQ节点
+    
+    // 初始化注入功率
+    P = zeros(nb, 1);
+    Q = zeros(nb, 1);
+    
+    // 计算注入功率
+    for iter in 0..max_iter {
+        // 计算功率注入
+        S = V .* conj(Ybus * V);
+        P_calc = real(S);
+        Q_calc = imag(S);
+        
+        // 计算功率误差
+        P_error = P - P_calc;
+        Q_error = Q - Q_calc;
+        
+        // 检查收敛
+        if max(abs(vertcat(P_error, Q_error))) < tol {
+            break;
+        }
+        
+        // 构建雅可比矩阵
+        J11 = zeros(nb, nb);
+        J12 = zeros(nb, nb);
+        J21 = zeros(nb, nb);
+        J22 = zeros(nb, nb);
+        
+        for i in 0..nb {
+            for j in 0..nb {
+                if i != j {
+                    Y_ij = get(Ybus, i, j);
+                    V_i = get(V, i);
+                    V_j = get(V, j);
+                    theta_ij = arg(V_i) - arg(V_j);
+                    
+                    J11[i, j] = -abs(V_i) * abs(V_j) * abs(Y_ij) * sin(theta_ij + arg(Y_ij));
+                    J12[i, j] = -abs(V_i) * abs(Y_ij) * cos(theta_ij + arg(Y_ij));
+                    J21[i, j] = abs(V_i) * abs(V_j) * abs(Y_ij) * cos(theta_ij + arg(Y_ij));
+                    J22[i, j] = -abs(V_i) * abs(Y_ij) * sin(theta_ij + arg(Y_ij));
+                } else {
+                    sum_term = 0.0;
+                    for k in 0..nb {
+                        if k != i {
+                            Y_ik = get(Ybus, i, k);
+                            V_k = get(V, k);
+                            theta_ik = arg(V_i) - arg(V_k);
+                            sum_term += abs(Y_ik) * abs(V_k) * sin(theta_ik + arg(Y_ik));
+                        }
+                    }
+                    J11[i, i] = abs(V_i) * sum_term;
+                    J12[i, i] = abs(V_i) * real(Y_ij);
+                    J21[i, i] = -abs(V_i) * sum_term;
+                    J22[i, i] = -abs(V_i) * imag(Y_ij);
+                }
+            }
+        }
+        
+        // 求解修正方程
+        delta = linsolve(
+            [[J11, J12], [J21, J22]], 
+            vertcat(P_error, Q_error)
+        );
+        
+        // 更新电压
+        delta_theta = slice(delta, [0], [0, nb]);
+        delta_V = slice(delta, [nb], [0, nb]);
+        V = V .* exp(c(0, 1) * delta_theta) .* (1 + delta_V);
+    }
+    
+    // 更新母线电压
+    assign(bus, abs(V), [0], [VM-1]);
+    assign(bus, rad2deg(arg(V)), [0], [VA-1]);
+    
+    return bus;
+}
+
+// 快速解耦潮流计算
+fn fast_decoupled_pf(baseMVA, bus, gen, branch) {
+    // 初始化参数
+    tol = 1e-6;  // 收敛 tolerance
+    max_iter = 20;  // 最大迭代次数
+    nb = size(bus, 0);  // 母线数量
+    
+    // 构建导纳矩阵
+    Ybus = make_y_bus(baseMVA, bus, branch);
+    
+    // 初始化电压向量
+    V = slice(bus, [0], [VM-1]) .* exp(c(0,1) * slice(bus, [0], [VA-1]) * pi / 180.0);
+    
+    // 确定节点类型
+    bus_type = slice(bus, [0], [BUS_TYPE-1]);
+    ref = find(bus_type == REF);  // 平衡节点
+    pv = find(bus_type == PV);    // PV节点
+    pq = find(bus_type == PQ);    // PQ节点
+    
+    // 初始化注入功率
+    P = zeros(nb, 1);
+    Q = zeros(nb, 1);
+    
+    // 计算注入功率
+    for iter in 0..max_iter {
+        // 计算功率注入
+        S = V .* conj(Ybus * V);
+        P_calc = real(S);
+        Q_calc = imag(S);
+        
+        // 计算功率误差
+        P_error = P - P_calc;
+        Q_error = Q - Q_calc;
+        
+        // 检查收敛
+        if max(abs(vertcat(P_error, Q_error))) < tol {
+            break;
+        }
+        
+        // 构建B'和B''矩阵
+        B_prime = -imag(Ybus);
+        B_double_prime = -imag(Ybus);
+        
+        // 求解修正方程
+        delta_theta = B_prime \ (P_error ./ abs(V));
+        delta_V = B_double_prime \ (Q_error ./ abs(V));
+        
+        // 更新电压
+        V = V .* exp(c(0, 1) * delta_theta) .* (1 + delta_V);
+    }
+    
+    // 更新母线电压
+    assign(bus, abs(V), [0], [VM-1]);
+    assign(bus, rad2deg(arg(V)), [0], [VA-1]);
+    
+    return bus;
+}
+
+// 示例使用
+// 加载系统数据
+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]
+];
+
+// 运行潮流计算
+bus_results = newton_pf(baseMVA, bus, gen, branch);
+// bus_results = fast_decoupled_pf(baseMVA, bus, gen, branch);
+
+// 输出结果
+print("母线电压幅值: ", slice(bus_results, [0], [VM-1]));
+print("母线电压角度: ", slice(bus_results, [0], [VA-1]));
+```
+
+### 代码说明
+
+1. **导纳矩阵构建**：`make_y_bus`函数根据支路参数计算系统导纳矩阵，考虑了变压器变比和移相角的影响。
+
+2. **牛顿-拉夫逊法**：`newton_pf`函数实现了标准的牛顿-拉夫逊潮流算法，通过构建雅可比矩阵求解修正方程，迭代更新节点电压直到收敛。
+
+3. **快速解耦法**：`fast_decoupled_pf`函数实现了快速解耦潮流算法，利用电力系统的特性简化雅可比矩阵，提高计算速度。
+
+4. **数据结构**：采用RustScript的张量结构存储母线、发电机和支路数据，通过索引操作提取和更新数据。
+
+5. **示例数据**：包含了一个简化的4节点系统数据，可替换为实际系统数据进行计算。
+
+### 使用说明
+
+1. 加载系统数据：设置基准功率`baseMVA`，定义母线`bus`、发电机`gen`和支路`branch`数据。
+
+2. 选择潮流算法：调用`newton_pf`或`fast_decoupled_pf`函数进行潮流计算。
+
+3. 输出结果：打印母线电压幅值和角度等计算结果。
+
+该实现遵循RustScript的语法规范，使用张量操作处理所有数据，适合科学计算和电力系统分析。
+
+Process finished with exit code 0

rustscript/RustScript手册_update.md

+# RustScript 语言规范
+# RustScript 语言规范
+
+## 1. 语言概述
+
+RustScript 是一种结合了 Rust 和 MATLAB 语法特征的脚本语言，专为科学计算和矩阵操作设计。它采用基于张量的数据结构，具有强类型推导和函数式编程特征。
+
+## 2. 词法规则
+
+### 2.1 标识符
+```rustscript
+// 有效标识符
+variable_name
+matrix1
+bus_data
+PQ_bus
+```
+
+### 2.2 数值字面量
+```rustscript
+// 整数
+42
+-17
+0
+
+// 浮点数
+3.14
+-2.718
+1.23e-4
+6.022e23
+
+// 科学记数法
+1.5e10
+-2.3E-5
+```
+
+### 2.3 字符串字面量
+```rustscript
+// 字符串使用双引号
+"Hello, World!"
+"Power flow data for IEEE 14 bus"
+"File path: /data/case14.txt"
+```
+### 2.4 数学常量约定
+- π：pi
+- 自然常数：e
+- 分母为零：NAN
+- 正无穷大：INF
+- 负无穷大：NEG_INF
+
+
+### 2.5 注释
+```rustscript
+// 单行注释
+/* 多行注释 */
+
+/* 
+ * 块注释
+ * 支持多行
+ */
+```
+
+## 3. 数据类型
+
+### 3.1 基本数据类型
+- `f64`: 64位浮点数（默认数值类型）
+- `i64`: 64位整数
+- `bool`: 布尔值 (`true`, `false`)
+- `string`: 字符串类型
+- `complex`: 复数类型
+
+**注意：RustScript没有结构体类型，所有数据都基于基本类型和张量。**
+
+### 3.2 复数类型
+```rustscript
+// 复数创建
+z1 = c(3.0, 4.0);    // 3 + 4i
+z2 = c(0, 1);        // i
+z3 = c(5.0, 0);      // 实数
+
+// 复数运算
+result = z1 + z2 * 2.0;
+magnitude = abs(z1);
+phase = arg(z1);
+```
+
+### 3.3 张量类型
+```rustscript
+// 标量
+scalar = 42.0;
+
+// 1D 张量（一维张量）- shape为 [n]
+vector = [1.0, 2.0, 3.0, 4.0];  // shape: [4]
+
+// 2D 张量（二维张量）- shape为 [m, n]
+matrix = [
+    [1.0, 2.0, 3.0],
+    [4.0, 5.0, 6.0],
+    [7.0, 8.0, 9.0]
+];  // shape: [3, 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]
+
+// 3D 张量
+tensor3d = [
+    [[1.0, 2.0], [3.0, 4.0]],
+    [[5.0, 6.0], [7.0, 8.0]]
+];  // shape: [2, 2, 2]
+```
+
+**重要区别：**
+- **一维张量**：shape为 [n]，在运算时相当于行向量
+- **二维张量**：包括矩阵、行向量 [1, n]、列向量 [m, 1]
+- **行向量和列向量都属于二维张量**，但形状不同
+- 张量定义可能涉及多行代码，在行间不可以加任何注释
+
+### 3.4 数据组织方式
+由于没有结构体，复杂数据通过张量和多个相关变量来组织：
+```rustscript
+// 电力系统数据组织（无结构体方式）
+baseMVA = 100;          // 基准功率
+bus = [...];            // 母线数据矩阵
+gen = [...];            // 发电机数据矩阵
+branch = [...];         // 支路数据矩阵
+
+// 不是: mpc.baseMVA, mpc.bus 等结构体访问方式
+```
+
+## 4. 变量和赋值
+
+### 4.1 变量声明
+```rustscript
+// 变量赋值（类型推导）
+baseMVA = 100;
+voltage = 1.06;
+name = "RustScript";
+is_valid = true;
+
+// 张量赋值
+vector = [1, 2, 3, 4];
+matrix = [[1, 2], [3, 4]];
+```
+
+### 4.2 常量声明
+```rustscript
+// 常量定义（约定使用大写）
+PI = 3.14159265359;
+EULER = 2.71828;
+MAX_ITERATIONS = 1000;
+
+// 电力系统常量示例
+PQ = 1;
+PV = 2; 
+REF = 3;
+NONE = 4;
+
+// 母线数据列索引
+BUS_I = 0;
+BUS_TYPE = 1;
+PD = 2;
+QD = 3;
+```
+
+## 5. 张量操作
+
+### 5.1 张量索引
+```rustscript
+函数
+    get
+语法
+	element = get(t, row, col);  // 获取指定位置的单个元素
+    注意：不支持 A[0,1] 这样的直接索引方式
+输入参数
+    t - 张量，若为稀疏矩阵，仅能获取非零元
+    row - 行索引，标量
+    col - 列索引，标量
+    v - 向量
+示例
+    输入 get([1, 2, 3], 1)
+    结果 2
+    
+    输入 get([[1, 2, 3], [4, 5, 6], [7, 8, 9]], 1, 2)
+    结果 6
+    
+    输入 get(sparse([0,0],[0,1],[1,2], 2, 2), 0, 1)
+    结果 2
+```
+
+### 5.2 张量切片
+```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列(一维张量)
+```
+
+### 5.3 获取张量指定行列
+```rustscript
+函数
+    select
+语法
+    select(t, row_spec, col_spec)
+输入参数
+    t - 张量
+    row_spec - 行索引，数值代表单个索引，[]代表所有行，向量代表指定多行
+    col_spec - 列索引，数值代表单个索引，[]代表所有列，向量代表指定多列
+示例
+    a = [[1, 2, 3], [4, 5, 6], [7, 8, 9]];
+    输入 select(a, [0,1], [2])
+    结果 [[3], [6]]
+    
+    输入 select(a, [0,2])
+    结果 [[1, 2, 3], [7, 8, 9]]
+	
+	输入 select(a, [], [0,2])
+    结果 [[1,3], [4,6], [7,9]]
+	
+	输入 select(a, 0, [0,2])
+    结果 [[1,3]]
+```
+
+### 5.4 张量赋值操作
+```rustscript
+函数
+    assign
+语法
+    assign(target, source, row_spec, col_spec)
+输入参数
+    target - 待赋值张量
+    source - 赋值张量
+    row_spec - 行索引，数值代表单个索引，[0]代表所有行，[start,end,step]代表范围和步长
+    col_spec - 列索引，数值代表单个索引，[0]代表所有列，[start,end,step]代表范围和步长
+    重要：source的维度必须与target切片的形状匹配
+输入参数示例
+    1. 赋值二维张量 - source必须是匹配的二维张量
+    b_2d = [[1.0], [2.0], [3.0]];        // 3×1列向量(二维张量)
+    assign(a, b_2d, [0], [1, 2]);        // 正确：b_2d是3×1列向量，匹配slice(a,[0],[1,2])
+    
+    c_2d = [[1.0, 2.0, 3.0]];            // 1×3行向量(二维张量)  
+    assign(a, c_2d, [1, 2], [0]);        // 正确：c_2d是1×3行向量，匹配slice(a,[1,2],[0])
+    
+    2. 赋值一维张量 - source必须是匹配的一维张量
+    b_1d = [1.0, 2.0, 3.0];              // shape为[3]的一维张量
+    assign(a, b_1d, [0], 1);             // 正确：b_1d是一维张量，匹配slice(a,[0],1)
+    assign(a, b_1d, 1, [0]);             // 正确：b_1d是一维张量，匹配slice(a,1,[0])
+    
+    错误示例（形状不匹配）
+    // assign(a, b_1d, [0], [1, 2]);     // 错误：一维张量不能赋值给二维位置
+    // assign(a, b_2d, [0], 1);          // 错误：二维张量不能赋值给一维位置
+示例
+    a = [[1, 2, 3], [4, 5, 6], [7, 8, 9]];
+    输入 assign(a, [[-2],[-5],[-8]], [0], [1,2])
+    结果 [[1, -2, 3], [4, -5, 6], [7, -8, 9]]
+    
+    输入 assign(a, [[-4,-5,-6]], [1,2], [0])
+    结果 [[1, 2, 3], [-4, -5, -6], [7, 8, 9]];
+	
+	输入 assign(a, [[-4,-5],[-7,-8]], [1,3], [0,2])
+    结果 [[1, 2, 3], [-4, -5, 6], [-7, -8, 9]]
+	
+	输入 assign(a, [[-1,-3],[-7,-9]], [0,3,2], [0,3,2])
+    结果 [[-1, 2, -3], [4, 5, 6], [-7, 8, -9]]
+
+    输入 assign(a, [-2,-5,-8], [0], 1)
+    结果 [[1,-2,3],[4,-5,6],[7,-8,9]]
+
+    输入 assign(a, [-4,-5,-6], 1, [0])
+    结果 [[1, 2, 3], [-4, -5, -6], [7, 8, 9]]
+    
+电力系统应用示例
+    voltage = slice(bus, [0], [VM-1, VM]);      // 获取电压幅值列(二维张量)
+    new_voltage = [[1.05], [1.02], [1.01]];    // 新的电压值(二维张量)
+    assign(bus, new_voltage, [0], [VM-1, VM]); // 更新电压幅值
+    
+    angle_flat = slice(bus, [0], VA-1);         // 获取电压角度(一维张量)
+    new_angles = [0.0, -2.5, 1.2];             // 新的角度值(一维张量)
+    assign(bus, new_angles, [0], VA-1);        // 更新电压角度
+```
+
+### 5.5 张量形状和维度
+#### 5.5.1 重要概念区分
+```rustscript
+a = [1, 2, 3];          // 一维张量, shape: [3]
+b = [[1, 2, 3]];        // 行向量(二维张量), shape: [1, 3]  
+c = [[1], [2], [3]];    // 列向量(二维张量), shape: [3, 1]
+
+在运算中：
+    - 一维张量在运算时相当于行向量
+    - 行向量和列向量都属于二维张量，但形状不同
+    - slice和assign函数的行为取决于参数格式和返回的张量维度
+```
+#### 5.5.2 获取张量维数
+```rustscript
+函数
+    ndim
+语法
+    ndim(t)
+输入参数
+    t - 张量
+示例
+    输入 ndim([1, 2, 3])
+    结果 1
+
+    输入 ndim([[1, 2, 3]])
+    结果 2
+
+    输入 ndim([[1], [2], [3]])
+    结果 2
+```
+#### 5.5.3 获取指定维度大小
+```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
+```
+
+## 6. 运算符
+### 6.1 算术运算符
+#### 6.1.1 标量运算
+##### 6.1.1.1 加法
+```rustscript
+运算符
+    +
+语法
+    a + b;
+```
+##### 6.1.1.2 减法
+```rustscript
+运算符
+    -
+语法
+    a - b;
+```
+##### 6.1.1.3 乘法
+```rustscript
+运算符
+    *
+语法
+    a * b;
+```
+##### 6.1.1.4 除法
+```rustscript
+运算符
+    /
+语法
+    a / b;
+```
+##### 6.1.1.5 幂运算
+```rustscript
+运算符
+    ^
+语法
+    a ^ b;
+```
+#### 6.1.2 元素级运算（张量）
+##### 6.1.2.1 元素级加法
+```rustscript
+运算符
+    +
+语法
+    A + B;
+输入参数
+    A - 矩阵
+    B - 矩阵
+    若A的形状与B的形状相同，对应元素相加
+    若A为行向量且长度与B的列数相同，则B的每一行均与A相加，反之亦然
+	若A为列向量且长度与B的行数相同，则B的每一列均与A相加，反之亦然
+示例
+    输入 [10,20]+[[1,2],[3,4]]
+    结果 [[11,22],[13,24]]
+    
+    输入 [[10],[20]]+[[1,2],[3,4]]
+    结果 [[11,12],[23,24]]
+	
+	输入 [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)]]
+	
+	输入 [2,3]+sparse([0,1,2],[1,0,1],[2,3,6], 3, 2)
+    结果 [[2,5],[5,3],[2,9]]
+```
+##### 6.1.2.2 元素级减法
+```rustscript
+运算符
+    -
+语法
+    A - B;
+输入参数
+    A - 矩阵
+    B - 矩阵
+    若A的形状与B的形状相同，对应元素相减
+    若A为行向量且长度与B的列数相同，则B的每一行均与A相减，反之亦然
+	若A为列向量且长度与B的行数相同，则B的每一列均与A相减，反之亦然
+示例
+    输入 [10,20]-[[1,2],[3,4]]
+    结果 [[9,18],[7,16]]
+    
+    输入 [[10],[20]]-[[1,2],[3,4]]
+    结果 [[9,8],[17,16]]
+	
+	输入 [[c(1,2),c(3,4)],[c(5,6),c(7,8)]]-[c(-3,-4),c(-1,-2)]
+    结果 [[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)
+    结果 [[2,1],[-1,3],[2,3]]
+```
+##### 6.1.2.3 元素级乘法
+```rustscript
+运算符
+    .*
+语法
+    A .* B;
+输入参数
+    A - 矩阵
+    B - 矩阵
+    若A的形状与B的形状相同，对应元素相乘
+    若A为行向量且长度与B的列数相同，则B的每一行均与A相乘，反之亦然
+	若A为列向量且长度与B的行数相同，则B的每一列均与A相乘，反之亦然
+示例
+    输入 [10,20].*[[1,2],[3,4]]
+    结果 [[10,40],[30,80]]
+    
+    输入 [[100],[200]].*[[1,2],[3,4]]
+    结果 [[100,200],[600,800]]
+    
+    输入 [c(1,2),c(3,4)].*[c(5,6),c(7,8)]
+    结果 [c(-7,16),c(-11,52)]
+    
+    输入 [2,3].*sparse([0,1,2],[1,0,1],[2,3,6], 3, 2)
+    结果 [[0,6],[6,0],[0,18]]
+```
+##### 6.1.2.4 元素级除法
+```rustscript
+运算符
+    ./
+语法
+    A ./ B;
+输入参数
+    A - 矩阵
+    B - 矩阵
+    若A的形状与B的形状相同，对应元素相除
+    若A为行向量且长度与B的列数相同，则B的每一行均与A相除，反之亦然
+	若A为列向量且长度与B的行数相同，则B的每一列均与A相除，反之亦然
+示例
+    输入 [10,20]./[[1,2],[3,4]]
+    结果 [[10,10],[10/3, 5]]
+    
+    输入 [[100],[200]]./[[1,2],[3,4]]
+    结果 [[100,50],[200/3,50]]
+    
+    输入 [c(-7,16),c(-11,52)]./[c(5,6),c(7,8)]
+    结果 [c(1,2),c(3,4)]
+    
+    输入 sparse([0,1,2],[1,0,1],[2,3,6], 3, 2)./[2,3]
+    结果 [[0,2/3],[1.5,0],[0,2]]
+```
+##### 6.1.2.5 元素级幂运算
+```rustscript
+运算符
+    .^
+语法
+    A .^ n;
+输入参数
+    A - 矩阵
+    n - 标量
+示例
+    输入 [[1,2],[3,4]].^(-1)
+    结果 [[1,0.5], [1/3.,0.25]]
+    
+    输入 [c(1,2),c(3,4)].^3
+    结果 [c(-3,4),c(-7,24)]
+    
+    输入 sparse([0,1,2],[1,0,1],[2,3,6], 3, 2).^3
+    结果 [[3, 2, 0], [0, 1, 8], [1, 0, 27], [2, 1, 216]]
+```
+##### 6.1.2.6 元素级模运算
+```rustscript
+运算符
+    %
+语法
+    A % B;
+输入参数
+    A - 矩阵
+    B - 矩阵
+    若A的形状与B的形状相同，对应元素相模
+    若A为行向量且长度与B的列数相同，则B的每一行均与A相模，反之亦然
+	若A为列向量且长度与B的行数相同，则B的每一列均与A相模，反之亦然
+示例
+    输入 [10,20]%[[2,3],[4,5]]
+    结果 [[0,2],[2,0]]
+    
+    输入 [[11],[21]]%[[2,3],[4,5]]
+    结果 [[1, 2],[1, 1]]
+    
+    输入 [7,9]%sparse([0,0,1,1],[0,1,0,1],[2,3,4,6], 2, 2)
+    结果 [[1,0],[3,3]]
+```
+#### 6.1.3 矩阵运算
+##### 6.1.3.1 矩阵加法
+```rustscript
+运算符
+    +
+语法
+    A + B;
+输入参数
+    A - 矩阵
+    B - 矩阵
+    A与B的形状相同
+示例
+    输入 [[1,2],[3,4]]+[[5,6],[7,8]]
+    结果 [[6,8],[10,12]]
+    
+    输入 [[c(-3, -4), c(-1, -2)],[c(-7, -8), c(-5, -6)]]+
+        [[c(1, 2), c(3, 4)],[c(5, 6), c(7, 8)]]
+    结果 [[c(-2, -2), c(2, 2)],[c(-2, -2), c(2, 2)]]
+    
+    输入 [[1,2],[3,4]]+sparse([0,1],[1,0],[2., 3.], 2, 2)
+    结果 [[1,4],[6,4]]
+    
+    输入 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]]
+```
+##### 6.1.3.2 矩阵减法
+```rustscript
+运算符
+    -
+语法
+    A - B;
+输入参数
+    A - 矩阵
+    B - 矩阵
+    A与B的形状相同
+示例
+    输入 [[1,2],[3,4]]-[[7,8],[5,6]]
+    结果 [[-6,-6],[-2,-2]]
+    
+    输入 [[c(-3, -4), c(-1, -2)],[c(-7, -8), c(-5, -6)]]-
+        [[c(1, 2), c(3, 4)],[c(5, 6), c(7, 8)]]
+    结果 [[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)
+    结果 [[1,0],[0,4]]
+    
+    输入 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, -1], [2, 0, -6], [2, 1, 6]]
+```
+##### 6.1.3.3 矩阵标量乘法
+```rustscript
+运算符
+    *
+语法
+    n * A;
+    A * n;
+输入参数
+    n - 标量
+    A - 矩阵
+示例
+    输入 2*[[3],[2]]
+    结果 [[6],[4]]
+    
+    输入 c(1,2)*[c(1,2),c(3,4)]
+    结果 [c(-3,4),c(-5,10)]
+    
+    输入 2*sparse([1,2],[1,2],[2,3], 3, 3)
+    结果 [[3,3,0],[1,1,4],[2,2,6]]
+```
+##### 6.1.3.4 矩阵标量除法
+```rustscript
+运算符
+    /
+语法
+    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.3.8 矩阵初始化
+### 9.3.8.1 全1矩阵
+```rustscript 
+函数
+    ones
+语法
+    ones(shape)          // 根据形状向量创建全1张量
+    ones(m, n)           // 创建 m×n 全1矩阵
+    ones(n)              // 创建 n×n 全1方阵
+示例
+    输入 ones(3)
+    结果 [[1, 0, 0], [0, 1, 0], [0, 0, 1]]  // 注意：这应该是eye，不是ones
+    // 正确示例：
+    输入 ones(2, 3)
+    结果 [[1, 1, 1], [1, 1, 1]]
+    
+    输入 ones([2, 3, 4])
+    结果 形状为[2,3,4]的全1三维张量
+```
+
+### 9.3.8.2 全0矩阵
+```rustscript
+函数
+    zeros
+语法
+    zeros(shape)         // 根据形状向量创建全0张量
+    zeros(m, n)          // 创建 m×n 全0矩阵
+    zeros(n)             // 创建 n×n 全0方阵
+示例
+    输入 zeros(2, 3)
+    结果 [[0, 0, 0], [0, 0, 0]]
+    
+    输入 zeros([3])
+    结果 [0, 0, 0]
+```
+
+### 9.3.8.3 单位矩阵
+```rustscript
+函数
+    eye
+语法
+    eye(n)               // 创建 n×n 单位矩阵
+    eye(m, n)            // 创建 m×n 单位矩阵（主对角线为1）
+示例
+    输入 eye(3)
+    结果 [[1, 0, 0], [0, 1, 0], [0, 0, 1]]
+    
+    输入 eye(2, 3)
+    结果 [[1, 0, 0], [0, 1, 0]]
+```
+
+### 9.3.8.4 随机矩阵
+```rustscript
+函数
+    rand
+语法
+    rand(shape)          // 均匀分布随机数[0,1)
+    rand(m, n)           // m×n 均匀分布随机矩阵
+示例
+    输入 rand(2, 2)
+    结果 [[0.123, 0.456], [0.789, 0.234]]
+
+函数
+    randn
+语法
+    randn(shape)         // 标准正态分布随机数
+    randn(m, n)          // m×n 正态分布随机矩阵
+```
+
+### 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 线性方程组求解
+```rustscript
+函数
+    sp_linsolve
+语法
+    sp_linsolve([eqs], b, [init_val], [var_name]);
+输入参数
+    eqs - 包含变量的方程组表达式，多个方程之间用","分隔
+    b - 常数向量
+    init_val - 变量初值，用","分隔
+    var_name - 变量名称，用","分隔
+    注意：变量名称需包含在"`"中，如`x`
+返回结果
+	[变量求解结果,迭代次数]
+示例
+    输入 g1 = `x1`+3/3 * `x2`+ min(2,5)*`x3` - 1;
+        g2 = 1*3*`x2` - 4*3;
+        g3 = 1*3 * `x2`+sin(8-2)*x3 - 7;
+        b = [10,0,0];
+        r = sp_linsolve([`g1`,`g2`,`g3`], b, [], [`x1`,x2,x3]);
+    结果 [-28.79, 4, 17.89, 0]
+```
+
+### 10.2 混合整数线性规划
+```rustscript
+函数
+    intlinprog
+语法
+    intlinprog(obj, [st], var_type, [var_name]);
+输入参数
+    obj - 目标函数表达式
+    st - 约束条件表达式，多个约束条件之间用","分隔
+    var_type - 变量类型向量，1为0-1变量、2为整型变量、3为实数变量
+    var_name - 变量名称，用","分隔
+    注意：变量名称需包含在"`"中，如`x`
+返回结果
+	[变量优化结果,最优目标值,迭代次数]
+示例
+    输入 f = (5*1)*`x1`+3*`x2`+2*`x3`+(10-3)*`x4`+4*x5;
+        g1 = 2*`x1` - (2*4)*`x2` + 4*`x3` + 2*`x4` + max(1,5)*`x5` <= 5*2;
+        g2 = `x2` <= 0.2;
+        r = intlinprog(max(`f`), [`g1`,`g2`], [1,3,1,1,1], [`x1`,`x2`,`x3`,`x4`,`x5`]);
+    结果 [1, 0.2, 0, 1, 1, 16.6, 0]
+```
+
+### 10.3 非线性规划
+```rustscript
+函数
+    fmincon
+语法
+    fmincon(obj, [st], st_lower, st_upper, var_lower, var_upper, [var_name]);
+输入参数
+    obj - 目标函数表达式
+    st - 约束条件表达式，多个约束条件之间用","分隔
+    st_lower - 约束下限向量
+    st_upper - 约束上限向量
+    var_lower - 变量下限向量
+    var_upper - 变量上限向量
+    var_name - 变量名称，用","分隔
+    注意：变量名称需包含在"`"中，如`x`
+返回结果
+	[变量优化结果,最优目标值,迭代次数]
+示例
+    输入 f = `x1` * x4 * (x1 + x2 + x3) + x3;
+        g1 = `x1` * x2 * x3 * x4;
+        g2 = `x1`^2 + x2^2 + x3^2 + x4^2;
+        x_lower = [1, 1, 1, 1];
+        x_upper = [5, 5, 5, 5];
+        r = fmincon(min(`f`), [`g1`, g2], [25, 40], [2e19, 40], x_lower,x_upper,[`x1`,x2,x3,x4]);
+    结果 [0.9999999900103392, 4.742999643578124, 3.8211499789476977, 1.379408293213419, 17.014017140221718, 0]
+```
+
+## 11. 数据结构示例
+
+### 11.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]
+];
+```
+
+## 12. 模块系统
+
+### 12.1 模块导入
+```rustscript
+// 导入整个模块
+import power_flow;
+
+// 导入特定函数
+import {newton_pf, fast_decoupled_pf} from power_flow;
+
+// 别名导入
+import newton_pf as newton from power_flow;
+```
+
+### 12.2 模块定义
+```rustscript
+// 模块文件: power_flow.rs
+export fn newton_pf(baseMVA, bus, gen, branch) {
+    // 实现牛顿拉夫逊潮流计算
+}
+
+export fn fast_decoupled_pf(baseMVA, bus, gen, branch) {
+    // 实现快速解耦潮流计算
+}
+```
+
+
+## 13. 与MATLAB的对比
+
+### 13.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没有结构体概念 |
+
+### 13.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] (前闭后开)
+```
+
+### 13.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;
+}
+```
+
+### 13.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)`
+