Syslab使用手册
⋮

# 2026a V26.2 发行说明

发行时间：2026-04-03

V26.2 版本中，交互式编程环境优化了 IDE、调试、Julia 内核、绘图、APP Designer、代码生成、AI 插件、M 导入工具、帮助文档等多个模块；科学计算函数库新增了仪器控制工具箱，优化了 22 个函数库及若干个函数。

# 新增功能

# 交互式编程环境

  • IDE 界面改进

    • Julia 代码分析：提供对容器使用不稳定类型的告警，例如 Union{Float64, Float32}[]、Any[] 等，提醒用户不稳定类型容器对性能造成的影响；
    • 编码助手新增 17 个 TyGlobalOptimization（全局优化工具箱）、47 个 TyOptimization（优化工具箱）、157 个 TyPhasedArray（相控阵工具箱）、82 个 TyRF（射频工具箱）、117 个 TyRadar（雷达工具箱）、477 个 TySymbolicMath（符号数学工具箱）、175 个 TyWavelet（小波工具箱）签名帮助（Signature Help）功能，共计 1072 个函数的用法及参数帮助信息；
    • 资源管理器的搜索功能中添加开关控制是否进行文件过滤；
    • 资源管理器切换文件夹时不去修改正在运行时任务的工作目录；
    • 新增 Julia 多线程默认读取用户 CPU 物理核心数的逻辑；
    • 新建 Julia 函数库和设置函数库依赖页面修改为弹出式；
    • 首选项中新增“在编辑器顶部的滚动过程中显示嵌套的当前作用域”配置项；
    • 代码编辑器标签页支持固定宽度；
    • 软件更新后，支持持久化用户预加载配置；
    • 修复编码助手遮挡上方代码问题；
    • 修复工作区中变量名存在“.”符号时表格视图无法打开的问题。

  • 调试功能改进

    • ★新增调试优化：自动设置函数为编译或解释模式执行（实验性），启用后，可以大幅提升调试性能，但存在少数场景下函数断点不生效情况；
    • 调试控制台支持双击选中带特殊符号的函数名；
    • 调试控制台支持代码注释快捷键。

  • Julia 内核改进

    ★Julia 1.10 支持，提升 30% 以上的函数库加载速度，支持多线程 GC，减少多线程代码中的 GC 暂停时间。

  • APP Designer 功能改进

    新增微调器、滑块组件。

  • 绘图功能改进

    • ★支持曲线的数据刷亮功能；
    • ★支持图窗、坐标轴、曲线的非模态属性面板；
    • 支持设置 xlim 后，ylim 范围自动匹配缩放；
    • 支持设置刻度指数显示的数量级；
    • 云化绘图 figure 函数支持 Position 属性。

  • Syslab 代码生成功能改进

    新增 --no-inline 编译选项，禁用部分 Julia 函数的内联，以减少生成后的 C++ 代码量。

  • AI 插件改进

    Syslab AI 插件引入了 Agent 模式，并大幅加强了 AI 对项目的理解能力。

    • 优化上下文动态感知与添加方式：
      • 支持输入框通过 @ 符号添加 AI 上下文
      • 支持通过文件拖拽至输入框的方式添加 AI 上下文
    • 集成大量 AI 工具，同时支持工具执行权限管理：
      • 文件类：read file, edit file, create file
      • 搜索类：grep, glob, ls, code search, mds search
      • 网页类：web_fetch, web_search (实验性功能)
      • 执行类：shell interpreter
      • 通用类：
        • ask user 工具辅助澄清用户需求
        • load skills 加载外部 skills
    • 支持 DiffPatch 格式的代码生成与提交，以清晰的可视化方式展示代码变更；
    • 优化代码补全状态管理模块，更准确地提示用户代码补全情况。

  • M 导入工具改进

    • ★新增 M 脚本打包为可执行程序功能；
    • ★新增 actxserver 函数，支持调用 Windows 上具备 COM 接口的软件（如 Excel）；
    • M 内核完善：类支持重载 subsasgn 和 subsref 方法；
    • 文件 IO 部分函数性能优化：
      • xlsread(1e7 数据量，11.8s->6 s)
      • xlswrite(1e7 数据量，5 min 以上->48 s)
      • writematrix(1e6 数据量，5 min 以上->4.6 s)
      • writecell（1e6 数据量，5 min 以上->5 s）
    • 新增 M 函数 15 个，当前函数总数 2048 个。

  • 帮助文档改进

    新增 30 个数学统计与优化综合示例，共提供 303 个综合示例。

# 科学计算函数库

# 功能优化

  • 基础工具箱

    • 基础工具箱新增 1 个函数，改进 28 个函数，增加中英文报错国际化处理；
    • 图形工具箱新增 1 个函数，改进 28 个函数；
    • 基础数学工具箱新增 4 个函数，改进 38 个函数，增加中英文打印、绘图信息国际化处理。

  • 数学、统计和优化

    • 曲线拟合工具箱改进 1 个函数，增加中英文打印、绘图信息国际化处理；
    • 统计工具箱新增 4 个函数，改进 14 个函数，增加中英文打印、绘图信息国际化处理；
    • 优化工具箱改进 4 个函数；
    • 符号数学工具箱改进 1 个函数；
    • 全局优化工具箱，增加中英文打印、绘图信息国际化处理。

  • 信号处理和无线通信

    • 信号处理工具箱改进 23 个函数；
    • 通信工具箱改进 3 个函数，增加中英文报错国际化处理；
    • 雷达工具箱增加中英文报错国际化处理；
    • 射频工具箱改进 2 个函数，增加中英文报错国际化处理；
    • DSP 系统工具箱增加中英文报错国际化处理；
    • 小波工具箱增加中英文报错国际化处理；
    • 相控阵工具箱增加中英文报错国际化处理。

  • 控制系统

  • 图像处理和计算机视觉

    图像处理工具箱改进 3 个函数，增加中英文报错国际化处理。

  • AI 与数据科学

    • 机器学习工具箱新增 2 个函数，增加中英文报错国际化处理；
    • 深度学习工具箱增加中英文报错国际化处理；
    • 强化学习工具箱增加中英文报错国际化处理。

  • 测试与测量

    ★新增仪器控制工具箱，发布 47 个函数。仪器控制工具支持 Syslab 直接与示波器、函数发生器、信号分析仪、信号发生器、电源和分析仪器等设备进行连接。该工具箱基于 VISA、串口、TCP/IP 等常用通信协议/接口的文本型 SCPI 命令实现仪器连接。

  • 代码生成

    定点设计工具箱新增 1 个函数，增加中英文打印、绘图信息国际化处理。

# 性能优化

函数库 优化函数 优化前/s 优化后/s 优化后 / 优化前 备注
基础库 fprintf 2.15298 0.756414 3.51E-01 200W*2
基础库 importdata 2.279 0.15413 6.76E-02 200W*2
基础库 fwrite 2.127 0.617913 2.905E-01 4 亿 UInt8
基础库 fread 2.37 1.769 7.46E-01 4 亿 Int64
基础库 find 0.136941 7.67E-06 5.60E-05 9000W（查找 1000W 个）
基础库 regexp 15.891 0.866617 5.45E-02 300W 字符串数组
基础库 ismember 1.258 0.840989 6.69E-01 8000W Int64
基础库 compose 6.664 1.647 2.47E-01 200W 字符串
基础库 sscanf 0.002668 0.00000648 2.43E-03 300
基础库 fullfile 1.33 0.002029 1.53E-03 3w 字符串
基础库 textscan 7.094 1.491 0.210177615 500W
基础库 clear 0.672815 0.003169 0.004710061 1W 变量 clear()
基础库 regexprep 192.349849 0.023756 0.000123504 400W 字符串
基础库 dir 0.332374 0.004579 0.013776649 1W
基础库 clearvars 1.79724 0.0053 2.95E-03 1W 正则 +except 正则
基础库 logspace 16.097 4.839 0.300615021 10^1-10^8 取 10 亿数据
基础库 bitshift 9.854 0.216511 0.02197189 3000W
基础库 ty_sort 0.777811 0.218055 2.80E-01 900W 向量
基础库 ind2sub 4.929 0.953869 1.94E-01 3 亿（1W*1W*3）（查找 1 亿）
基础库 mode 2.716 0.032653 1.20E-02 按行 300W*4 nargout=1
基础库 num2array 2.568 0.013505 5.26E-03 3000*1000*3 合并 1、3 维度
基础库 datevec 8.04 0.334406 4.16E-02 300W 字符串数组
基础库 dec2base 0.837409 0.185935 2.22E-01 300W 转 8 进制
基础库 sortrows 3.107 0.053832 0.017326038 60W*7 矩阵
基础库 what 0.012319 0.010845 0.880347431 2W 个 Julia 文件（1 W 个.jl 文件+5k 个.jld 文件+5k 个.jld2 文件）
基础库 ndgrid 0.049759 0.012558 0.252376455 2000*2000 dims=2
图形库 area 0.323508 0.183217 0.566344573 /
图形库 scatter3 0.431757 0.232105 0.537582483 数据量 100W
图形库 bar 10.596599 3.411415 0.321934896 数据量 100W
图形库 stem 4.326508 0.264222 0.061070498 数据量 100W
图形库 colormap 0.11269 0.034591 0.306957139 /
图形库 findobj 0.043234 0.020371 0.47118009 /
图形库 yline 0.090252 0.03991 0.442206267 /
图形库 datestr 0.175001 0.045022 0.257267101 /
图形库 histogram 405.76837 4.06146 0.010009307 数据量 100W
图形库 line 0.610853 0.222558 0.364339702 数据量 100W
图形库 text 0.206819 0.021496 0.103936292 /
图形库 loglog 0.487933 0.167817 0.343934516 /
图形库 xticks 0.154503 0.028666 0.18553685 /
图形库 yticks 0.156378 0.028366 0.181393802 /
图形库 axis 0.129293 0.076524 0.591864989 /
图形库 hist 8.120674 3.60387 0.443789518 数据量 100W
图形库 tightlayout 0.233967 0.111239 0.475447392 /
图形库 plot3 1.05706 0.306088 0.289565398 /
图形库 contour 0.491691 0.253316 0.515193485 /
图形库 contourf 0.428847 0.282082 0.657768388 /
图形库 surf 0.35441 0.232143 0.655012556 数据量 1000*1000
图形库 contourc 1.235383 0.636208 0.514988469 数据量 300*300
数学库 nextpow2 2.5214045 0.9831703 0.389929621 /
数学库 pow2 1.745968 0.8696541 0.498092806 /
数学库 trapz 2.9783435 0.6416211 0.215428845 /
数学库 unwarp 1.4731233 0.6290666 0.427029156 /
数学库 polyfit 2.2169282 1.4439906 0.651347482 /
数学库 polyval 2.5158498 0.7530429 0.299319498 /
数学库 interp 23.9082829 2.3515958 0.098359042 makima 方法
数学库 interp2 3.8502835 3.0081185 0.78127195 cubic 方法
数学库 interp2 3.6713003 0.0069109 0.001882412 spline 方法
数学库 numgrid 0.2799055 0.1930405 0.689663118 /
数学库 interp1 0.0007312 0.0004316 0.590262582 linear 方法
数学库 interp1 5.8492554 1.5904753 0.271910729 cubic 方法
数学库 interp1 0.0276708 0.0173616 0.627433974 nearest 方法
数学库 interp3 0.5768887 0.3230075 0.55991303 linear 方法
数学库 interp3 8.5926581 1.9896301 0.231550014 nearest 方法
数学库 griddata 1.2091777 0.0254146 0.021018085 linear 方法
数学库 griddata 1429.171243 0.513472163 0.00035928 natural 方法
数学库 griddata 0.513472163 0.5664254 1.103127766 cubic 方法
数学库 randn 91.216643 17.7773596 0.194891623 /
数学库 rand 42.2906865 7.4443176 0.176027353 /
数学库 randg 14.262869 3.5358899 0.247908741 /
数学库 randi 41.8595443 13.0192443 0.311022122 /
数学库 randperm 9.7619183 8.1233741 0.832149364 /
数学库 randpermk 5.232679 1.7924966 0.342558105 /
数学库 sprand 75.3914006 70.4227105 0.934094737 /
数学库 sprandn 77.852003 70.9930811 0.911897939 /
数学库 mfft 1.472 0.810545 0.550641984 /
数学库 ode15s 0.647622 0.1988011 0.306970887 /
统计库 ty_minimum 267.6874818 6.059718 2.26E-02 /
统计库 ty_maximum 266.8176714 5.88856 2.21E-02 /
统计库 normcdf 0.161162 0.0617023 3.83E-01 /
统计库 normrnd 2.7193027 1.8063446 6.64E-01 /
统计库 cdf 31.5026422 3.0565026 9.70E-02 /
优化库 quadprog 20.3607862 0.858383 4.22E-02 /
信号库 square 7.78E-02 2.44E-02 3.14E-01 /
信号库 grpdelay 2.26E-01 8.77E-02 3.87E-01 /
信号库 findpeaks 2.56E+01 5.61E-02 2.19E-03 /
信号库 downsample 1.78E-02 3.40E-03 1.91E-01 /
信号库 fir1 2.11E+00 9.20E-01 4.36E-01 /
信号库 sawtooth 1.74E-01 2.54E-02 1.47E-01 /
信号库 bilinear 7.259E-02 5.320E-02 7.328E-01 /
信号库 freqz 1.23E-01 6.38E-02 5.17E-01 /
信号库 butter 2.53E-02 1.95E-02 7.72E-01 /
信号库 maxflat 1.33E-04 9.37E-05 7.06E-01 /
信号库 finddelay 2.18E+00 3.45E-01 1.58E-01 /
信号库 ty_pwelch 2.53E-01 9.17E-02 3.63E-01 /
信号库 czt 1.32E-02 9.97E-03 7.54E-01 /
信号库 hilbert 1.21E+00 1.37E-01 1.14E-01 /
信号库 freqs 1.10E+01 2.52E+00 2.29E-01 /
信号库 upsample 2.24E-02 2.21E-02 9.83E-01 /
信号库 invfreqz 2.88E+00 1.92E+00 6.67E-01 /
信号库 pspectrum 63.99 6.44 1.01E-01 /
信号库 pulstran 4.39E-01 4.99E-04 1.14E-03 /
信号库 vmd 7.92 1.32 1.67E-01 /
通信库 bi2de 6.42E-02 3.90E-03 6.07E-02 /
通信库 de2bi 9.74E-04 4.39E-04 4.51E-01 /
通信库 awgn 5.44E-05 3.82E-05 7.02E-01 /
控制库 isreal 0.017357 0.013141 0.757100881 /
控制库 norm 7.666806 0.60576 0.079010738 /
控制库 initial 0.0013 0.00048 0.369230769 /
控制库 step 0.000478 0.00021 0.439330544 /
鲁棒控制库 diag 0.053048 0.019739 0.372096969 /
图像库 copy 0.167 0.059 0.353293413 数据量 100W
图像库 bwdist 346.9 0.0046 1.32603E-05 数据量 20W
图像库 imdilate 0.0031 0.0023 0.741935484 数据量 100W

  • 基础工具箱

    • fprintf：针对 fprintf 进行了性能优化；

      using TyBase
using BenchmarkTools
A = repeat(
    [
        8.8 7.7
        8800 7700
    ],
    1000000,
);
formatSpec = "X is %4.2f meters or %8.3f mm\n"
fid = fopen("fprintf_test.txt", "w")

@btime fprintf(fid, formatSpec, A)

fclose(fid)
rm("fprintf_test.txt")

      大致的执行时间是：
      R2026a： 2.15 秒
      R2026a SP1： 0.76 秒

    • importdata：针对 importdata 进行了性能优化；

      using TyBase
using BenchmarkTools
A = repeat(
    [
        8.8 7.7
        8800 7700
    ],
    1000000,
)
filename = "num.txt"
save(filename, "-ascii"; A)

@btime importdata("num.txt");

      大致的执行时间是：
      R2026a： 2.28 秒
      R2026a SP1： 0.15 秒

    • fwrite：针对 fwrite 进行了性能优化；

      using TyBase
using BenchmarkTools
fname = "data.bin"

A = repeat(
    [
        8 7
        88 77
    ],
    100000000,
)

fid = fopen(fname, "w");

@btime fwrite(fid, A, "UInt8");

fclose(fid)

      大致的执行时间是：
      R2026a： 2.13 秒
      R2026a SP1： 0.62 秒

    • fread：针对 fread 进行了性能优化；

      using TyBase
using BenchmarkTools
fname = "data_bin"
A = repeat(
    [
        8 7
        8800 7700
    ],
    100000000,
)
fid = fopen(fname, "w");
fwrite(fid, A, "Int64")
fclose(fid)

fid = fopen(fname);
@btime begin
    seek(fid, 0)
    fread(fid, "Int64")
end
fclose(fid)

      大致的执行时间是：
      R2026a： 2.37 秒
      R2026a SP1： 1.77 秒

    • find：针对 find 进行了性能优化；

      using TyBase
using BenchmarkTools
X = repeat([1 0 2; 0 1 1; 0 0 4], 10000000);

@btime find(X, 10000, "last");

      大致的执行时间是：
      R2026a： 0.14 秒
      R2026a SP1： 7.67e-6 秒

    • regexp：针对 regexp 进行了性能优化；

      using TyBase
using BenchmarkTools
str = ["Madrid, Spain" "Romeo and Juliet" "Syslab is great"];
str2 = repeat(str, 1000000, 1)
capExpr = r"[A-Z]";

@time regexp(str2, capExpr);
@btime regexp(str2, capExpr);

      大致的执行时间是：
      R2026a： 15.90 秒
      R2026a SP1： 0.87 秒

    • ismember：针对 ismember 进行了性能优化；

      using TyBase
using BenchmarkTools
A_matrix = repeat(
    [
        1 3 5 7
        2 4 6 8
    ], 10000000)

B_400w_matrix = repeat(
    [
        1 3 5 6
        2 4 6 8
    ], 10000000)

@btime ismember(A_matrix, B_400w_matrix; rows=true)

      大致的执行时间是：
      R2026a： 1.26 秒
      R2026a SP1： 0.84 秒

    • compose：针对 compose 进行了性能优化；

      using TyBase
using BenchmarkTools
A = repeat([pi exp(1)], 2000000)
formatSpec = "The value of pi is %.2e; the value of e is %.5f.";
largeString = repeat(formatSpec, 2000000)
@btime compose(formatSpec, A);

      大致的执行时间是：
      R2026a： 6.67 秒
      R2026a SP1： 1.65 秒

    • sscanf：针对 sscanf 进行了性能优化；

      using TyBase
using BenchmarkTools
str = "2.7183  3.1416  0.0073  "    # 24
str2 = repeat(str, 100);
@btime sscanf(str, "%f");

      大致的执行时间是：
      R2026a： 0.002668 秒
      R2026a SP1： 6.48e-6 秒

    • fullfile：针对 fullfile 进行了性能优化；

      using TyBase
using BenchmarkTools
components = repeat(["myfolder", "mysubfolder", "myfile.jl"], 10000)
@btime fullfile(components...)

      大致的执行时间是：
      R2026a： 1.33 秒
      R2026a SP1： 0.0021 秒

    • textscan：针对 textscan 进行了性能优化；

      using TyBase
using BenchmarkTools
str = "0.41 8.24 3.57 6.24 9.27 "
str2 = repeat(str, 1000000);

@btime textscan(str2, "%f");

      大致的执行时间是：
      R2026a： 7.09 秒
      R2026a SP1： 1.49 秒

    • clear：针对 clear 进行了性能优化；

      using TyBase
for i in 1:10000
    eval(Meta.parse("global var$i = $i"))
end
variable_names = ["var$i" for i in 1:10000]
@time clear()

      大致的执行时间是：
      R2026a： 0.67 秒
      R2026a SP1： 0.0032 秒

    • regexprep：针对 regexprep 进行了性能优化；

      using TyBase
using BenchmarkTools
str = "bat cat can car coat court CUT ct CAT-scan";
str2 = repeat(str, 100000)
expression = r"c[aeiou]+t";
replace1 = "--"
@btime regexprep(str2, expression, replace1);

      大致的执行时间是：
      R2026a： 192.35 秒
      R2026a SP1： 0.024 秒

    • dir：针对 dir 进行了性能优化；

      filedir = "File_test"
mkdir(filedir)
# 创建 10000 个空文件
for i in 1:10_000
    filename = joinpath(filedir, "file_$(i).txt")
    open(filename, "w") do f
        # 不写内容，生成空文件
    end
end

using TyBase
using BenchmarkTools

@btime dir("File_test");

      大致的执行时间是：
      R2026a： 0.33 秒
      R2026a SP1： 0.0046 秒

    • clearvars：针对 clearvars 进行了性能优化；

      using TyBase
for i in 1:10000
    eval(Meta.parse("global var$i = $i"))
end
variable_names = ["var$i" for i in 1:10000]

re = r"^var"
re2 = r"^var(9000|900[1-9]|9[1-9][0-9]{3}|10000)$"
@time clearvars("-regexp", re, "-except", "-regexp", re2)

      大致的执行时间是：
      R2026a： 1.80 秒
      R2026a SP1： 0.0053 秒

    • logspace：针对 logspace 进行了性能优化；

      using TyBase
using BenchmarkTools

@btime logspace(1, 8, 1e9);

      大致的执行时间是：
      R2026a： 16.10 秒
      R2026a SP1： 4.84 秒

    • bitshift：针对 bitshift 进行了性能优化；

      using TyBase
using BenchmarkTools
A = repeat([1 2 3], 10000000, 1)
B = repeat([1 2 3], 10000000, 1)

@btime bitshift(A, B);

      大致的执行时间是：
      R2026a： 9.85 秒
      R2026a SP1： 0.22 秒

    • ty_sort：针对 ty_sort 进行了性能优化；

      using TyBase
using BenchmarkTools
A = repeat([3, 6, 5, 7, -2, 4, 1, 0, -9], 1000000)

@btime ty_sort(A);

      大致的执行时间是：
      R2026a： 0.78 秒
      R2026a SP1： 0.22 秒

    • ind2sub：针对 ind2sub 进行了性能优化；

      using TyBase
using BenchmarkTools
sz = [10000, 10000, 3]
ind2 = 1e8:2e8

@btime ind2sub(sz, ind2);

      大致的执行时间是：
      R2026a： 4.93 秒
      R2026a SP1： 0.95 秒

    • mode：针对 mode 进行了性能优化；

      using TyBase
using BenchmarkTools
A = repeat([3 3 1 4; 0 0 1 1; 0 1 2 4], 1000000, 1)

@btime mode(A, 2; nargout=1);

      大致的执行时间是：
      R2026a： 2.72 秒
      R2026a SP1： 0.033 秒

    • num2array：针对 num2array 进行了性能优化；

      using TyBase
using BenchmarkTools
A = repeat([8 1 6; 3 5 7; 4 9 2], 1000000, 1);
A = reshape(A, 3000, 1000, 3)

@btime num2array(A, [1 3]);

      大致的执行时间是：
      R2026a： 2.57 秒
      R2026a SP1： 0.014 秒

    • datevec：针对 datevec 进行了性能优化；

      using TyBase
using BenchmarkTools
DateString = repeat(["09/16/2007"; "05/14/1996"; "11/29/2010"], 1000000, 1);
formatIn = "mm/dd/yyyy";

@btime datevec(DateString, formatIn);

      大致的执行时间是：
      R2026a： 8.04 秒
      R2026a SP1： 0.33 秒

    • dec2base：针对 dec2base 进行了性能优化；

      using TyBase
using BenchmarkTools
D = repeat([1023 122 14], 1000000, 1);

@btime dec2base(D, 8);

      大致的执行时间是：
      R2026a： 0.84 秒
      R2026a SP1： 0.19 秒

    • sortrows：针对 sortrows 进行了性能优化；

      using TyBase
using BenchmarkTools
A = [
    95 45 92 41 13 1 84
    95 7 73 89 20 74 52
    95 7 73 5 19 44 20
    95 7 40 35 60 93 67
    76 61 93 81 27 46 83
    76 79 91 0 19 41 1
]

A = repeat(A, 100000, 1)

@btime sortrows(A);

      大致的执行时间是：
      R2026a： 3.11 秒
      R2026a SP1： 0.054 秒

    • what：针对 what 进行了性能优化；

      使用脚本建 2W 个 Julia 文件（1W 个.jl 文件+5k 个.jld 文件+5k 个.jld2 文件）:

      """
generate_empty_test_files(root; n_jl=10000, n_jld=5000, n_jld2=5000, overwrite=false)

生成大量空测试文件。
"""
function generate_empty_test_files(
    root::AbstractString;
    n_jl::Int=10_000,
    n_jld::Int=5_000,
    n_jld2::Int=5_000,
    overwrite::Bool=false,
)
    mkpath(root)

    created_jl = 0
    created_jld = 0
    created_jld2 = 0
    skipped = 0

    for i in 1:n_jl
        filename = joinpath(root, "test_$(lpad(i, 5, '0')).jl")
        if !overwrite && isfile(filename)
            skipped += 1
            continue
        end
        touch(filename)
        created_jl += 1
    end

    for i in 1:n_jld
        filename = joinpath(root, "data_$(lpad(i, 5, '0')).jld")
        if !overwrite && isfile(filename)
            skipped += 1
            continue
        end
        touch(filename)
        created_jld += 1
    end

    for i in 1:n_jld2
        filename = joinpath(root, "data2_$(lpad(i, 5, '0')).jld2")
        if !overwrite && isfile(filename)
            skipped += 1
            continue
        end
        touch(filename)
        created_jld2 += 1
    end

    println("生成完成：")
    println("  .jl   文件: ", created_jl)
    println("  .jld  文件: ", created_jld)
    println("  .jld2 文件: ", created_jld2)
    println("  跳过文件数: ", skipped)
    println("  目标目录: ", abspath(root))

    return nothing
end

generate_empty_test_files(raw"D:\syslab code\test_what_files")

      using TyBase
using BenchmarkTools

@btime redirect_stdout(devnull) do
    s = what(raw"D:\syslab code\test_what_files")
end

      大致的执行时间是：
      R2026a： 0.0124 秒
      R2026a SP1： 0.0108 秒

    • ndgrid：针对 ndgrid 进行了性能优化。

      using TyBase
using BenchmarkTools
x1 = 1:2:4000
x2 = 2:2:4000

@btime ndgrid(x1, x2);

      大致的执行时间是：
      R2026a： 0.050 秒
      R2026a SP1： 0.013 秒

      此代码是运行在 Windows 11 的 16 核 Intel(R) Core(TM) Ultra 9 185H @ 2.30 GHz 的客户端版本 Syslab，使用 Julia 的 @btime、@time 宏进行计时。

  • 图形工具箱

    • area：针对 area 进行了性能优化；

      using TyPlot

Y = [[1, 5, 3], [3, 2, 7], [1, 5, 3], [2, 6, 1]];
figure()
@time area(Y)

      大致的执行时间是：
      R2026a： 0.323508 秒
      R2026a SP1： 0.183217 秒

    • scatter3：针对 scatter3 进行了性能优化；

      using TyPlot

x = rand(1000000);
figure()
@time scatter3(x, x, x)

      大致的执行时间是：
      R2026a： 0.431757 秒
      R2026a SP1： 0.232105 秒

    • bar：针对 bar 进行了性能优化；

      using TyPlot

figure()
x = 1:1000000;
@time bar(x)

      大致的执行时间是：
      R2026a： 10.596599 秒
      R2026a SP1： 2.168764 秒

    • stem：针对 stem 进行了性能优化；

      using TyPlot

figure()
x = 1:1000000;
@time stem(x)

      大致的执行时间是：
      R2026a： 4.326508 秒
      R2026a SP1： 0.264222 秒

    • colormap：针对 colormap 进行了性能优化；

      using TyPlot

x, y, z = peaks();
c = surf(x, y, z);
@time colormap(c, "winter")

      大致的执行时间是：
      R2026a： 0.11269 秒
      R2026a SP1： 0.034591 秒

    • findobj：针对 findobj 进行了性能优化；

      using TyPlot

plot(rand(100, 100));
@time findobj()

      大致的执行时间是：
      R2026a： 0.043234 秒
      R2026a SP1： 0.020371 秒

    • yline：针对 yline 进行了性能优化；

      using TyPlot

figure()
@time yline(5)

      大致的执行时间是：
      R2026a： 0.090252 秒
      R2026a SP1： 0.03991 秒

    • datestr：针对 datestr 进行了性能优化；

      using TyPlot

t = [now(); now() + Day(1)]
@time datestr(t)

      大致的执行时间是：
      R2026a： 0.175001 秒
      R2026a SP1： 0.045022 秒

    • histogram：针对 histogram 进行了性能优化；

      using TyPlot

x = randn(4000000, 1);
nbins = 1000000;
@time histogram(x, nbins)

      大致的执行时间是：
      R2026a： 405.76837 秒
      R2026a SP1： 4.06146 秒

    • line：针对 line 进行了性能优化；

      using TyPlot

figure()
x = 1:1000000;
y = rand(1000000, 1);
@time line(x, y)

      大致的执行时间是：
      R2026a： 0.610853 秒
      R2026a SP1： 0.222558 秒

    • text：针对 line 进行了性能优化；

      using TyPlot

ax = gca()
@time text(0.5, 0.5, "text")

      大致的执行时间是：
      R2026a： 0.206819 秒
      R2026a SP1： 0.021496 秒

    • loglog：针对 loglog 进行了性能优化；

      using TyPlot

x = rand(1000000, 1);
figure()
@time loglog(x)

      大致的执行时间是：
      R2026a： 0.487933 秒
      R2026a SP1： 0.167817 秒

    • xticks：针对 xticks 进行了性能优化；

      using TyPlot

plot(1:10)
@time xticks([1 5 10])

      大致的执行时间是：
      R2026a： 0.154503 秒
      R2026a SP1： 0.028666 秒

    • yticks：针对 yticks 进行了性能优化；

      using TyPlot

plot(1:10)
@time yticks([1, 5, 10])

      大致的执行时间是：
      R2026a： 0.156378 秒
      R2026a SP1： 0.028366 秒

    • axis：针对 axis 进行了性能优化；

      using TyPlot

plot(rand(1000000, 1));
@time axis([0 2*pi -1.5 1.5])

      大致的执行时间是：
      R2026a： 0.129293 秒
      R2026a SP1： 0.076524 秒

    • hist：针对 hist 进行了性能优化；

      using TyPlot

figure()
x = randn(400000, 1);
nbins = 1000000;

@time hist(x, nbins)

      大致的执行时间是：
      R2026a： 8.120674 秒
      R2026a SP1： 3.60387 秒

    • tightlayout：针对 tightlayout 进行了性能优化；

      using TyPlot

plot(rand(1000000, 1))
@time tightlayout()

      大致的执行时间是：
      R2026a： 0.233967 秒
      R2026a SP1： 0.111239 秒

    • plot3：针对 plot3 进行了性能优化；

      using TyPlot

figure()
x = 1:1000000;
@time plot3(x, x, x)

      大致的执行时间是：
      R2026a： 1.05706 秒
      R2026a SP1： 0.306088 秒

    • contour：针对 contour 进行了性能优化；

      using TyPlot

X, Y, Z = peaks();
figure()
@time contour(X, Y, Z, 20)

      大致的执行时间是：
      R2026a： 0.491691 秒
      R2026a SP1： 0.253316 秒

    • contourf：针对 contourf 进行了性能优化；

      using TyPlot

X, Y, Z = peaks();
figure()
@time contourf(Z)

      大致的执行时间是：
      R2026a： 0.428847 秒
      R2026a SP1： 0.282082 秒

    • surf：针对 surf 进行了性能优化；

      using TyPlot

figure()
X, Y, Z = peaks(1000);
@time surf(Z)

      大致的执行时间是：
      R2026a： 0.35441 秒
      R2026a SP1： 0.232143 秒

    • contourc：针对 contourc 进行了性能优化。

      using TyPlot

Z = rand(300, 300);
@time contourc(Z);

      大致的执行时间是：
      R2026a： 1.235383 秒
      R2026a SP1： 0.636208 秒

      此代码运行在 Windows 10 客户端系统上，硬件配置为 12th Gen Intel(R) Core(TM) i7-12700H @ 2.30 GHz 处理器。使用 Julia 的@time 宏进行计时。

  • 数学工具箱

    • interp1：一维数据插值（表查找）；

      使用 linear 方法进行计算时性能得到了提升，示例如下：

      using TyMath
using TyBase
rng = MT19937ar(5489)
xdata = 1:100000
ydata = rand(100000) .+ xdata
zdata = rand(100000) .+ xdata

F = interp1(xdata, ydata, zdata, "linear", "linear")

      大致的执行时间是：
      R2026a： 0.0007312 秒
      R2026a SP1： 0.0004316 秒

      此代码是运行在 Windows 11 的 8 核 Intel(R) Core(TM) i3-13100T @ 2.5 GHz 测试环境上利用 julia 的@elapsed、@belapsed 综合得出。

      使用 cubic 方法进行计算时性能得到了提升，示例如下：

      using TyMath
using TyBase
rng = MT19937ar(5489)
xdata = 1:100000000
ydata = rand(100000000) .+ xdata
zdata = rand(100000000) .+ xdata

F = interp1(xdata, ydata, zdata, "cubic")

      大致的执行时间是：
      R2026a： 5.8492554 秒
      R2026a SP1： 1.5904753 秒

      此代码是运行在 Windows 11 的 8 核 Intel(R) Core(TM) i3-13100T @ 2.5 GHz 测试环境上利用 julia 的@elapsed、@belapsed 综合得出。

      使用 nearest 方法进行计算时性能得到了提升，示例如下：

      using TyMath
using TyBase
rng = MT19937ar(5489)
sig_len = 20971520
sig_ana = rand(rng,1, 20971520)
cc = rand(rng,20971520, 1)
x = 1:sig_len
y = vec(sig_ana)
xq = vec(cc)

sin_sig = interp1(x,y,xq, "nearest");

      大致的执行时间是：
      R2026a： 0.0276708 秒
      R2026a SP1： 0.0173616 秒

      此代码是运行在 Windows 11 的 8 核 Intel(R) Core(TM) i3-13100T @ 2.5 GHz 测试环境上利用 julia 的@elapsed、@belapsed 综合得出。

    • interp2：meshgrid 格式的二维网格数据插值；

      使用 makima 方法进行计算时性能得到了提升，示例如下：

      using TyMath
using TyBase
rng = MT19937ar(5489)
x, y = meshgrid2(0.02:0.02:100, 0.02:0.02:100);
z = cos.(x) .+ sin.(y);
a, b = meshgrid2(0.02:0.02:100, 0.02:0.02:100);
a = a .+ rand(rng, 5000, 5000)
b = b .+ rand(rng, 5000, 5000)
# mtest-setup end
c = interp2(x, y, z, a, b, "makima")

      大致的执行时间是：
      R2026a： 23.9082829 秒
      R2026a SP1： 2.3515958 秒

      此代码是运行在 Windows 11 的 8 核 Intel(R) Core(TM) i3-13100T @ 2.5 GHz 测试环境上利用 julia 的@elapsed、@belapsed 综合得出。

      使用 spline 方法进行计算时性能得到了提升，示例如下：

      using TyMath
using TyBase
rng = MT19937ar(5489)
x, y = meshgrid2(0:0.5:1, 0:0.01:1)
v = rand(rng, 101, 3)
xq, yq = meshgrid2(-0.2:0.002:1.2, -0.2:0.002:1.2)

res = interp2(x, y, v, xq, yq, "spline");

      大致的执行时间是：
      R2026a： 3.6713003 秒
      R2026a SP1： 0.0069109 秒

      此代码是运行在 Windows 11 的 8 核 Intel(R) Core(TM) i3-13100T @ 2.5 GHz 测试环境上利用 julia 的@elapsed、@belapsed 综合得出。

      使用 cubic 方法进行计算时性能得到了提升，示例如下：

      using TyMath
using TyBase
rng = MT19937ar(5489)
x, y = meshgrid2(0.05:0.05:100, 0.05:0.05:100);
z = cos.(x) .+ sin.(y);
a, b = meshgrid2(0.05:0.05:100, 0.05:0.05:100);
a = a .+ rand(rng, 2000, 2000)
b = b .+ rand(rng, 2000, 2000)

for i in 1:50
    c = interp2(x, y, z, a, b, "cubic")
end

      大致的执行时间是：
      R2026a： 3.8502835 秒
      R2026a SP1： 3.0081185 秒

      此代码是运行在 Windows 11 的 8 核 Intel(R) Core(TM) i3-13100T @ 2.5 GHz 测试环境上利用 julia 的 @elapsed、@belapsed 综合得出。

    • interp3：meshgrid 格式的三维网格数据的插值；

      使用 interp3 的 linear 方法进行计算时性能得到了提升，示例如下：

      using TyMath
using TyBase
X, Y, Z = meshgrid3(0:1:200, 0:1:200, 0:1:200);
V = @. sin(2 * pi * X) * cos(2 * pi * Y) * sin(2 * pi * Z);
XI, YI, ZI = meshgrid3(LinRange(0, 1, 300), LinRange(0, 1, 300), LinRange(0, 1, 300));

VI = interp3(X, Y, Z, V, XI, YI, ZI,"linear");

      大致的执行时间是：
      R2026a： 0.5768887 秒
      R2026a SP1： 0.3230075 秒

      此代码是运行在 Windows 11 的 8 核 Intel(R) Core(TM) i3-13100T @ 2.5 GHz 测试环境上利用 julia 的 @elapsed、@belapsed 综合得出。

      使用 interp3 的 nearest 方法进行计算时性能得到了提升，示例如下：

      using TyMath
using TyBase
X, Y, Z = meshgrid3(LinRange(0, 1, 100), LinRange(0, 1, 100), LinRange(0, 1, 100));
V = @. sin(2 * pi * X) * cos(2 * pi * Y) * sin(2 * pi * Z);
XI, YI, ZI = meshgrid3(LinRange(0, 1, 200), LinRange(0, 1, 200), LinRange(0, 1, 200));

VI = interp3(X, Y, Z, V, XI, YI, ZI, "makima", "makima");

      大致的执行时间是：
      R2026a： 8.5926581 秒
      R2026a SP1： 1.9896301 秒

      此代码是运行在 Windows 11 的 8 核 Intel(R) Core(TM) i3-13100T @ 2.5 GHz 测试环境上利用 julia 的@elapsed、@belapsed 综合得出。

    • griddata：对二维或三维散点数据插值；

      使用 griddata 的 natural 方法进行计算时性能得到了提升，示例如下：

      using TyMath
using TyBase
rng = MT19937ar(5489)
x = -3 .+ 6 * rand(rng, 500000);
y = -3 .+ 6 * rand(rng, 500000);
v = sin.(x) .^ 4 .* cos.(y);
xq = -3 .+ 6 * rand(rng, 5000000);
yq = -3 .+ 6 * rand(rng, 5000000);
near = "natural"

z1 = griddata(x, y, v, xq, yq, near);

      大致的执行时间是：
      R2026a： 1429.171243 秒
      R2026a SP1： 0.513472163 秒

      此代码是运行在 Windows 11 的 8 核 Intel(R) Core(TM) i3-13100T @ 2.5 GHz 测试环境上利用 julia 的@elapsed、@belapsed 综合得出。

      使用 griddata 的 linear 方法进行计算时性能得到了提升，示例如下：

      using TyMath
using TyBase
rng = MT19937ar(5489)
x = -3 .+ 6 * rand(rng, 5000);
y = -3 .+ 6 * rand(rng, 5000);
v = sin.(x) .^ 4 .* cos.(y);
xq, yq = meshgrid2(-3:0.01:3, -3:0.01:3);
near = "linear"

z1 = griddata(x, y, v, xq, yq, near);

      大致的执行时间是：
      R2026a： 1.2091777 秒
      R2026a SP1： 0.0254146 秒

      此代码是运行在 Windows 11 的 8 核 Intel(R) Core(TM) i3-13100T @ 2.5 GHz 测试环境上利用 julia 的@elapsed、@belapsed 综合得出。

      使用 griddata 的 cubic 方法进行计算时性能得到了提升，示例如下：

      using TyMath
using TyBase
rng = MT19937ar(5489)
x = -3 .+ 6 * rand(rng, 10000);
y = -3 .+ 6 * rand(rng, 10000);
v = sin.(x) .^ 4 .* cos.(y);
xq, yq = meshgrid2(-3:0.005:3, -3:0.005:3);
near = "cubic"

z1 = griddata(x, y, v, xq, yq, near);

      大致的执行时间是：
      R2026a： 12.0774219 秒
      R2026a SP1： 0.5664254 秒

      此代码是运行在 Windows 11 的 8 核 Intel(R) Core(TM) i3-13100T @ 2.5 GHz 测试环境上利用 julia 的@elapsed、@belapsed 综合得出。

    • numgrid：对二维区域中的网格点进行编号；

      使用 numgird 进行计算时性能得到了提升，示例如下：

      using TyMath
G = numgrid("A", 5000);

      大致的执行时间是：
      R2026a： 0.2799055 秒
      R2026a SP1： 0.1930405 秒

      此代码是运行在 Windows 11 的 8 核 Intel(R) Core(TM) i3-13100T @ 2.5 GHz 测试环境上利用 julia 的@elapsed、@belapsed 综合得出。

    • randn：标准正态分布随机数；

      使用 SWB2712 随机数种子生成正态分布随机数时性能得到了提升，示例如下：

      using TyMath
rng = SWB2712(100)
randn(rng, 1000000000);

      大致的执行时间是：
      R2026a： 91.216643 秒
      R2026a SP1： 17.7773596 秒

      此代码是运行在 Windows 11 的 8 核 Intel(R) Core(TM) i3-13100T @ 2.5 GHz 测试环境上利用 julia 的 @elapsed、@belapsed 综合得出。

    • rand：均匀分布随机数；

      使用 SWB2712 随机数种子生成均匀分布随机数时性能得到了提升，示例如下

      using TyMath
rng = SWB2712(100)
rand(rng, 1000000000);

      大致的执行时间是：
      R2026a： 42.2906865 秒
      R2026a SP1： 7.4443176 秒

      此代码是运行在 Windows 11 的 8 核 Intel(R) Core(TM) i3-13100T @ 2.5 GHz 测试环境上利用 julia 的 @elapsed、@belapsed 综合得出。

    • randg：Gamma 分布随机数；

      使用 SWB2712 随机数种子生成 Gamma 分布随机数时性能得到了提升，示例如下：

      using TyMath
rng = SWB2712(100)
randg(rng, 3, 100000000);

      大致的执行时间是：
      R2026a： 14.262869 秒
      R2026a SP1： 3.5358899 秒

      此代码是运行在 Windows 11 的 8 核 Intel(R) Core(TM) i3-13100T @ 2.5 GHz 测试环境上利用 julia 的 @elapsed、@belapsed 综合得出。

    • randi：均匀分布随机整数；

      使用 SWB2712 随机数种子生成均匀分布随机整数时性能得到了提升，示例如下：

      using TyMath
rng = SWB2712(100)
randi(rng, 5000, 1000000000);

      大致的执行时间是：
      R2026a： 41.8595443 秒
      R2026a SP1： 13.0192443 秒

      此代码是运行在 Windows 11 的 8 核 Intel(R) Core(TM) i3-13100T @ 2.5 GHz 测试环境上利用 julia 的 @elapsed、@belapsed 综合得出。

    • randperm：整数随机排列；

      使用 SWB2712 随机数种子生成整数随机排列时性能得到了提升，示例如下：

      using TyMath
rng = SWB2712(100)
randperm(rng, 50000000);

      大致的执行时间是：
      R2026a： 9.7619183 秒
      R2026a SP1： 8.1233741 秒

      此代码是运行在 Windows 11 的 8 核 Intel(R) Core(TM) i3-13100T @ 2.5 GHz 测试环境上利用 julia 的 @elapsed、@belapsed 综合得出。

    • randpermk：整数部分随机排列；

      使用 SWB2712 随机数种子生成整数部分随机排列时性能得到了提升，示例如下：

      using TyMath
rng = SWB2712(100)
randpermk(rng, 100000000, 50000000);

      大致的执行时间是：
      R2026a： 5.232679 秒
      R2026a SP1： 1.7924966 秒

      此代码是运行在 Windows 11 的 8 核 Intel(R) Core(TM) i3-13100T @ 2.5 GHz 测试环境上利用 julia 的 @elapsed、@belapsed 综合得出。

    • sprand：整数部分随机排列；

      使用 SWB2712 随机数种子生成随机稀疏矩阵时性能得到了提升，示例如下：

      using TyMath
rng = SWB2712(100)
sprand(rng, 10000, 10000, 0.5);

      大致的执行时间是：
      R2026a： 75.3914006 秒
      R2026a SP1： 70.4227105 秒

      此代码是运行在 Windows 11 的 8 核 Intel(R) Core(TM) i3-13100T @ 2.5 GHz 测试环境上利用 julia 的 @elapsed、@belapsed 综合得出。

    • sprandn：正态分布随机稀疏矩阵；

      使用 SWB2712 随机数种子生成正态分布随机稀疏矩阵时性能得到了提升，示例如下：

      using TyMath
rng = SWB2712(100)
sprandn(rng, 10000, 10000, 0.5);

      大致的执行时间是：
      R2026a： 77.852003 秒
      R2026a SP1： 70.9930811 秒

      此代码是运行在 Windows 11 的 8 核 Intel(R) Core(TM) i3-13100T @ 2.5 GHz 测试环境上利用 julia 的 @elapsed、@belapsed 综合得出。

    • mfft：傅里叶变换；

      使用 mfft 计算矩阵沿维度 1 计算傅里叶变换时性能得到了提升，示例如下：

      using TyMath
rng = MT19937ar(5489)
x = rand(rng, 15000, 15000);
y = mfft(x, 1);

      大致的执行时间是：
      R2026a： 1.472 秒
      R2026a SP1： 0.810545 秒

      此代码是运行在 Windows 11 的 8 核 Intel(R) Core(TM) i3-13100T @ 2.5 GHz 测试环境上利用 julia 的 @elapsed、@belapsed 综合得出。

    • nextpow2：2 的更高次幂的指数；

      使用 nextpow2 函数进行计算时性能得到了提升，示例如下：

      using TyMath
rng = MT19937ar(5489)
X = randi(rng, [-10000, 10000], 5000, 5000)

for i in 1:10
    Y = nextpow2(X)
end

      大致的执行时间是：
      R2026a： 23.9594227 秒
      R2026a SP1： 0.2708339 秒

      此代码是运行在 Windows 11 的 8 核 Intel(R) Core(TM) i3-13100T @ 2.5 GHz 测试环境上利用 julia 的@elapsed、@belapsed 综合得出。

    • pow2：浮点数的以 2 为底的幂运算和缩放；

      使用 pow2 函数进行计算时性能得到了提升，示例如下：

      using TyMath
rng = MT19937ar(5489)
X = rand(rng, 5000, 5000)
Y = 1024

for i in 1:30
    P = pow2(X, Y)
end

      大致的执行时间是：
      R2026a： 8.0135799 秒
      R2026a SP1： 1.2215162 秒

      此代码是运行在 Windows 11 的 8 核 Intel(R) Core(TM) i3-13100T @ 2.5 GHz 测试环境上利用 julia 的@elapsed、@belapsed 综合得出。

    • trapz：梯形数值积分；

      使用 trapz 函数进行计算时性能得到了提升，示例如下：

      using TyMath
rng = MT19937ar(5489)
X = randn(rng, 5000)
Y = randn(rng, 5000, 5000)

for i in 1:20
    Q = trapz(X, Y)
end

      大致的执行时间是：
      R2026a： 1.077406 秒
      R2026a SP1： 0.1010266 秒

      此代码是运行在 Windows 11 的 8 核 Intel(R) Core(TM) i3-13100T @ 2.5 GHz 测试环境上利用 julia 的@elapsed、@belapsed 综合得出。

    • unwrap：平移相位角；

      使用 unwrap 进行计算时性能得到了提升，示例如下：

      using TyMath
rng = MT19937ar(5489)
X = randn(rng, 5000, 5000)
tol = 10

for i in 1:5
    Y = unwrap(X, tol)
end

      大致的执行时间是：
      R2026a： 1.4731233 秒
      R2026a SP1： 0.6290666 秒

      此代码是运行在 Windows 11 的 8 核 Intel(R) Core(TM) i3-13100T @ 2.5 GHz 测试环境上利用 julia 的@elapsed、@belapsed 综合得出。

    • polyfit：对误差函数进行多项式拟合；

      使用 polyfit 对误差函数进行多项式拟合时性能得到了提升，示例如下：

      using TyMath
x = collect(0:0.0001:2.5)
y = erf.(x)
m = 6

for i in 1:1000
    p, S = polyfit(x, y, m)
end

      大致的执行时间是：
      R2026a： 2.1028079 秒
      R2026a SP1： 0.9541475 秒

      此代码是运行在 Windows 11 的 8 核 Intel(R) Core(TM) i3-13100T @ 2.5 GHz 测试环境上利用 julia 的@elapsed、@belapsed 综合得出。

    • ode15s：将 Robertson 问题作为半显式微分代数方程(DAE)求解；

      使用 ode15s 计算时性能得到了提升，示例如下：

      using TyMath
function robertsdae(t, y)
    return [
        -0.04 * y[1] + 1e4 * y[2] .* y[3]
        0.04 * y[1] - 1e4 * y[2] .* y[3] - 3e7 * y[2] .^ 2
        y[1] + y[2] + y[3] - 1
    ]
end
y0 = [1; 0; 0]
tspan = [0; 4 * (10 .^ LinRange(-6, 6, 500000))]
M = [1 0 0; 0 1 0; 0 0 0]
options = odeset(; mass=M, reltol=1e-4, abstol=[1e-6; 1e-10; 1e-6])

t, y, = ode15s(robertsdae, tspan, y0, options);

      大致的执行时间是：
      R2026a： 0.647622 秒
      R2026a SP1： 0.1988011 秒

      此代码是运行在 Windows 11 的 8 核 Intel(R) Core(TM) i3-13100T @ 2.5 GHz 测试环境上利用 julia 的@elapsed、@belapsed 综合得出。

    • polyval：多项式计算。

      使用 polyval 计算时性能得到了提升，示例如下：

      using TyMath
rng = MT19937ar(5489)
x = 1:0.1:1001
y = randn(rng, 10001)
p, S, mu = polyfit(x, y, 1; normalize=true)
# mtest-setup end
for i in 1:10000
    y_fit, delta = polyval(p, x, S, mu)
end

      大致的执行时间是：
      R2026a： 2.5158498 秒
      R2026a SP1： 0.7530429 秒

      此代码是运行在 Windows 11 的 8 核 Intel(R) Core(TM) i3-13100T @ 2.5 GHz 测试环境上利用 julia 的@elapsed、@belapsed 综合得出。

  • 优化工具箱

    quadprog：仅含线性等式约束的二次规划。

    使用 trust-region-reflective 算法进行求解时性能得到了提升，示例如下：

    using TyMath
using TyOptimization
n = 300
H2 = speye(n)
H =
    3 * circshift(H2, (0, -3)) +
    6 * circshift(H2, (0, -2)) +
    2 * circshift(H2, (0, -1)) +
    14 * H2 +
    2 * circshift(H2, (0, 1)) +
    6 * circshift(H2, (0, 2)) +
    3 * circshift(H2, (0, 3))
Aeq = ones(1, n)
beq = [0]
f = -(1:n)
opts = optimoptions(:quadprog; Algorithm="trust-region-reflective",Display="off")

for i in 1:500
    x, fval, exitflag, output, lambda = quadprog(H, f, [], [], Aeq, beq, [], [], [], opts)
end

    大致的执行时间是：
    R2026a： 20.3607862 秒
    R2026a SP1： 0.858383 秒

    此代码是运行在 Windows 11 的 8 核 Intel(R) Core(TM) i3-13100T @ 2.5 GHz 测试环境上利用 julia 的@elapsed、@belapsed 综合得出。

  • 统计工具箱

    • cdf：计算 Stable 分布的 cdf；

      使用 Stable 分布计算 cdf 时性能得到了提升，示例如下：

      using TyMath
using TyStatistics
rng = MT19937ar(5489)
gm = makedist("Stable")
x = rand(rng, 1000000)

for _ in 1:50
    y = cdf(gm, x)
end

      大致的执行时间是：
      R2026a： 31.5026422 秒
      R2026a SP1： 3.0565026 秒

      此代码是运行在 Windows 11 的 8 核 Intel(R) Core(TM) i3-13100T @ 2.5 GHz 测试环境上利用 julia 的@elapsed、@belapsed 综合得出。

    • cdf：计算 Rician 分布的 cdf；

      使用 Rician 分布计算 cdf 时性能得到了提升，示例如下：

      using TyMath
using TyStatistics
rng = MT19937ar(5489)
gm = makedist("Rician"; ν=1.0, σ=1.0)
x = rand(rng, 100000)

for _ in 1:10
    y = cdf(gm, x)
end

      大致的执行时间是：
      R2026a： 4.0073521 秒
      R2026a SP1： 0.4833418 秒

      此代码是运行在 Windows 11 的 8 核 Intel(R) Core(TM) i3-13100T @ 2.5 GHz 测试环境上利用 julia 的@elapsed、@belapsed 综合得出。

    • normcdf：计算向量的 normcdf；

      使用 normcdf 计算向量时性能得到了提升，示例如下：

      using TyMath
using TyStatistics
rng = MT19937ar(5489)
x = rand(rng, 100000);
mu = 2;
sigma = 1;

for i in 1:100
    p = normcdf(x, mu, sigma)
end

      大致的执行时间是：
      R2026a： 0.161162 秒
      R2026a SP1： 0.0617023 秒

      此代码是运行在 Windows 11 的 8 核 Intel(R) Core(TM) i3-13100T @ 2.5 GHz 测试环境上利用 julia 的@elapsed、@belapsed 综合得出。

    • normrnd：生成 5000*5000 的随机数；

      使用 normrnd 生成 5000*5000 的随机数时性能得到了提升，示例如下：

      using TyMath
using TyStatistics
rng = MT19937ar(5489)

for i in 1:10
    r = normrnd(rng, 3, 10, 5000, 5000)
end

      大致的执行时间是：
      R2026a： 2.7193027 秒
      R2026a SP1： 1.8063446 秒

      此代码是运行在 Windows 11 的 8 核 Intel(R) Core(TM) i3-13100T @ 2.5 GHz 测试环境上利用 julia 的@elapsed、@belapsed 综合得出。

    • ty_maximum：沿行计算 1000000*2 矩阵的最大值；

      使用 ty_maximum 沿行计算 1000000*2 矩阵的最大值时性能得到了提升，示例如下：

      using TyMath
using TyStatistics
rng = MT19937ar(5489)
A = rand(rng, 1000000, 2)
num = 2


for i in 1:500
    M, I = ty_maximum(A, 2)
end

      大致的执行时间是：
      R2026a： 266.8176714 秒
      R2026a SP1： 5.88856 秒

      此代码是运行在 Windows 11 的 8 核 Intel(R) Core(TM) i3-13100T @ 2.5 GHz 测试环境上利用 julia 的@elapsed、@belapsed 综合得出。

    • ty_minimum：沿行计算 1000000*2 矩阵的最小值；

      使用 ty_minimum 沿行计算 1000000*2 矩阵的最小值时性能得到了提升，示例如下：

      using TyMath
using TyStatistics
rng = MT19937ar(5489)
A = rand(rng, 1000000, 2)
num = 2


for i in 1:500
    M, I = ty_minimum(A, 2)
end

      大致的执行时间是：
      R2026a： 267.6874818 秒
      R2026a SP1： 6.059718 秒

      此代码是运行在 Windows 11 的 8 核 Intel(R) Core(TM) i3-13100T @ 2.5 GHz 测试环境上利用 julia 的@elapsed、@belapsed 综合得出。

    • negloglik：计算 Nakagami 分布的负对数似然。

      使用 negloglik 计算 Nakagami 分布的负对数似然时性能得到了提升，示例如下：

      using TyMath
using TyStatistics
rng = MT19937ar(5489)
a = rand(rng, 200000)
pd = fitdist(a, "Nakagami")

for i in 1:100
    negloglik(pd)
end

      大致的执行时间是：
      R2026a： 1.7076876 秒
      R2026a SP1： 2.72E-06 秒

      此代码是运行在 Windows 11 的 8 核 Intel(R) Core(TM) i3-13100T @ 2.5 GHz 测试环境上利用 julia 的@elapsed、@belapsed 综合得出。

  • 信号处理工具箱

    • grpdelay：二阶节形式滤波器的群延迟计算；

      直接使用二阶节的每一节系数计算，内部运算完全标量化。

      using TySignalProcessing
z, p, k = butter(6, 0.2, "lowpass"; otype="zpk")
sos = zp2sos(z, p, k; g_flag=false)
gd, = grpdelay(sos, 1000000)

      大致的执行时间是：
      R2026a： 2.26E-01 秒
      R2026a SP1： 8.77E-02 秒

    • findpeaks：对矩阵进行寻峰；

      峰值判断使用更高效的分桶算法。

      using TySignalProcessing
using TyMath

rng = MT19937ar(1234)
data = randi(rng, 100, 1000000)
pks1, loc1 = findpeaks(data, MinPeakDistance=10)

      大致的执行时间是：
      R2026a： 2.56E+01 秒
      R2026a SP1： 5.61E-02 秒

    • downsample：信号下采样；

      优化内存分配及取子数组方式。

      using TySignalProcessing
using TyMath

rng = MT19937ar(1234)
x = randn(rng, 1, 10000, 100, 10)
y = downsample(x, 13)

      大致的执行时间是：
      R2026a： 1.78E-02 秒
      R2026a SP1： 3.40E-03 秒

    • fir1：生成基于窗口的 fir 滤波器；

      优化了最小线性二乘的 fir 生成算法。

      using TySignalProcessing
using TyMath

N = 1000
win = chebwin(N + 1, 30)
w = (1:1:Int(1e5-1)) / 100000
num = fir1(N, w, "lowpass", win)

      大致的执行时间是：
      R2026a： 2.11E+00 秒
      R2026a SP1： 9.20E-01 秒

    • sawtooth：生成锯齿波；

      使用了多线程并优化了算法中的计算逻辑。

      using TySignalProcessing
using TyMath

N = 1000
win = chebwin(N + 1, 30)
w = (1:1:Int(1e5-1)) / 100000
num = fir1(N, w, "lowpass", win)

      大致的执行时间是：
      R2026a： 1.74E-01 秒
      R2026a SP1： 2.54E-02 秒

    • bilinear：模数滤波器转换的双线性变换方法；

      优化了单位阵的计算，及内存分配。

      using TySignalProcessing

z, p, k = buttap(500)
A, B, C, D = zp2ss(z, p, k)
Fs = 2e3
u1 = 2 * Fs * tan(100 * (2 * pi / Fs) / 2)
u2 = 2 * Fs * tan(500 * (2 * pi / Fs) / 2)
Bw = u2 - u1
Wo = sqrt(u1 * u2)
At, Bt, Ct, Dt = lp2bp(A, B, C, D, Wo, Bw)

Ad, Bd, Cd, Dd = bilinear(At, Bt, Ct, Dt, Fs)

      大致的执行时间是：
      R2026a： 7.259E-02 秒
      R2026a SP1： 5.320E-02 秒

    • freqz：iir 滤波器的频响；

      优化了内部 fft 运算，复用 fft plan。

      using TySignalProcessing

b, a = butter(500, 0.5)
h, = freqz(b, a, Int(1e6))

      大致的执行时间是：
      **R2026a:**1.23E-01 秒
      R2026a SP1： 6.38E-02 秒

    • butter：设计巴特沃斯滤波器；

      优化了内存分配及单位阵的计算。

      using TySignalProcessing

butter(500,0.5,otype="ABCD")

      大致的执行时间是：
      **R2026a:**2.53E-02 秒
      R2026a SP1： 1.95E-02 秒

    • maxflat：设计广义数字巴特沃斯滤波器；

      重新实现了组合数的计算。

      using TySignalProcessing
n = 8
m = 2
Wn = 0.1
b, a, = maxflat(n, m,Wn)

      大致的执行时间是：
      R2026a： 1.33E-04 秒
      R2026a SP1： 9.37E-05 秒

    • finddelay：计算两个信号间的延迟；

      重新实现信号互相关算法，优化内存，生成可以复用的 fft plan。

      using TySignalProcessing
n = 8
m = 2
Wn = 0.1
b, a, = maxflat(n, m,Wn)

      大致的执行时间是：
      R2026a： 2.18E+00 秒
      R2026a SP1： 3.45E-01 秒

    • ty_pwelch：使用 welch 方法计算功率谱密度；

      减少函数中的拷贝，复用 fft plan。

      using TySignalProcessing
using TyMath

fs = 1e9
T = 1 / fs
t = 0:T:(1e-2-T)
y = chirp(t, 0, 1e-2, 1e6)
win = hamming(100000)
nfft = 2^nextpow2(length(win))
psd, = ty_pwelch(y,win,50,nfft,fs)

      大致的执行时间是：
      R2026a： 2.53E-01 秒
      R2026a SP1： 9.17E-02 秒

    • czt：信号的线性调频 Z 变换；

      优化循环运算中的内存分配。

      using TySignalProcessing
using TyMath

rng = MT19937ar(5489)
x = randn(rng, 10130, 20)
y = czt(x)

      大致的执行时间是：
      R2026a： 2.53E-01 秒
      R2026a SP1： 9.17E-02 秒

    • hilbert：信号的希尔伯特变换；

      缓存了最近一次的 fft plan，在多次调用的情况下提升显著。

      using TySignalProcessing
using TyMath

rng = MT19937ar(1234)
x = randn(rng,10000000)
y = hilbert(x)

      大致的执行时间是：
      R2026a： 1.21E+00 秒
      R2026a SP1： 1.37E-01 秒

    • square：生成方波信号；

      启用多线程，优化了代码逻辑。

      using TySignalProcessing
t = LinRange(0, 3 * pi, 10000000)
x = square(t, 70)

      大致的执行时间是：
      R2026a： 7.78E-02 秒
      R2026a SP1： 2.44E-02 秒

    • freqs：模拟滤波器频响；

      优化内部多项式求值。

      using TySignalProcessing
b,a = butter(500,0.5,"s")
h,w = freqs(b, a, 1000000)

      大致的执行时间是：
      R2026a： 11.02 秒
      R2026a SP1： 2.52 秒

    • upsample：信号上采样；

      优化了赋值操作。

      using TySignalProcessing
using TyMath
rng = MT19937ar(1234)
x =randn(rng,1000000)
y = upsample(x,10)

      大致的执行时间是：
      R2026a： 2.24E-02 秒
      R2026a SP1： 2.21E-02 秒

    • invfreqz：从频响求解滤波器传递函数；

      优化了实数的矩阵共轭乘法。

      using TySignalProcessing
using TyMath
rng = MT19937ar(1234)
a = rand(rng, 5377) + im * rand(rng, 5377)
b = rand(rng, 5377, 3)
a1 = @view a[1:5375]
b1 = (@view b[1:5375]) * 1e9 / (1.0752e12 / 2) * pi
invfreqz(a1, b1, 4000, 0)

      大致的执行时间是：
      R2026a： 2.88E+00 秒
      R2026a SP1： 1.92E+00 秒

    • pspectrum：瞬态信号的持久谱；

      优化了内部数据存储构造以及 fft 运算。

      using TySignalProcessing
fs = 1000
t = 0:(1/fs):500
rng = MT19937ar(1234)
x = chirp(t, 180, t[end], 220) .+ 0.15 .* randn(rng, size(t))
idx = floor(Int, length(x) / 6)
x[1:idx] = x[1:idx] .+ 0.05 .* cos.(2 * pi .* t[1:idx] .* 210)
a = [100 290]
b = 1
p1, = pspectrum(x, fs, "spectrogram"; FrequencyLimits=a, TimeResolution=b)

      大致的执行时间是：
      R2026a : 63.99 秒
      R2026a SP1: 6.44 秒

    • pulstran：周期性高斯脉冲；

      优化了函数派发调用。

      using TySignalProcessing
using TyPlot
fs = 1e7;
tc, = gauspuls("cutoff", 10e3, 0.5, [], -40);
t = (-tc):(1/fs):tc;
x, = gauspuls(t, 10e3, 0.5);

plot(t, x)
xlabel("Time (s)")
ylabel("Waveform")

ts = 0:(1/50e3):0.025;
d = [0:(1/1e3):0.025 sin.(2 * pi * 0.1 * (0:25))];
y = pulstran(ts, d, x, fs);

      大致的执行时间是：
      R2026a : 4.39E-01 秒
      R2026a SP1: 4.99E-04 秒

    • vmd：拨号音信号的变分模态分解。

      优化了函数内部迭代的内存分配。

      using TySignalProcessing

fs = 4e3
t = 0:(1/fs):(0.5-1/fs)
ver = [697 770 852 941]
hor = [1209 1336 1477]
tones = Float64[]
for k in eachindex(ver)
    for l in eachindex(hor)
        tone = sum(sin.(2 .* pi .* t * [ver[k] hor[l]]); dims=2)
        global tones = [tones; tone; zeros(size(tone))]
    end
end

p, = vmd(tones)

      大致的执行时间是：
      R2026a : 7.92 秒
      R2026a SP1: 1.32 秒

      此代码是运行在 Windows 11 的 14 核 Intel(R) Core(TM) i7-12800H 的客户端版本 Syslab，使用 Julia @benchmark 宏进行进行计时

  • 通信工具箱

    • bi2de：二进制数转换为十进制数；

      优化了内部迭代与逻辑判断。

      using TySignalProcessing
using TyMath
rng = MT19937ar(1234)
b1 = randi(rng, [0, 1], 100000, 52)
d1 = bi2de(b1, 52)

      大致的执行时间是：
      R2026a： 6.42E-02 秒
      R2026a SP1： 3.90E-03 秒

    • de2bi：十进制数转换为二进制数；

      优化了内部迭代与逻辑判断。

      using TySignalProcessing
using TyMath
d = 1:10000
b = de2bi(d)

      大致的执行时间是：
      R2026a： 9.74E-04 秒
      R2026a SP1： 4.39E-04 秒

    • awgn：为信号增加高斯白噪声；

      优化了内部计算内存分配，修改了复数随机数生成方式。

      using TySignalProcessing
using TyMath
rng = MT19937ar(1234)
c = [-5 -5im 5 5im -3 -3-3im -3im 3-3im 3 3+3im 3im -3+3im -1 -1im 1 1im]
sigpower = 11.222158782728267
M = length(c)
data = randi(rng, [0 M-1], 2000, 1)
modData = genqammod(data, c)
rxSig = awgn(rng, modData, 20, sigpower)

      大致的执行时间是：
      R2026a： 5.44E-05 秒
      R2026a SP1： 3.82E-05 秒

  • 控制系统工具箱

    • initial：针对 initial 进行了性能优化；

      using Random
using LinearAlgebra
using BenchmarkTools
using TyControlSystems

nx, ny, nu = 50, 10, 15
Nt = 5000
tfinal = 10.0

Random.seed!(1234)
A = randn(nx, nx)
@inbounds for i in 1:nx
    A[i, i] -= 2.0
end
B = randn(nx, nu)
C = randn(ny, nx)
D = zeros(ny, nu)

sys = ss(A, B, C, D)
x0 = randn(nx)
t = collect(range(0.0, tfinal; length=Nt))

initial(sys, x0, t; fig=false)  # warmup

print("@time:  ")
@time initial(sys, x0, t; fig=false)

print("@btime: ")
@btime initial($sys, $x0, $t; fig=false) samples=3 evals=1

      大致的执行时间是：
      R2026a： 0.05604 秒
      R2026a SP1： 0.01194 秒

    • isreal：针对 isreal 进行了性能优化；

      using BenchmarkTools
using Random
using TyControlSystems
using LinearAlgebra

nx = 80
N = 1000

A = randn(nx, nx)
@inbounds for i in 1:nx
    A[i, i] -= 2.0
end
B = randn(nx, 2)
C = randn(2, nx)
D = zeros(2, 2)

ss_r = ss(A, B, C, D)
Ac = complex.(A) .+ 1e-3im .* randn(nx, nx)
ss_c = ss(Ac, complex.(B), complex.(C), complex.(D))

tf_r = tf([1.0], [1.0, 2.0, 1.0])
tf_c = tf(ComplexF64[1.0 + 0.1im], ComplexF64[1.0, 2.0, 1.0])

rng = MersenneTwister(42 + 10nx + N)
pool = Vector{Any}(undef, N)

@inbounds for i in 1:N
    use_ss = rand(rng) < 0.5
    use_c = rand(rng) < 0.3
    if use_ss
        pool[i] = use_c ? ss_c : ss_r
    else
        pool[i] = use_c ? tf_c : tf_r
    end
end

begin
    count = 0
    @inbounds for sys in pool
        if isreal(sys)
            count += 1
        end
    end
    count
end

print("@time:  ")
@time begin
    count = 0
    @inbounds for sys in pool
        if isreal(sys)
            count += 1
        end
    end
    count
end

print("@btime: ")
@btime begin
    count = 0
    @inbounds for sys in $pool
        if isreal(sys)
            count += 1
        end
    end
    count
end

      大致的执行时间是：
      R2026a： 0.011577 秒
      R2026a SP1： 0.011356 秒

    • norm：针对 norm 进行了性能优化；

      using TyControlSystemsCore
using LinearAlgebra
using BenchmarkTools
using Printf
using Random

const TOL = 1e-6

Random.seed!(42)

Ts = 0.001
n = 50
n_modes = n ÷ 2
A = zeros(n, n)
@inbounds for k = 1:n_modes
    r = 0.95 + 0.04 * rand()
    θ = 2π * rand()
    a = r * cos(θ)
    b = r * sin(θ)
    i = 2k - 1
    A[i:i+1, i:i+1] = [a -b; b a]
end
@inbounds for _ in 1:div(n, 5)
    i, j = rand(1:n, 2)
    A[i, j] += 0.02 * randn()
end
B = randn(n, 4) * 0.3
C = randn(5, n) * 0.3
D = zeros(5, 4)

sys = ss(A, B, C, D, Ts)

@printf("nx=%d, nu=%d, ny=%d, 类型=%s\n",
    sys.nx, sys.nu, sys.ny, iscontinuous(sys) ? "连续" : "离散")

norm(sys, Inf; tol=TOL)  # warmup

print("@time:  ")
@time norm(sys, Inf; tol=TOL)

print("@btime: ")
@btime norm($sys, Inf; tol=$TOL) samples=300 evals=1

      大致的执行时间是：
      R2026a： 0.01381 秒
      R2026a SP1： 0.009578 秒

    • step：针对 step 进行了性能优化。

      using TyControlSystems
using LinearAlgebra
using BenchmarkTools
using Printf
using Random

Random.seed!(42)

nx, nu, ny = 80, 10, 10
Q = randn(nx, nx)
A = -(Q * Q' + I)
B = randn(nx, nu)
C = randn(ny, nx)
D = 0.1 .* randn(ny, nu)

sys = ss(A, B, C, D)
t = collect(range(0.0, 5.0, length=5000))

@printf("nx=%d, nu=%d, ny=%d, 类型=%s\n",
    sys.nx, sys.nu, sys.ny, iscontinuous(sys) ? "连续" : "离散")

step(sys, t; fig=false)  # warmup

print("@time:  ")
@time step(sys, t; fig=false)

print("@btime: ")
@btime step($sys, $t; fig=false) samples=30 evals=1

      大致的执行时间是：
      R2026a： 0.011543 秒
      R2026a SP1： 0.002507 秒

      此代码是运行在 Windows 11 的 16 核 Intel(R) Core(TM) Ultra 9 185H @ 2.30 GHz 的客户端版本 Syslab，使用 Julia 的 @btime、@time 宏进行计时。

  • 鲁棒控制工具箱

    • diag：针对 diag 进行了性能优化。

      using BenchmarkTools
using Random
using TyRobustControl

N = 100_000
n = 8
rng = MersenneTwister(42)

mats = [umat(randn(rng, n, n)) for _ in 1:N]
ks = rand(rng, -(n - 1):(n - 1), N)

@time begin
    acc = 0
    @inbounds for i in eachindex(mats)
        acc += length(TyRobustControl.diag(mats[i], ks[i]))
    end
    acc
end

@btime begin
    acc = 0
    @inbounds for i in eachindex($mats)
        acc += length(TyRobustControl.diag($mats[i], $ks[i]))
    end
    acc
end

      大致的执行时间是：
      R2026a： 5.413 秒
      R2026a SP1： 2.198 秒

  • 图像处理工具箱

    • imdilate：对图像进行膨胀操作；

      重构了算法实现，基于 julia 算法重新实现，移除 OpenCV 依赖。

      using TyImageProcessing, TyRandom, Test
using BenchmarkTools
rng = MT19937ar(2026)
A = rand(rng, 500, 2000)
BW = A .> 0.7
nd_ = trues(3, 3)
imdilate(BW, nd_);

      大致的执行时间是：
      R2026a： 4.32E-03 秒
      R2026a SP1： 3.02E-03 秒

    • copy：点云数据对象深度复制；

      优化了 julia 实现，避免数据多次复制。

      using TyImageProcessing
using BenchmarkTools

xyzPoints = rand(Float32, 333334, 3)
color = rand(Float32,333334,3)
ptCloudIn = pointCloud(xyzPoints, Color=color);
copy(ptCloudIn);

      大致的执行时间是：
      R2026a： 9.56E-04 秒
      R2026a SP1： 7.2E-5 秒

    • bwdist：二值图像的距离变换；

      重构了算法实现，降低算法复杂度。

      using TyImageProcessing, TyRandom
using BenchmarkTools
rng = MT19937ar(5489)
A = rand(rng, 50, 50)
BW = A .> 0.5
bwdist(BW);

      大致的执行时间是：
      R2026a： 6.39E-02 秒
      R2026a SP1： 4.97E-5 秒

      此代码是运行在 Windows 11 的 14 核 Intel(R) Core(TM) i7-12800H 的客户端版本 Syslab，使用 Julia @btime 宏进行计时。

# 删除或变更功能 ⚠️

# Julia 内核

Julia 内核改进引入破坏性更新 1 个。

Julia 内核升级至 1.10 版本后，QR 分解的返回值字段 Q 不再属于 AbstractMatrix 的子类型。在以下两个场景中会发生错误；

  • 问题现象 1：

    using LinearAlgebra;
A = randn(6, 3);
Q = qr(A).Q;
W = reverse(Q, dims=2); # Q 无法直接 reverse
W2 = reverse(Matrix(Q), dims=2);

    问题原因：

    Q 不再是 AbstractMatrix 的子类型，无法使用 AbstractMatrix 的通用方法。

    解决方案：

    using LinearAlgebra;
A = randn(6, 3);
Q = qr(A).Q;
W = reverse(Q*I, dims=2);  # 得到预期满分解Q值
W2 = reverse(Matrix(Q), dims=2); # 得到econ分解的结果值

  • 问题现象 2：

    using LinearAlgebra;
temp = [0.224334+0.521272im  -0.424236-0.472774im;
-0.432631-0.452408im   0.325689-0.884612im];
Q = zeros(ComplexF64,2,2);
Q[:], = qr(temp, Val(false)); # 无法运行

    问题原因：

    Q 不再是 AbstractMatrix 的子类型，无法通过索引复制到数组内。

    解决方案：

    using LinearAlgebra;
temp = [0.224334+0.521272im  -0.424236-0.472774im;
-0.432631-0.452408im   0.325689-0.884612im];
Q = zeros(ComplexF64,2,2);
temp_q, = qr(temp, Val(false));
Q .= temp_q;

# 图形工具箱

图形工具箱引入破坏性更新 2 个。

  1. findobj：优化调整了返回值对象的顺序，返回值对象顺序遵循两个规则:一是后创建对象的排在先创建的对象前面；二是输入多个句柄时，优先返回下层句柄对应的结果，再返回上层句柄对应的结果，如坐标轴中获取的对象排在图窗中获取的对象前面。例如：

    using TyPlot
fig = figure()

ax1 = subplot(2,1,1)
plot(1:10, DisplayName="a1")
hold("on")
plot(rand(10), DisplayName="a2")

ax2 = subplot(2,1,2)
plot(1:10, DisplayName="b1")
hold("on")
plot(rand(10), DisplayName="b2")

    R2026a 及之前版本运行结果：

    h1 = findobj(fig, "Type", "line")
for l in h1
  println(plt_get(l, "displayname"))
end
#=
b1
b2
a1
a2
=#

h2 = findobj([ax1, gcf(), ax2], "Type", "line")
for l in h2
  println(plt_get(l, "displayname"))
end
#=
a1
a2
b1
b2
a1
a2
b1
b2
=#

    R2026a SP1 运行结果：

    h1 = findobj(fig, "Type", "line")
for l in h1
  println(plt_get(l, "displayname"))
end
#=
b2
b1
a2
a1
=#

h2 = findobj([ax1, gcf(), ax2], "Type", "line")
for l in h2
  println(plt_get(l, "displayname"))
end
#=
a2
a1
b2
b1
b2
b1
a2
a1
=#

  2. n,edges,bin = histcounts(___;nargout = 3) 用法的 bin 返回值类型由 Float 改为 Int 类型。例如：

    using TyPlot
X = [2 3 5 7 11 13 17 19 23 29];
n, edges, bin = histcounts(X, 6; nargout=3);
eltype(bin)

    R2026a 及之前版本运行结果：

    Float64

    R2026a SP1 版本运行结果：

    Int64

# 符号数学工具箱

符号数学工具箱引入破坏性更新 1 个。

taylor 函数：更改输出结果类型至 Num 类型。

using TySymbolicMath
@variables x
T1 = taylor(exp(x))

输出结果如下：

Warning: 此函数即将废弃，请使用 taylor_series 函数进行求解。
T1 = (1 + x + (1//2)*(x^2) + (1//6)*(x^3) + (1//24)*(x^4) + (1//120)*(x^5), x, 6×2 DataFrame
 Row │ coeffs  order 
     │ Num     Int64
─────┼───────────────
   1 │      1      0
   2 │      1      1
   3 │   1//2      2
   4 │   1//6      3
   5 │  1//24      4
   6 │ 1//120      5)

其中第一个输出与第二个输出类型发生更改，从原有的 TaylorN{Float64} 类型变更至 Num 类型，便于参与后续符号计算。

# 附录：函数列表

# 基础工具箱

基础工具箱新增函数 1 个。

函数名 函数说明
save_profile 保存 @profile 性能采样结果为 .syslabprof 文件

基础工具箱修改函数 28 个。

函数名 函数变更说明
xlsread 对于可转数值的字符串仍然保持字符串类型输出，仅过滤前后空格
fscanf 1. 修复在输入含有 i、n、f、a 的 1 或 2 个字符时使用 %f 报错的问题；2. 修复输入使用 %f 解析 Inf 时，应只匹配 inf 而不是 infinity；3. 修复在使用 %i 解析负数时，没能返回负数的问题；4. 在指定空数组时返回类型与输入数据的类型规则匹配
load 增加对.mat 文件读取时的变量名过滤
fprintf 性能优化
importdata 性能优化
fwrite 性能优化
fread 性能优化
find 性能优化
regexp 性能优化
ismember 性能优化
compose 性能优化
sscanf 性能优化
fullfile 性能优化
textscan 性能优化
clear 性能优化
regexprep 性能优化
dir 性能优化
logspace 性能优化
bitshift 性能优化
ty_sort 性能优化
ind2sub 性能优化
mode 性能优化
num2array 性能优化
datevec 性能优化
dec2base 性能优化
sortrows 性能优化
what 性能优化
ndgrid 性能优化

# 图形工具箱

图形工具箱新增函数 1 个。

函数名 函数说明
combine_figures 将多个图窗中的坐标轴合并到一个新图窗中

图形工具箱修改函数 28 个。

函数名 函数变更说明
area 性能优化
scatter3 性能优化
bar 性能优化
errorbar bug 修复
stem 性能优化
colormap 性能优化
findobj 性能优化，调整了返回值对象的顺序
yline 性能优化
datestr 性能优化
histogram 性能优化
line 性能优化
text 性能优化
loglog 性能优化
xticks 性能优化
yticks 性能优化
axis 性能优化
hist 性能优化
tightlayout 性能优化
plot3 性能优化
addpoint 函数重构
contour 性能优化
contourf 性能优化
surf 性能优化
contourc 性能优化
pie 支持 pie 函数输入 colors 关键词参数
tickangle 自动调整页面布局
patch 修复 patch 函数设置 facealpha 关键词参数无效的问题
histcounts 修改返回值类型

# 数学工具箱

数学工具箱新增函数 4 个。

函数名 函数说明
delaunayTriangulation 二维和三维德劳内三角剖分
triangulation 二维或三维三角剖分
triplot 二维三角图
nearestNeighbor 最靠近指定点的顶点

数学工具箱修改函数 38 个。

函数名 函数变更说明
heaviside 函数 bug 修复
lsqnonneg 函数 bug 修复
nextpow2 性能优化
pow2 性能优化
trapz 性能优化
unwarp 性能优化
polyfit 性能优化
polyval 性能优化
interp2 性能优化
numgrid 性能优化
interp1 性能优化
interp3 性能优化
griddata 性能优化
scatteredInterpolant1 性能优化
randn 性能优化
rand 性能优化
randg 性能优化
randi 性能优化
randperm 性能优化
randpermk 性能优化
sprand 性能优化
filter1 函数 bug 修复
mfft 性能优化
ode15s 性能优化
vroronoi 函数 bug 修复
ode23 函数 bug 修复
ode45 函数 bug 修复
ode78 函数 bug 修复
ode89 函数 bug 修复
ode113 函数 bug 修复
ode23t 函数 bug 修复
ode23s 函数 bug 修复
ode23tb 函数 bug 修复
ode15i 函数 bug 修复
bvp4c 函数 bug 修复
bvp5c 函数 bug 修复
bvpinit 函数 bug 修复
bvpxtend 函数 bug 修复

# 符号数学工具箱

符号数学工具箱修改函数 1 个。

函数名 函数变更说明
taylor 函数 函数破坏性更改：更改输出类型

# 曲线拟合工具箱

曲线拟合工具箱修改函数 1 个。

函数名 函数变更说明
fittype 函数 bug 修复

# 统计工具箱

统计工具箱新增函数 4 个。

函数名 函数说明
grp2dix 从分组变量创建索引向量
eccdf 经验互补累积分布函数
probplot 概率图
ecdfhist 基于经验累积分布函数的直方图

统计工具箱修改函数 14 个。

函数名 函数变更说明
ty_minimum 性能优化
chi2gof 函数 bug 修复
ty_maximum 性能优化
negloglik 函数 bug 修复
normcdf 性能优化
normrnd 性能优化
icdf 函数功能新增
iqr 函数功能新增
quantile 函数功能新增
cdf 性能优化
fitdist 函数 bug 修复
prctile 函数 bug 修复
gamcdf 函数 bug 修复
gaminv 函数 bug 修复

# 优化工具箱

优化工具箱修改函数 4 个。

函数名 函数变更说明
quadprog 性能优化
fmincon 性能优化
fsolve 函数功能新增
optimoptions 函数功能新增

# 信号处理工具箱

信号处理工具箱修改函数 23 个。

函数名 函数变更说明
square 函数优化
grpdelay 函数优化，输入二阶节计算的群延迟更加精确
findpeaks 函数优化
downsample 函数优化
fir1 函数优化
sawtooth 函数优化
pwelch 修复了部分配置下的功能异常
bilinear 函数优化
freqz 函数优化
butter 函数优化，修改
maxflat 函数优化
fftfilt 函数优化，并支持了复数输入
finddelay 函数优化，并指出了复数输入
ty_pwelch 函数优化
czt 函数优化
hilbert 函数优化，支持输入变换长度的用法
zp2tf bug 修复，修复了 zp2tf 中极点为空时报错的问题
freqs 函数优化
upsample 函数优化
invfreqz 函数优化
pspectrum 函数优化
pulstran 函数优化
vmd 函数优化

# 通信工具箱

通信工具箱修改函数 3 个。

函数名 函数变更说明
awgn 函数优化，修改了输入为复数时随机数生成方式
bi2de 函数优化
de2bi 函数优化

# 射频工具箱

射频工具箱修改函数 2 个。

函数名 函数变更说明
s2z 支持了输入标量、向量的 s 参数
sparameter 修复了对 snp 文件内的 tab 解析错误的问题

# ★仪器控制工具箱（新增）

新增仪器控制工具箱，仪器控制工具支持 Syslab 直接与示波器、函数发生器、信号分析仪、信号发生器、电源和分析仪器等设备进行连接。该工具箱基于 VISA、串口、TCP/IP 等常用通信协议/接口的文本型 SCPI 命令实现仪器连接。发布 47 个函数。

函数名 函数说明
tcpclient 与 TCP/IP 服务器建立连接
configureTerminator 设置通过 TCP/IP 与远程主机进行 ASCII 字符串通信的终止符
read 通过 TCP/IP 从远程主机读取数据
readline 通过 TCP/IP 从远程主机读取 ASCII 字符串数据行
readbinblock 通过 TCP/IP 从远程主机读取二进制数据块
write 通过 TCP/IP 将数据写入远程主机
writeline 通过 TCP/IP 向远程主机写入一行 ASCII 数据
writebinblock 通过 TCP/IP 向远程主机写入二进制数据块
writeread 通过 TCP/IP 向远程主机写入命令并读取响应
flush 清除 TCP/IP 通信的缓冲区
echotcpip 启动或停止 TCP/IP 回显服务器
close 关闭 TCP/IP 连接
tcpclientfind 查找 TCP/IP 客户端连接
serialport 建立串口连接
serialportlist 连接到系统的串口列表
configureTerminator 设置通过串口进行 ASCII 字符串通信的终止符
read 从串口读取数据
readline 从串口读取 ASCII 字符串数据行
readbinblock 从串口读取二进制数据块
write 向串口写入数据
writeline 向串口写入一行 ASCII 数据
writebinblock 向串口写入二进制数据块
writeread 向串口写入命令并读取响应
flush 刷新输入/输出缓冲区
getpinstatus 获取串口引脚状态
setRTS 设置串口 RTS 引脚
setDTR 设置串口 DTR 引脚
close 关闭串口连接
serialportfind 查找串口设备
visadev 使用 VISA 与设备建立连接
configureTerminator 设置与 VISA 资源进行 ASCII 字符串通信的终止符
visadevfind 查找 VISA 设备连接
read 从 VISA 资源读取数据
readline 从 VISA 资源读取 ASCII 字符串数据行
readbinblock 从 VISA 资源读取二进制数据块
write 向 VISA 资源写入数据
writeline 向 VISA 资源写入一行 ASCII 数据
writebinblock 向 VISA 资源写入二进制数据块
writeread 向 VISA 资源写入命令并读取响应
flush 清除 VISA 资源的缓冲区
getpinstatus 获取 VISA 串口引脚状态
setRTS 设置 VISA 串口 RTS 引脚
setDTR 设置 VISA 串口 DTR 引脚
close 关闭 VISA 设备连接
ins_load 保存仪器对象
ins_save 载入仪器对象
instrfind 查找仪器对象

# 控制系统工具箱

控制系统工具箱修改函数 7 个。

函数名 函数变更说明
isreal 性能优化
norm 性能优化
initial 性能优化，历史缺陷修复
bode 历史缺陷修复
lsim 历史缺陷修复
step 历史缺陷修复，性能优化
impulse 历史缺陷修复

# 系统辨识工具箱

系统辨识工具箱修改函数 1 个。

函数名 函数变更说明
idss 增加状态空间到传递函数的转换支持

# 鲁棒控制工具箱

鲁棒控制工具箱修改函数 1 个。

函数名 函数变更说明
diag 性能优化

# 图像处理工具箱

图像处理工具箱修改函数 3 个。

函数名 函数变更说明
copy 函数实现重构，提升运行效率
bwdist 完成算法重构，大幅提升运行效率
imdilate 实现 julia 语言重构，完成性能优化

# 机器学习工具箱

机器学习工具箱新增函数 2 个。

函数名 函数说明
xgboostr 用于训练基于 XGBoost 的回归模型
mdscale 非经典多维尺度分析

# 定点设计工具箱

定点设计工具箱新增函数 1 个。

函数名 函数说明
hex2num 使用 quantizer 将十六进制字符串转换为数字对象

# M 兼容新增函数

M 兼容新增函数 15 个，当前函数总数为 2048 个 M 函数及帮助文档。

函数名 函数说明
lasterror 最后一条错误消息和相关信息
lasterr 最后一条错误消息
lastwarn 最后一条警告消息
clipboard 在目标与系统剪贴板之间复制并粘贴文本
writecell 将元胞数组写入文件
convhulln N 维凸包
heaviside 海维赛德阶跃函数
iqr 数据集的四分位距
normalize 归一化数据
randg 尺度参数为 1 的伽马随机数
actxserver 创建 COM 服务器
ode78 求解非刚性微分方程 - 高阶方法
ode89 求解非刚性微分方程 - 高阶方法
quit 退出终端
exit 退出终端