# plpgsql_pg4ml **Repository Path**: stevechang/plpgsql_pg4ml ## Basic Information - **Project Name**: plpgsql_pg4ml - **Description**: 这是使用 postgresql v13 实现的，使用 plpgsql 编写的机器学习框架 - **Primary Language**: SQL - **License**: AGPL-3.0 - **Default Branch**: master - **Homepage**: None - **GVP Project**: No ## Statistics - **Stars**: 0 - **Forks**: 5 - **Created**: 2023-02-22 - **Last Updated**: 2023-02-22 ## Categories & Tags **Categories**: Uncategorized **Tags**: None ## README # readme 目录 >``` >一、pg4ml 机器学习框架安装指引 > 1. 安装条件与前置工作 > 2. 安装步骤 >二、mnist 手写体数字数据集的加工、lenet-5 模型的构建、训练 > 1. mnist 手写体数字数据集的加工 > 2. lenet-5 模型的构建 > 3. lenet-5 模型的训练 > 4. 若干说明 >三、基于数据库的机器学习框架设计基本原理 > 1. 矩阵基础运算 > 2. 分类、回归、神经网络 > 3. 聚类 > 4. 科学计算 > 5. 其他函数 > 6. 提升运行效率 >四、附录 > (一)、项目目录结构说明 > (二)、数据库对象命名惯常缩写或解释 > (三)、附表 > 1. 函数列表 > 2. 运算符列表 > 3. 存储过程介绍 > 4. 神经网络节点支持运算类型 >``` # 一、pg4ml 机器学习框架安装指引 >## 1. 安装条件与前置工作 >>>1). linux 环境； >>>2). 已安装 postgresql v13，系统中数据库用户为 postgres； >>>3). 已安装 python3； >>>4). 已安装 numpy； >>>5). 已安装 plpython3u； >## 2. 安装步骤 >>>1). 将项目工程中以下子目录拷贝到 linux 环境的 postgres 用户下； >>>>假定拷贝至目录 /var/lib/pgsql/pg4ml/01_main/。 >>>>``` >>>>├─/var/lib/pgsql/pg4ml/01_main/ >>>>│ ├─01_type_schema_extension >>>>│ ├─02_table_view >>>>│ ├─03_function >>>>│ ├─04_procedure >>>>│ ├─06_data_initial >>>>│ ├─09_operator >>>>│ ├─10_install >>>>``` >>>2). 更改为 postgres 用户权限操作、执行权限，如下例： >>> cd /var/lib/pgsql/pg4ml/01_main/ >>> chown postgres ./* >>> chgrp postgres ./* >>> find -type f | xargs dos2unix >>> chmod 755 ./10_install/install.sh >>>3). 执行安装，如下例： >>> su - postgres >>> cd /var/lib/pgsql/pg4ml/01_main/ >>> sh ./10_install/install.sh >>>4). 安装的若干说明 >>>> a. 安装过程将 drop schema sm_sc。如果非首次安装，请先备份 sm_sc 表数据； # 二、mnist 手写体数字数据集的加工、lenet-5 模型的构建、训练 >>## 1. mnist 手写体数字数据集的加工 >>>1). 该模型案例，在项目工程中的如下目录： >>>>./02_nn_model/000000002_mnist_lenet5_batchnorm >>>2). 在数据库中，创建表 sm_sc.tb_tmp_mnist_0201，用于接收数据集；sql 建表脚本如下： >>>>./02_nn_model/000000002_mnist_lenet5_batchnorm/01_mnist_dataset/01_create_source_data_table.sql >>>3). 在数据库中，向 sm_sc.tb_tmp_mnist_0201 中插入数据集，sql 脚本如下： >>>>在项目工程中的如下目录 ./02_nn_model/000000002_mnist_lenet5_batchnorm/02_import_source_data/ 中的 .sql 文件： >>>> a. mnist_train_part_00001_09992.sql >>>> b. mnist_train_part_09993_19992.sql >>>> c. mnist_train_part_19993_29992.sql >>>> d. mnist_train_part_29993_39992.sql >>>> e. mnist_train_part_39993_49992.sql >>>> f. mnist_train_part_49993_60000.sql >>>4). 在数据库中，将数据集编码后，插入 sm_sc.tb_nn_train_input_buff 表 ，sql 脚本如下： >>>>在项目工程中的如下目录 ./02_nn_model/000000002_mnist_lenet5_batchnorm/02_import_to_buffer_table/ 中的 .sql 文件： >>>> a. 01_import_dataset.sql >>## 2. lenet-5 模型的构建 >>>1). 在数据库中，创建 lenet-5 神经网络训练任务和模型设计、配置节点的超参数，sql 脚本如下： >>>>在项目工程中的如下目录 ./02_nn_model/000000002_mnist_lenet5_batchnorm/03_create_train_nn_task/ 中的 .sql 文件： >>>> a. 01_create_task.sql >>>> b. 02_create_nn.sql >>## 3. lenet-5 模型的训练 >>>1). 在数据库中，训练任务的准备工作，设置每组类别的小批量随机数量、规划训练次数，sql 脚本如下： >>>>在项目工程中的如下目录 ./02_nn_model/000000002_mnist_lenet5_batchnorm/04_train/ 中的 .sql 文件： >>>> a. 01_prepare.sql >>>2). 在数据库中，执行训练任务，设置初始学习率、损失函数梯度阈值等任务超参数，sql 脚本如下： >>>>在项目工程中的如下目录 ./02_nn_model/000000002_mnist_lenet5_batchnorm/04_train/ 中的 .sql 文件： >>>> a. 02_exec_train.sql >>## 4. 若干说明： >>>1). 步骤6，步骤7，可以交替循环执行，用于中途逐步递增规划次数、调整任务超参数； >>>2). 训练过程中，查看节点明细情况，sql 脚本举例如下： >>>>./02_nn_model/000000002_mnist_lenet5_batchnorm/04_train/03_track_data_in_nn_node.sql >>>3). 测试集、验证集验证正确预测结果，sql 脚本举例如下： >>>>./02_nn_model/000000002_mnist_lenet5_batchnorm/05_validation/01_predict.sql >>>4). 本项目中已经上传了一个训练过的模型： >>>>在项目工程中的如下目录 ./02_nn_model/000000002_mnist_lenet5_batchnorm/06_model_backup/ >>>>即，导出如下两表： >>>> a. sm_sc.tb_nn_node，用于继续训练； >>>> b. sm_sc.__vt_nn_node，用于测试集、验证集做预测； # 三、基于数据库的机器学习框架设计基本原理 schema 之 sm_sc 装载框架对象，避免后续对象命名与 schema public 冲突； >## 1. 矩阵基础运算 >>本套矩阵基础运算函数设计与运算库的规划，考虑到运算粒度因素。运算操作对象可能是以下其中的一种或多种： >>>1). 矩阵每个元素的内部结构。比如：复矩阵取各元素实部； >>>2). 两个或多个入参矩阵的一一对应元素。比如；点(广播)四则运算； >>>3). 入参矩阵的切片。比如：切片聚合； >>>4). 入参矩阵。比如：转置； >>>5). 多个入参矩阵聚合。比如：多个矩阵每个对应位置求平均； >>
>>本套矩阵基础运算函数库，带有“点(广播)”说明的函数，通常支持广播功能。包括如下场景： >>>1). 单元素值与一维数组(入参顺序不分先后)； >>>2). 单元素值与二维数组(入参顺序不分先后)； >>>3). 一维数组与二维数组(入参顺序不分先后)； >>>4). 二维数组单行与二维数组(入参顺序不分先后)； >>>5). 二维数组单列与二维数组(入参顺序不分先后)； >>其中3)、4)等价。 >>
>>本套矩阵基础运算函数库的很多函数，利用 postgresql 的伪类型特性，使用 anyarray 为入参和出参类型，类似 java 泛型或 c++ 类模板，以支持这些函数对任何元素类型的矩阵的多态。 >>
>>具体运算库函数分类规划： >>> fn_a. 矩阵元素的算数、比较、进位、拼接、布尔、位运算、复运算、广播运算： >>> fn_b. 矩阵乘法、转置、翻转、镜像、拼接： >>> fn_c. 矩阵的构造、采样、替换、填充、字符匹配、随机生成、去壳(缘于pg13版本暂不支持 array 高维切片)： >>> fn_d. 矩阵的三角函数广播运算： >>> fn_f. 矩阵的切片粒度聚合、矩阵粒度聚合、以某切片值排序、切片粒度定位极值位置： >
>## 2. 分类、回归、神经网络 >>1). table 之 sm_sc.tb_nn_node / sm_sc.__vt_nn_node(前者用于训练，后者用于测试和验证)、sm_sc.tb_nn_path 表，用于承载深度神经网络的 node 和 path 结构； >>2). table 之 sm_sc.tb_nn_train_input_buff ，用于公共接收训练集； >>3). table 之 sm_sc.tb_classify_task ，用于部署和管理训练任务； >>4). 定义了机器学习、矩阵运算的相关函数，用于实时执行简单运算或原子运算； >>具体运算函数库分类规划： >>> fn_g. 机器学习的标准化函数： >>> fn_h. 机器学习的激活函数： >>> fn_j. 机器学习的卷积、池化： >>> fn_k. 机器学习的 lambda： >>> fn_l. 机器学习的神经网络专用： >>> fn_m. 机器学习的编码、解码： >>> fn_n. 机器学习的损失函数： >>> fn_q. 导数公式推导： >>> fn_r. 复杂函数求导： >> 5). procedure 之 sm_sc.prc_nn_prepare / sm_sc.prc_nn_train，用于深度神经网络训练任务的准备和执行； >>> a. 执行 sm_sc.prc_nn_prepare 之前，可以通过更新 input buff_slice_rand_pick 节点的 node_fn_asso_value，调整随机小批量的每个类别采样数量； >>> b. sm_sc.prc_nn_train 采用了 adam 梯度下降算法 >> 6). procedure 之 sm_sc.prc_linear_regression / sm_sc.prc_logistic_regression，用于线性回归、逻辑分类的浅层训练任务的准备和执行； >>> 当一轮准备和执行完成，可以调高 sm_sc.prc_nn_prepare 的次数参数，接续准备和执行； >> 7). function 之 sm_sc.fv_nn_in_out，用于输入测试集或验证集的单条数据，输出测试或验证结果； >
>## 3. 聚类 >> 1). 硬聚类之 kmeans++ >>> a. table 之 sm_sc.tb_cluster_task ，用于部署和管理训练任务； >>> b. procedure 之 sm_sc.prc_kmeans_pp，用于执行 kmeans++ 任务； >> 2). 软聚类之 dbscan >>> a. table 之 sm_sc.tb_cluster_task ，用于部署和管理训练任务； >>> b. procedure 之 sm_sc.prc_dbscan_pp，用于执行 dbscan 任务； >
>## 4. 科学计算 >> 1). 定义了科学计算的相关函数，用于实时执行简单运算或原子运算； >>具体运算函数库分类规划： >>> fn_e. 波形处理： >>> fn_i. 计算图的 json 序列化、反序列化： >>> fn_o. 复数运算： >>> fn_s. 线性代数： >
>## 5. 其他函数 >> fn_p. 对 postgresql 补充的 udf 公共函数：
>## 6. 提升运行效率 >>以下建议，用于运算速度提升。 >> 1). 矩阵运算库优化： >>>在当前版本，矩阵乘法通过 pg 的扩展 pgplpython3 调用 numpy 实现。 >>>建议也可以使用运行效率更高的其他编程语言矩阵运算库，比如 openblas； >> 2). 训练过程多线程： >>>a. 调整系统内核参数 /etc/sysctl.conf, /etc/security/limits.conf, 为 pg 数据库分配更多系统资源； >>>b. 设置 pg 并行参数 >>>>min_parallel_table_scan_size >>>>min_parallel_index_scan_size >>>>force_parallel_mode >>>>max_parallel_workers_per_gather >>>>parallel_setup_cost >>>>parallel_tuple_cost >> 3). 分布式计算改造： >>>建议可以对神经网络节点的 lambda 调用改造为 rdd 或 mpp； >> 4). 使用 GPU： >>>建议可以创建 pg_strom 扩展，引入 GPU 计算；
# 四、附录 ## (一)、项目目录结构说明 >``` >├─plpgsql_pg4ml >│ ├─01_main >│ │ ├─01_type_schema_extension : 创建 schema 和 extension >│ │ │ └─04_create_type : 创建类型 >│ │ │ ├─01 : 此处序号仅为了控制部署执行顺序 >│ │ │ └─02 : 此处序号仅为了控制部署执行顺序 >│ │ ├─02_table_view : 创建 table 和 view >│ │ ├─03_function : 创建 function >│ │ │ ├─03_matrix : 矩阵相关函数 >│ │ │ │ ├─01_calcu_bit_concat_compare : 算数运算、位运算、拼接、比较 >│ │ │ │ ├─03_prod_trans_turn_mirror : 矩阵乘法、变换、转换、镜像 >│ │ │ │ ├─04_construct_sample_match_replace : 构建、采样、匹配、替换 >│ │ │ │ ├─05_trigono : 三角运算 >│ │ │ │ ├─06_wave : 波形变换 >│ │ │ │ └─09_slice_aggr_ord : 切片、聚合、排序 >│ │ │ │ ├─01_fv : 此处序号仅为了控制部署执行顺序，返回数值 >│ │ │ │ └─02_fa : 此处序号仅为了控制部署执行顺序，聚合函数 >│ │ │ ├─04_machine_learn : 机器学习相关函数 >│ │ │ │ ├─01_udf_calcu : 自定义简单类型函数 >│ │ │ │ ├─02_standlize : 标准化函数 >│ │ │ │ ├─03_grad_reduction : 导数推导 >│ │ │ │ ├─04_activate : 激活函数 >│ │ │ │ ├─05_computational_graph_json : json 类型的计算图 >│ │ │ │ ├─06_conv_pool : 卷积、池化 >│ │ │ │ ├─07_lambda : lambda 函数 >│ │ │ │ ├─08_nn : 神经网络 >│ │ │ │ ├─09_encode_decode : 编码、解码 >│ │ │ │ └─10_loss_fn : 损失函数 >│ │ │ ├─05_complex : 复数 >│ │ │ │ └─alian : 复数有关的函数别名 >│ │ │ ├─06_common : 通用性函数 >│ │ │ └─07_math_array : 线性代数 >│ │ ├─04_procedure : 创建存储过程 >│ │ │ └─01_machine_learn : 机器学习 >│ │ │ ├─01_classify_regress : 分类、回归 >│ │ │ ├─02_neural_network : 神经网络 >│ │ │ └─03_cluster : 聚类 >│ │ ├─06_data_initial : 初始化数据 >│ │ ├─09_operator : 创建运算符 >│ │ ├─10_install : 安装部署 >│ └─02_nn_model : 模型 >│ ├─000000002_mnist_lenet5_batchnorm : mnist 数据集，lenet-5神经网络、BN 标准化 >│ │ ├─01_mnist_dataset : mnist 数据集 >│ │ ├─02_import_to_buffer_table : 导入 buff 表 >│ │ ├─03_create_train_nn_task : 创建神经网络结构和训练任务 >│ │ ├─04_train : 执行训练 >│ │ ├─05_validation : 验证 >│ │ └─06_model_backup : 导出训练模型 >│ ├─00xxxxxxx_xxxx : 其他模型 >│ │ ├─01_xxx_dataset : xxx 数据集 >│ │ ├─... : 模型其他目录... >│ ├─... : 其他模型... >``` ## (二)、数据库对象命名惯常缩写或解释 >* _ : 做为命名前缀，意味着执行体(包括代码块，函数，存储过程)内部使用的临时对象 >* __ : 做为命名前缀，意味着全局内部使用对象 >* typ_ : type，类型对象 >* sm_ : schema，模式，类似于逻辑概念的 database 或 tablespace >* seq_ : sequence，序列 >* tb_ : table，表 >* idx_ : index，索引 >* vw_ : view，普通视图 >* xv_ : x_view，带有关联、复杂运算的视图 >* fv_ : function_value，返回数据类型数值的函数 >* ft_ : function_table，返回表的函数 >* fa_ : function_aggregate，聚合函数 >* prc_ : procedure，存储过程 >* m_ : member，(类型)成员 >* is_ : bool 判断 >* i_ : input，输入变量 >* o_ : output，输出变量 >* v_ : val，变量 >* cte_ : common_table_expression，公共表达式 >* enum_ : enum，枚举 >* sess_ : session，会话 >* _a_ : alias，别名 >* _co_ : cooperative，合作的，配套的 >* _asso_ : associate，协作的，副的 >* _no : number，编号 >* _id : id，标识 >* _ex_ : extra，额外的 >* _2_ : to，"指向"关系 >* _4_ : for，"用于"关系 >* _l_ : long，长类型 >* _s_ : short，短类型 >* _tmp_ : temp，临时对象 >* _ord_ : order，排序的 >* _aggr_ : aggregate，聚合的 >* _idx_ : position，定位的，检索的 >* _dic_ : dictionary，字典的 >* _opr_ : operator，运算符的 >* _sum_ : summary，汇总的 >* _lsum_ : low_summary，低粒度汇总的 >* _hsum_ : high_summary，高粒度汇总的 >* _cfg_ : configure，配置的 >* _fn_ : function，函数的 >* _time_ : time，时间有关的 >* _lang_ : language，语言有关的 >* _gis_ : geographic_information_system，地理有关的，地点有关的，地图有关的 >* _sys_ : system，系统配套的 >* _map_ : map，映射关系 >* _snap_ : snapshot，快照，不随时间线性变化的清单 >* _trs_ : transaction，流水，随时间线性变化的清单 >* _ods_ : operational_data_store，(业务系统)主数据 >* _dw_ : data_warehouse，数据仓库，数据加工，数据分析处理过程 >* _dm_ : data_market，数据集市，成品分析数据 >* _sour_ : source，源 >* _tar_ : target，目标 >* _his_ : history，历史(数据) >* _slice_ : slice，(数组)切片 >* _arr_ : array，数组 >* _y_ : y 轴，二维数组的第一维度，也即纵向方向 >* _x_ : x 轴，二维数组的第二维度，也即横向方向 >* _mx_ : metrix，矩阵，也即二维数组 >* _1d_ : 1st_dimension，一维(数组) >* _2d_ : 2nd_dimension，二维(数组) >* _ele_ : element，(数组)元素 >* _area_ : area，指定区域 >* _pos_ : position，指定位置 >* _nn_ : neural_network，神经网络 >* _fore_ : fore，(神经网络)前向 >* _back_ : back，(神经网络)反向 >* _loss_ : loss，损失函数相关 ## (三)、附表 >### 1. 函数列表 >>#### a. 矩阵元素的算数、比较、进位、拼接、布尔、位运算、复运算、广播运算： >> >>> 函数名|函数说明|调用举例 >>> :-|:-|:- >>> sm_sc.fv_opr_add |点(广播)加。
参数：
  1. 加数1；
  2. 加数2； |select
  sm_sc.fv_opr_add
  (
    array[[1.3, -8.8],[2.2, -3.0]]
  , array[[-2.6, 11.3],[-4.6, 5.1]]
  );

返回：
  array[[-1.3, 2.5],[-2.4, 2.1]] >>> sm_sc.fv_opr_sub |点(广播)减。
参数：
  1. 被减数；
  2. 减数； |select
  sm_sc.fv_opr_sub
  (
    array[[1.3, -8.8],[2.2, -3.0]]
  , array[[-2.6, 11.3],[-4.6, 5.1]]
  );

返回：
  array[[3.9, -20.1],[6.8, -8.1]] >>> sm_sc.fv_opr_sub |点(广播)相反数。
参数：
  1. 原数；|select
  sm_sc.fv_opr_sub
  (
    array[[1.3, -8.8],[2.2, -3.0]]
  );

返回：
  array[[-1.3,8.8],[-2.2,3.0]] >>> sm_sc.fv_opr_mul |点(广播)乘。
参数：
  1. 乘数1；
  2. 乘数2； |select
  sm_sc.fv_opr_mul
  (
    array[[1.3, -8.8],[2.2, -3.0]]
  , array[[-2.6, 11.3],[-4.6, 5.1]]
  );

返回：
  array[[-3.38, -99.44],[-10.12, -15.30]] >>> sm_sc.fv_opr_div |点(广播)除。
参数：
  1. 被除数；
  2. 除数； |select
  sm_sc.fv_opr_div
  (
    array[[1.3, -8.8],[2.2, -3.0]]
  , array[[-2.6, 11.3],[-4.6, 5.1]]
  );

返回：
  array[[-0.5, -0.77876],[-0.47826, -0.58824]] >>> sm_sc.fv_opr_div |点(广播)倒数。
参数：
  1. 原数； |select
  sm_sc.fv_opr_div
  (
    array[[1.3, -8.8],[2.2, -3.0]]
  );

返回：
  array[[0.76923, -0.11364],[0.45455, -0.33333]] >>> sm_sc.fv_opr_mod |点(广播)求余。
参数：
  1. 被除数；
  2. 除数； |select
  sm_sc.fv_opr_mod
  (
    array[[10, -29],[12, -33]]
  , array[[-3, 11],[-5, 5]]
  );

返回：
  array[[1, -7],[2, -3]] >>> sm_sc.fv_opr_pow |点(广播)幂。
参数：
  1. 底数；
  2. 指数； |select
  sm_sc.fv_opr_pow
  (
    array[[1.3, 8.8],[2.2, 3.0]]
  , array[[-2.6, 1.3],[-4.6, 5.1]]
  );

返回：
  array[[0.50553, 16.89770],[0.02660, 271.21793]] >>> sm_sc.fv_opr_exp |点(广播)自然常数幂。
参数：
  1. 指数； |select
  sm_sc.fv_opr_exp
  (
    array[[1.3, -8.8],[2.2, -3.0]]
  );

返回：
  array[[3.66930, 0.00015],[9.02501, 0.04979]] >>> sm_sc.fv_opr_log |点(广播)对数。
参数：
  1. 底数；
  2. 真数； |select
  sm_sc.fv_opr_log
  (
    array[[1.3, 8.8],[2.2, 3.0]]
  , array[[2.6, 11.3],[4.6, 5.1]]
  );

返回：
  array[[3.64193, 1.11498],[1.93550, 1.48300]] >>> sm_sc.fv_opr_ln |点(广播)自然对数。
参数：
  1. 真数； |select
  sm_sc.fv_opr_ln
  (
    array[[1.3, 8.8],[2.2, 3.0]]
  );

返回：
  array[[0.26236, 2.17475],[0.78846, 1.09861]] >>> sm_sc.fv_opr_or |点(广播)位或、逻辑或操作。
参数：
  1. 操作数1；
  2. 操作数2； |select
  sm_sc.fv_opr_or
  (
    array[[true, false],[true, false]]
  , array[[false, true],[false, true]]
  );

返回：
  array[[true, true],[true, true]]
--------------------------
select
  sm_sc.fv_opr_or
  (
    array[[B'010', B'011'],[B'101', B'011']]
  , array[[B'011', B'101'],[B'011', B'101']]
  );

返回：
  array[[B'011', B'111'],[B'111', B'111']] >>> sm_sc.fv_opr_and |点(广播)位与、逻辑且操作。
参数：
  1. 操作数1；
  2. 操作数2； |select
  sm_sc.fv_opr_and
  (
    array[[true, false],[true, false]]
  , array[[false, true],[false, true]]
  );

返回：
  array[[false, false],[false, false]]
--------------------------
select
  sm_sc.fv_opr_and
  (
    array[[B'010', B'011'],[B'101', B'011']]
  , array[[B'011', B'101'],[B'011', B'101']]
  );

返回：
  array[[B'010', B'001'],[B'001', B'001']] >>> sm_sc.fv_opr_not |点(广播)位非、逻辑否操作。
参数：
  1. 操作数1； |select
  sm_sc.fv_opr_not
  (
    array[[true, false],[true, false]]
  );

返回：
  array[[false, true],[false, true]]
--------------------------
select
  sm_sc.fv_opr_not
  (
    array[[B'010', B'011'],[B'101', B'011']]
  );

返回：
  array[[B'101', B'100'],[B'010', B'100']] >>> sm_sc.fv_opr_is_regexp_match |点(广播)文本是否匹配。
参数：
  1. 原文本矩阵；
  2. 正则表达式矩阵； |select
  sm_sc.fv_opr_is_regexp_match
  (
    array[['abbbbbc122223', 'abc123'],['abc123', 'ac13']]
  , array[['a.c', '1.\*?3'],['1.3', 'a.\*?c']]
  );

返回：
  array[[false, true],[true, true]] >>> sm_sc.fv_opr_conjugate |点(广播)复元素共轭。
参数：
  1. 原数； |select
  sm_sc.fv_opr_conjugate
  (
    array[[(12.3, -25.1), (-2.56, 3.25)]
             ,[(12.3, 0.0), (0.0, 3.25)]] :: sm_sc.typ_l_complex[]
  );

返回：
  array[[(12.3, 25.1), (-2.56, -3.25)]
           ,[(12.3, 0.0), (0.0, -3.25)]] :: sm_sc.typ_l_complex[] >>> sm_sc.fv_opr_conjugate_i |复矩阵共轭。
参数：
  1. 原数； |select
  sm_sc.fv_opr_conjugate_i
  (
    array[[(12.3, -25.1), (-2.56, 3.25)]
             ,[(12.3, 0.0), (0.0, 3.25)] :: sm_sc.typ_l_complex[]
  );

返回：
  array[[(12.3, 25.1), (12.3, 0.0)]
           ,[(-2.56, -3.25), (0.0, -3.25)]] :: sm_sc.typ_l_complex[] >>> sm_sc.fv_opr_real |点(广播)复元素实部。
参数：
  1. 原数； |select
  sm_sc.fv_opr_real
  (
    array[[(12.3, -25.1), (-2.56, 3.25)]
             ,[(12.3, 0.0), (0.0, 3.25)]] :: sm_sc.typ_l_complex[]
  );

返回：
  array[[12.3, -2.56],[12.3, 0.0]] >>> sm_sc.fv_opr_imaginary |点(广播)复元素虚部。
参数：
  1. 原数； |select
  sm_sc.fv_opr_imaginary
  (
    array[[(12.3, -25.1), (-2.56, 3.25)]
             ,[(12.3, 0.0), (0.0, 3.25)]] :: sm_sc.typ_l_complex[]
  );

返回：
  array[[-25.1, 3.25],[0.0, 3.25]] >>> sm_sc.fv_opr_conjugate_45 |点(广播)复元素实虚对换。
参数：
  1. 原数； |select
  sm_sc.fv_opr_conjugate_45
  (
    array[[(12.3, -25.1), (-2.56, 3.25)]
             ,[(12.3, 0.0), (0.0, 3.25)]] :: sm_sc.typ_l_complex[]
  );

返回：
  array[[(-25.1, 12.3), (3.25, -2.56)]
           ,[(0.0, 12.3), (3.25, 0.0)]] :: sm_sc.typ_l_complex[] >>> sm_sc.fv_opr_xor |点(广播)位异或、逻辑异或操作。
参数：
  1. 操作数1；
  2. 操作数2； |select
  sm_sc.fv_opr_xor
  (
    array[[true, true],[true, true]]
  , array[[false, true],[false, true]]
  );

返回：
  array[[true, true],[true, true]]
--------------------------
select
  sm_sc.fv_opr_xor
  (
    array[[B'010', B'011'],[B'101', B'011']]
  , array[[B'011', B'101'],[B'011', B'101']]
  );

返回：
  array[[B'001', B'110'],[B'110', B'110']] >>> sm_sc.fv_opr_xnor |点(广播)位同或、逻辑同或操作。
参数：
  1. 操作数1；
  2. 操作数2； |select
  sm_sc.fv_opr_xnor
  (
    array[[true, false],[true, false]]
  , array[[false, true],[false, true]]
  );

返回：
  array[[false, false],[false, false]]
--------------------------
select
  sm_sc.fv_opr_xnor
  (
    array[[B'010', B'011'],[B'101', B'011']]
  , array[[B'011', B'101'],[B'011', B'101']]
  );

返回：
  array[[B'110', B'001'],[B'001', B'001']] >>> sm_sc.fv_opr_concat |点(广播)拼接。
参数：
  1. 操作数1；
  2. 操作数2； |select
  sm_sc.fv_opr_concat
  (
    array[['abc', 'efgh'],['hijk', 'lm']]
  , array[['no', 'pqr'],['stu', 'vwxyz']]
  );

返回：
  array[['abcno', 'efghpqr'],['hijkstu', 'lmvwxyz']] >>> sm_sc.fv_opr_shift_left |点(广播)位左移。
参数：
  1. 操作数1； |select
  sm_sc.fv_opr_shift_left
  (
    array[[B'010', B'011'],[B'101', B'011']]
  , array[[1, 2],[-1, -2]]
  );

返回：
  array[[B'100', B'100'],[B'010', B'000']] >>> sm_sc.fv_opr_shift_right |点(广播)位右移。
参数：
  1. 操作数1； |select
  sm_sc.fv_opr_shift_right
  (
    array[[B'010', B'011'],[B'101', B'011']]
  , array[[1, 2],[-1, -2]]
  );

返回：
  array[[B'001', B'000'],[B'010', B'100']] >>> sm_sc.fv_opr_is_equal |点(广播)相等判断。
参数：
  1. 操作数1；
  2. 操作数2； |select
  sm_sc.fv_opr_is_equal
  (
    array[[1.3, -8.8],[2.2, -3.0]]
  , array[[-2.6, -8.8],[2.2, 5.1]]
  );

返回：
  array[[false, true],[true, false]] >>> sm_sc.fv_opr_is_less |点(广播)小于判断。
参数：
  1. 操作数1；
  2. 操作数2； |select
  sm_sc.fv_opr_is_less
  (
    array[[1.3, -8.8],[2.2, -3.0]]
  , array[[-2.6, 11.3],[-4.6, 5.1]]
  );

返回：
  array[[false, true],[false, true]] >>> sm_sc.fv_opr_is_greater |点(广播)大于判断。
参数：
  1. 操作数1；
  2. 操作数2； |select
  sm_sc.fv_opr_is_greater
  (
    array[[1.3, -8.8],[2.2, -3.0]]
  , array[[-2.6, 11.3],[-4.6, 3.0]]
  );

返回：
  array[[true, false],[true, false]] >>> sm_sc.fv_opr_is_less_ex |点(广播)小于等于判断。
参数：
  1. 操作数1；
  2. 操作数2； |select
  sm_sc.fv_opr_is_less_ex
  (
    array[[1.3, -8.8],[2.2, -3.0]]
  , array[[1.3, -8.8],[-4.6, 5.1]]
  );

返回：
  array[[true, true],[false, true]] >>> sm_sc.fv_opr_is_greater_ex |点(广播)大于等于判断。
参数：
  1. 操作数1；
  2. 操作数2； |select
  sm_sc.fv_opr_is_greater_ex
  (
    array[[1.3, 11.3],[2.2, -3.0]]
  , array[[-2.6, 11.3],[2.2, 5.1]]
  );

返回：
  array[[true, true],[true, false]] >>> sm_sc.fv_opr_compare |点(广播)比较大小。
参数：
  1. 操作数1；
  2. 操作数2； |select
  sm_sc.fv_opr_compare
  (
    array[[1.3, -8.8],[2.2, -3.0]]
  , array[[-2.6, 11.3],[-4.6, 5.1]]
  );

返回：
  array[[1, -1],[1, -1]] >>> sm_sc.fv_opr_sign |点(广播)正负判断。
参数：
  1. 操作数1；
  2. 操作数2； |select
  sm_sc.fv_opr_sign
  (
    array[[1.3, -8.8],[2.2, -3.0],[-2.6, 11.3]]
  );

返回：
  array[[1, -1],[1, -1],[-1, 1]] >>> sm_sc.fv_opr_least |点(广播)取小。
参数：
  1. 操作数1；
  2. 操作数2； |select
  sm_sc.fv_opr_least
  (
    array[[1.3, -8.8],[2.2, -3.0]]
  , array[[-2.6, 11.3],[-4.6, 5.1]]
  );

返回：
  array[[-2.6, -8.8],[-4.6, -3.0]] >>> sm_sc.fv_opr_greatest |点(广播)取大。
参数：
  1. 操作数1；
  2. 操作数2； |select
  sm_sc.fv_opr_greatest
  (
    array[[1.3, -8.8],[2.2, -3.0]]
  , array[[-2.6, 11.3],[-4.6, 5.1]]
  );

返回：
  array[[1.3, 11.3],[2.2, 5.1]] >>> sm_sc.fv_opr_abs |点(广播)绝对值。
参数：
  1. 原数； |select
  sm_sc.fv_opr_abs
  (
    array[[1.3, -8.8],[2.2, -3.0],[-2.6, 11.3]]
  );

返回：
  array[[1.3, 8.8],[2.2, 3.0],[2.6, 11.3]] >>> sm_sc.fv_opr_round |点(广播)四舍五入。
参数：
  1. 原数；
  2. 保留小数点后位数； |select
  sm_sc.fv_opr_round
  (
    array[[1244.3753, -8.8443],[225.2153, -30.03821]]
  , 2
  );

返回：
  array[[1240, -10],[230, -30]]
--------------------------
select
  sm_sc.fv_opr_round
  (
    array[[1244.3753, -8.8443],[225.2153, -30.03821]]
  );

返回：
  array[[1244, -9],[225, -30]] >>> sm_sc.fv_opr_floor |点(广播)数位地板值。
参数：
  1. 原数；
  2. 保留小数点后位数； |select
  sm_sc.fv_opr_floor
  (
    array[[1244.3753, -8.8443],[225.2153, -30.03821]]
  , 2
  );

返回：
  array[[1244.37, -8.85],[225.21, -30.04]]
--------------------------
select
  sm_sc.fv_opr_floor
  (
    array[[1244.3753, -8.8443],[225.2153, -30.03821]]
  );

返回：
  array[[1244, -9],[225, -31]] >>> sm_sc.fv_opr_ceil |点(广播)数位天花板值。
参数：
  1. 原数；
  2. 保留小数点后位数； |select
  sm_sc.fv_opr_ceil
  (
    array[[1244.3753, -8.8443],[225.2153, -30.03821]]
  , 2
  );

返回：
  array[[1244.38, -8.84],[225.22, -30.03]]
--------------------------
select
  sm_sc.fv_opr_ceil
  (
    array[[1244.3753, -8.8443],[225.2153, -30.03821]]
  );

返回：
  array[[1245, -8],[226, -30]] >>> sm_sc.fv_opr_trunc |点(广播)数位截取值。
参数：
  1. 原数；
  2. 保留小数点后位数； |select
  sm_sc.fv_opr_trunc
  (
    array[[1244.3753, -8.8443],[225.2153, -30.03821]]
  , 2
  );

返回：
  array[[1244.37, -8.84],[225.21, -30.03]]
--------------------------
select
  sm_sc.fv_opr_trunc
  (
    array[[1244.3753, -8.8443],[225.2153, -30.03821]]
  );

返回：
  array[[1244, -8],[225, -30]] >> >>#### b. 矩阵乘法、转置、翻转、镜像、拼接： >> >>> 函数名|函数说明|调用举例 >>> :-|:-|:- >>> sm_sc.fv_opr_concat_x |矩阵左右拼接，第二维度的拼接。
参数：
  1. 操作数1；
  2. 操作数2； |select
  sm_sc.fv_opr_concat_x
  (
    array[[1.3, -8.8],[2.2, -3.0]]
  , array[[-2.6, 11.3, 1.1],[-4.6, 5.1, 0.4]]
  );

返回：
  array[[1.3, -8.8, -2.6, 11.3, 1.1]
          ,[2.2, -3.0, -4.6, 5.1, 0.4]] >>> sm_sc.fv_opr_concat_y |矩阵上下拼接，第一维度的拼接。
参数：
  1. 操作数1；
  2. 操作数2； |select
  sm_sc.fv_opr_concat_y
  (
    array[[1.3, -8.8],[2.2, -3.0]]
  , array[[-2.6, 11.3],[-4.6, 5.1],[2.6, 5.8]]
  );

返回：
  array[[1.3, -8.8]
          ,[2.2, -3.0]
          ,[-2.6, 11.3]
          ,[-4.6, 5.1]
          ,[2.6, 5.8]] >>> sm_sc.fv_opr_mirror_x |矩阵左右镜像，第二维度倒序排列。
参数：
  1. 操作数1； |select
  sm_sc.fv_opr_mirror_x
  (
    array[[1.3, -8.8, 2.25],[2.2, -3.0, -0.95]]
  );

返回：
  array[[2.25, -8.8, 1.3],[-0.95, -3.0, 2.2]] >>> sm_sc.fv_opr_mirror_y |矩阵上下镜像，第一维度倒序排列。
参数：
  1. 操作数1； |select
  sm_sc.fv_opr_mirror_y
  (
    array[[1.3, -8.8, 2.25],[2.2, -3.0, -0.95]]
  );

返回：
  array[[2.2, -3.0, -0.95],[1.3, -8.8, 2.25]] >>> sm_sc.fv_opr_transpose |矩阵转置。
参数：
  1. 操作数1； |select
  sm_sc.fv_opr_transpose
  (
    array[[1.3, -8.8, 2.25],[2.2, -3.0, -0.95]]
  );

返回：
  array[[1.3, 2.2],[-8.8,-3.0],[2.25,-0.95]] >>> sm_sc.fv_opr_transpose_i |矩阵反转置，等价于左右镜像后再转置。
参数：
  1. 操作数1； |select
  sm_sc.fv_opr_transpose_i
  (
    array[[1.3, -8.8, 2.25],[2.2, -3.0, -0.95]]
  );

返回：
  array[[-0.95,2.25],[-3.0,-8.8],[2.2,1.3]] >>> sm_sc.fv_opr_turn_back |矩阵旋转180°，等价于转置后再反转置。
参数：
  1. 操作数1； |select
  sm_sc.fv_opr_turn_back
  (
    array[[1.3, -8.8, 2.25],[2.2, -3.0, -0.95]]
  );

返回：
  array[[2.25, -8.8, 1.3],[-0.95, -3.0, 2.2]] >>> sm_sc.fv_opr_turn_left |矩阵逆时针旋转90°。
参数：
  1. 操作数1； |select
  sm_sc.fv_opr_turn_left
  (
    array[[1.3, -8.8, 2.25],[2.2, -3.0, -0.95]]
  );

返回：
  array[[2.2, 1.3],[-3.0, -8.8],[-0.95, 2.25]] >>> sm_sc.fv_opr_turn_right |矩阵顺时针旋转90°。
参数：
  1. 操作数1； |select
  sm_sc.fv_opr_turn_right
  (
    array[[1.3, -8.8, 2.25],[2.2, -3.0, -0.95]]
  );

返回：
  array[[2.25, -0.95],[-8.8, -3.0],[1.3, 2.2]] >>> sm_sc.fv_opr_prod_inner |矩阵内积；数量积。
参数：
  1. 操作数1；
  2. 操作数2； |select
  sm_sc.fv_opr_prod_inner
  (
    array[[1.3, -8.8, 2.25],[2.2, -3.0, -0.95]]
  , array[[-2.6, 11.3, 3.3],[-4.6, 5.1, -6.1]]
  );

返回：
  -115.020 >>> sm_sc.fv_opr_prod_inner_pow |矩阵内积幂；数量积幂。
参数：
  1. 数量积的底数；
  2. 数量积的指数； |select
  sm_sc.fv_opr_prod_inner_pow
  (
    array[[1.3, -8.8, 2.25],[2.2, -3.0, -0.95]]
  , 3.0
  );

返回：
  -685.09375 >>> sm_sc.fv_opr_prod_kronecker |Kronecker 积。
参数：
  1. 操作数1；
  2. 操作数2； |select
  sm_sc.fv_opr_prod_kronecker
  (
    array[[1.3, -8.8, 2.25],[2.2, -3.0, -0.95]]
  , array[[-2.6, 11.3],[-4.6, 5.1]]
  );

返回：
  array[[-3.38, 14.69, 22.88, -99.44, -5.850, 25.425]
          ,[-5.98, 6.63, 40.48, -44.88, -10.350, 11.475]
          ,[-5.72, 24.86, 7.80, -33.90, 2.470, -10.735]
          ,[-10.12, 11.22, 13.80, -15.30, 4.370, -4.845]] >>> sm_sc.fv_opr_prod_mx_py |python 实现的矩阵乘法、外积。
参数：
  1. 操作数1；
  2. 操作数2； |select
  sm_sc.fv_opr_prod_mx_py
  (
    array[[1.3, -8.8, 2.25],[2.2, -3.0, -0.95]]
  , array[[-2.6, 11.3],[-4.6, 5.1],[4.1, -3.1]]
  );

返回：
  array[[46.3250, -37.1650],[4.1850, 12.5050]] >>> sm_sc.fv_opr_prod_mx_pow |矩阵方阵乘法幂。
参数：
  1. 矩阵乘法的底数；
  2.矩阵乘法的指数； |select
  sm_sc.fv_opr_prod_mx_pow
  (
    array[[1.3, 2.25],[2.2, -3.0]]
  , 3
  );

返回：
  array[[1.3000, 2.25],[2.2000, -3.0]] >>> sm_sc.fv_opr_prod_mx_left |矩阵方阵乘以其转置。
参数：
  1. 操作数1； |select
  sm_sc.fv_opr_prod_mx_left
  (
    array[[-8.8, 2.25],[2.2, -0.95]]
  );

返回：
  array[[82.5025, -21.4975],[-21.4975, 5.7425]] >>> sm_sc.fv_opr_prod_mx_right |矩阵方阵的转置乘以该矩阵。
参数：
  1. 操作数1； |select
  sm_sc.fv_opr_prod_mx_right
  (
    array[[1.3, 2.25],[2.2, -3.0]]
  );

返回：
  array[[6.5300, -3.6750],[-3.6750, 14.0625]] >> >>#### c. 矩阵的构造、采样、替换、填充、字符匹配、随机生成、去壳(缘于pg13版本暂不支持 array 高维切片)： >> >>> 函数名|函数说明|调用举例 >>> :-|:-|:- >>> sm_sc.fv_mx_ele_2d_2_1d |二维数组扁平化为一维数组。
参数：
  1. 操作数1；|select
  sm_sc.fv_mx_ele_2d_2_1d
  (
    array[[1.3, -8.8],[2.2, -3.0]]
  );

返回：
  array[1.3, -8.8, 2.2, -3.0] >>> sm_sc.fv_mx_ele_1d_2_2d |一维数组按照指定宽度堆砌为二维数组。
参数：
  1. 原一维数组；
  2. 指定宽度；|select
  sm_sc.fv_mx_ele_1d_2_2d
  (
    array[[1.3, -8.8, 2.2, -3.0, 6.1, 0.23]]
  , 3
  );

返回：
  array[[1.3, -8.8, 2.2]
          ,[-3.0, 6.1, 0.23]] >>> sm_sc.fv_new |给定元素值构造二维数组。
参数：
  1. 元素值；
  2. 二维数组高宽规格；|select
  sm_sc.fv_new
  (
    3.6
  , array[3, 4]
  );

返回：
  array[[3.6, 3.6, 3.6, 3.6]
          ,[3.6, 3.6, 3.6, 3.6]
          ,[3.6, 3.6, 3.6, 3.6]] >>> sm_sc.fv_new_rand |(给定值范围内，)
构造随机矩阵。
参数：
  1. 随机值上限(缺省为 1.0)；
  2. 二维数组高宽规格；|select
  sm_sc.fv_new_rand
  (
    2.0
  , array[3, 2]
  );

返回：
  array[[0.070740982239343, 0.0899943754998205]
          ,[0.629551500745066, 0.369479334510409]
          ,[0.159237183526308, 1.29839220669395]]
--------------------------
select
  sm_sc.fv_new_rand
  (
    -- 1.0, -- 缺省值为 1.0
    array[3, 2]
  );

返回：
  array[[0.070740982239343, 0.0899943754998205]
          ,[0.629551500745066, 0.369479334510409]
          ,[0.159237183526308, 0.29839220669395]] >>> sm_sc.fv_new_rand_enum |构造枚举随机矩阵。
参数：
  1. 原枚举值一维数组；
  2. 二维数组高宽规格；|select
  sm_sc.fv_new_rand_enum
  (
    array['Mon', 'Tue', 'Wed', 'Thu', 'Fri', 'Sat', 'Sun']
  , array[2, 3]
  );

返回：
  array[['Sun', 'Sat', 'Sun ],['Sun', 'Tue', 'Wed']] >>> sm_sc.fv_new_randn |构造正态分布随机矩阵。
参数：
  1. 正态分布均值(期望值)；
  2. 正态分布标准差；
  3. 二维数组高宽规格；|select
  sm_sc.fv_new_randn
  (
    3.6
    , 0.2
    , array[3, 2]
  );

返回：
  array[[3.66170684, 3.40963440]
          ,[3.60093244, 3.51437251]
          ,[3.30444215, 3.35682136]] >>> sm_sc.fv_eye |构造给定序列的对角矩阵。
参数：
  1. 背景元素值；
  2...n. 按序排列的对角元素值，可以是 variadic array；|select
  sm_sc.fv_eye
  (
    1.0
  , variadic array[1.5, 2.3, 5.6]
  );

返回：
  array[[1.5, 1.0, 1.0],[1.0, 2.3, 1.0],[1.0, 1.0, 5.6]]
--------------------------
select
  sm_sc.fv_eye
  (
    1.0, 1.5, 2.3, 5.6
  );

返回：
  array[[1.5, 1.0, 1.0],[1.0, 2.3, 1.0],[1.0, 1.0, 5.6]] >>> sm_sc.fv_eye_arr |给定对角块的构造矩阵。
参数：
  1. 背景元素值(缺省为 0.0)；
  2...n. 对角块矩阵队列；|select
  sm_sc.fv_eye_arr
  (
    array[array[1.2, 2.4], array[11.2, 12.4]]
  , array[array[1.3, 2.6, 1.4, 2.8], array[11.3, 12.6, 11.4, 12.8]]
  , array[array[1.1, 2.2], array[11.1, 12.2], array[21.1, 22.2]]
  );

返回：
  array[[1.2, 2.4, 0.0, 0.0, 0.0, 0.0]
          ,[11.2, 12.4, 0.0, 0.0, 0.0, 0.0]
          ,[0.0, 0.0, 1.3, 2.6, 1.4, 2.8]
          ,[0.0, 0.0, 11.3, 12.6, 11.4, 12.8]
          ,[0.0, 0.0, 0.0, 0.0, 1.1, 2.2]
          ,[0.0, 0.0, 0.0, 0.0, 11.1, 12.2]
          ,[0.0, 0.0, 0.0, 0.0, 21.1, 22.2]]
--------------------------
select
  sm_sc.fv_eye_arr
  (
    1.0,
    array[array[1.2, 2.4], array[11.2, 12.4]]
  , array[array[1.3, 2.6, 1.4, 2.8], array[11.3, 12.6, 11.4, 12.8]]
  , array[array[1.1, 2.2], array[11.1, 12.2], array[21.1, 22.2]]
  );

返回：
  array[[1.2, 2.4, 1.0, 1.0, 1.0, 1.0]
          ,[11.2, 12.4, 1.0, 1.0, 1.0, 1.0]
          ,[1.0, 1.0, 1.3, 2.6, 1.4, 2.8]
          ,[1.0, 1.0, 11.3, 12.6, 11.4, 12.8]
          ,[1.0, 1.0, 1.0, 1.0, 1.1, 2.2]
          ,[1.0, 1.0, 1.0, 1.0, 11.1, 12.2]
          ,[1.0, 1.0, 1.0, 1.0, 21.1, 22.2]] >>> sm_sc.fv_eye_unit |构造(给定值的)对角矩阵。
参数：
  1. 对角元素值(缺省为 0.0)；
  2. 对角矩阵高宽规格；|select
  sm_sc.fv_eye_unit
  (
    3.6
  , 3
  );

返回：
  array[[3.6, 0, 0],[0, 3.6, 0],[0, 0, 3.6]]
--------------------------
select
  sm_sc.fv_eye_unit
  (
    -- 1.0, -- 缺省值为 1.0
    3
  );

返回：
  array[[1.0, 0, 0],[0, 1.0, 0],[0, 0, 1.0]] >>> sm_sc.fv_augmented |二维数组填值增广或切块。
参数：
  1. 原二维数组；
  2. 增广或切块的左上角在原矩阵的坐标；
  3. 增广或切块的高宽规格；
  4. 增广区域背景元素填值；|select
  sm_sc.fv_augmented
  (
    array[[1, 2, 3, 4, 5]
            ,[6, 7, 8, 9, 10]
            ,[11, 12, 13, 14, 15]
            ,[16, 17, 18, 19, 20]
            ,[21, 22, 23, 24, 25]]
  , array[2, -1]
  , array[8, 4]
  , 0
  );

返回：
  array[[0, 0, 6, 7, 8, 9]
          ,[0, 0, 11, 12, 13, 14]
          ,[0, 0, 16, 17, 18, 19]
          ,[0, 0, 21, 22, 23, 24]
          ,[0, 0, 0, 0, 0, 0]
          ,[0, 0, 0, 0, 0, 0]
          ,[0, 0, 0, 0, 0, 0]] >>> sm_sc.fv_array_1d_set_ele |对一维数组定位赋值，
支持指定负数或零的位置编号。
参数：
  1. 原一维数组；
  2. 位置编号或位置编号范围；
  3. 赋值或赋为给定数组； |select
  sm_sc.fv_array_1d_set_ele
  (
    array[1, 2, 3, 4]
  , -2
  , 5
  );

返回：
  array[1, 2, 5, 4]
--------------------------
select
  sm_sc.fv_array_1d_set_ele
  (
    array[1, 2, 3, 4]
  , 4
  , array[5, 6, 7]
  );

返回：
  array[1, 2, 3, 5, 6, 7]
--------------------------
select
  sm_sc.fv_array_1d_set_ele
  (
    array[1, 2, 3, 4]
  , int4range(1, 2, '[]')
  , array[5, 6, 7]
  );

返回：
  array[5, 6, 7, 3, 4]
--------------------------
select
  sm_sc.fv_array_1d_set_ele
  (
    array[1, 2, 3, 4]
  , -2
  , 5
  );

返回：
  array[1, 2, 5, 4] >>> sm_sc.fv_rand_1d_ele |随机组合，序号可重复。
参数：
  1. 总体数量；
  2. 抽样数量；|select
  sm_sc.fv_rand_1d_ele
  (
    8
  , 5
  );

返回：
  array[1, 1, 7, 3, 7] >>> sm_sc.fv_rand_1d_ele_pick |随机组合，序号不重复。
参数：
  1. 总体数量；
  2. 抽样数量；|select
  sm_sc.fv_rand_1d_ele_pick
  (
    8
  , 5
  );

返回：
  array[3, 6, 1, 7, 5] >>> sm_sc.ft_rand_slice_y |二维数组y方向随机获取切片行，
元素序号可重复。
入参：
  1. 原矩阵；
  2. 抽样数量；
出参列：
  1. 抽到的样本编号；
  2. 抽样切片组成的新矩阵；|select
  o_ord_nos, o_slices
from
  sm_sc.ft_rand_slice_y
  (
    array[[1.0, 2.0],[3.0, 4.0],[5.0, 6.0]
            ,[7.0, 8.0],[9.0, 10.0],[11.0, 12.0]]
  , 3
  );

返回：
  o_ord_nos:
    array[6, 2, 6]
  o_slices:
    array[[11.0, 12.0],[3.0, 4.0],[11.0, 12.0]] >>> sm_sc.ft_rand_slice_y_pick |二维数组y方向随机拣取切片行，
元素序号不重复。
入参：
  1. 原矩阵；
  2. 抽样数量；
出参列：
  1. 抽到的样本编号；
  2. 抽样切片组成的新矩阵；|select
  o_ord_nos, o_slices
from
  sm_sc.ft_rand_slice_y_pick
  (
    array[[1.0, 2.0],[3.0, 4.0],[5.0, 6.0]
            ,[7.0, 8.0],[9.0, 10.0],[11.0, 12.0]]
  , 3
  );

返回：
  o_ord_nos:
    array[6, 2, 6]
  o_slices:
    array[[5.0, 6.0],[3.0, 4.0],[11.0, 12.0]] >>> sm_sc.ft_rand_slice_x |二维数组x方向随机获取切片列，
元素序号可重复。
入参：
  1. 原矩阵；
  2. 抽样数量；
出参列：
  1. 抽到的样本编号；
  2. 抽样切片组成的新矩阵；|select
  o_ord_nos, o_slices
from
  sm_sc.ft_rand_slice_x
  (
    array[[1.0, 2.0, 3.0, 4.0, 5.0, 6.0]
            ,[7.0, 8.0, 9.0, 10.0, 11.0, 12.0]]
  , 3
  );

返回：
  o_ord_nos:
    array[1, 4, 1]
  o_slices:
    array[[1.0, 4.0, 1.0],[7.0, 10.0, 7.0]] >>> sm_sc.ft_rand_slice_x_pick |二维数组x方向随机拣取切片列，
元素序号不重复。
入参：
  1. 原矩阵；
  2. 抽样数量；
出参列：
  1. 抽到的样本编号；
  2. 抽样切片组成的新矩阵；|select
  o_ord_nos, o_slices
from
  sm_sc.ft_rand_slice_x_pick
  (
    array[[1.0, 2.0, 3.0, 4.0, 5.0, 6.0]
            ,[7.0, 8.0, 9.0, 10.0, 11.0, 12.0]]
  , 3
  );

返回：
  o_ord_nos:
    array[4, 5, 3]
  o_slices:
    array[[4.0, 5.0, 3.0],[10.0, 11.0, 9.0]] >>> sm_sc.ft_rand_ele_y |二维数组y方向每行获取指定个数随机元素，
行数不变，元素序号可重复。
入参：
  1. 原矩阵；
  2. 抽样数量；
出参列：
  1. 抽到的样本编号；
  2. 抽样切片组成的新矩阵；|select
  o_ord_nos, o_slices
from
  sm_sc.ft_rand_ele_y
  (
    array[[1.0, 2.0, 3.0, 4.0, 5.0, 6.0]
            ,[7.0, 8.0, 9.0, 10.0, 11.0, 12.0]]
  , 3
  );

返回：
  o_ord_nos:
    array[[4, 5, 5],[4, 4, 3]]
  o_slices:
    array[[4.0, 5.0, 5.0],[10.0, 10.0, 9.0]] >>> sm_sc.ft_rand_ele_y_pick |二维数组y方向每行拣取指定个数随机元素，
行数不变，元素序号不重复。
入参：
  1. 原矩阵；
  2. 抽样数量；
出参列：
  1. 抽到的样本编号；
  2. 抽样切片组成的新矩阵；|select
  o_ord_nos, o_slices
from
  sm_sc.ft_rand_ele_y_pick
  (
    array[[1.0, 2.0, 3.0, 4.0, 5.0, 6.0]
            ,[7.0, 8.0, 9.0, 10.0, 11.0, 12.0]]
  , 3
  );

返回：
  o_ord_nos:
    array[[6, 2, 4],[3, 1, 5]]
  o_slices:
    array[[6.0, 2.0, 4.0],[9.0, 7.0, 11.0]] >>> sm_sc.ft_rand_ele_x |二维数组x方向每列获取指定个数随机元素，
列数不变，元素序号可重复。
入参：
  1. 原矩阵；
  2. 抽样数量；
出参列：
  1. 抽到的样本编号；
  2. 抽样切片组成的新矩阵；|select
  o_ord_nos, o_slices
from
  sm_sc.ft_rand_ele_x
  (
    array[[1.0, 2.0],[3.0, 4.0],[5.0, 6.0]
            ,[7.0, 8.0],[9.0, 10.0],[11.0, 12.0]]
  , 3
  );

返回：
  o_ord_nos:
    array[[3, 2],[3, 1],[4, 3]]
  o_slices:
    array[[5.0, 4.0],[5.0, 2.0],[7.0, 6.0]] >>> sm_sc.ft_rand_ele_x_pick |二维数组x方向每列拣取指定个数随机元素，
列数不变，元素序号不重复。
入参：
  1. 原矩阵；
  2. 抽样数量；
出参列：
  1. 抽到的样本编号；
  2. 抽样切片组成的新矩阵；|select
  o_ord_nos, o_slices
from
  sm_sc.ft_rand_ele_x_pick
  (
    array[[1.0, 2.0],[3.0, 4.0],[5.0, 6.0]
            ,[7.0, 8.0],[9.0, 10.0],[11.0, 12.0]]
  , 3
  );

返回：
  o_ord_nos:
    array[[3, 4],[5, 1],[4, 3]]
  o_slices:
    array[[5.0, 8.0],[9.0, 2.0],[7.0, 6.0]] >>> sm_sc.fv_sample_y |y方向间隔采样。
入参：
  1. 原矩阵；
  2. 采样周期；
  3. 采样窗口约束。
      null 值表示不约束；
  4. 采样范围。
      队列支持多个范围；
  5. 升采样填充值阵。缺省为 null；
      超过窗口约束的采样范围，填充该值阵；|select
  sm_sc.fv_sample_y
  (
    array[[1, 2],[3, 4],[5, 6],[7, 8],[9, 10],[11, 12]]
  , 3
  , 3
  , array[int4range(1,2, '[]'), int4range(2,4, '[]')]
  , array[array[13, 14], array[15, 16]]
  );

返回：
  array[[1, 2],[3, 4],[3, 4],[5, 6],[13, 14],[15, 16]
          ,[7, 8],[9, 10],[9, 10],[11, 12],[13, 14],[15, 16]] >>> sm_sc.fv_sample_x |x方向间隔采样。
入参：
  1. 原矩阵；
  2. 采样周期；
  3. 采样窗口约束。
      null 值表示不约束；
  4. 采样范围。
      队列支持多个范围；
  5. 升采样填充值阵。缺省为 null；
      超过窗口约束的采样范围，填充该值阵；|select
  sm_sc.fv_sample_x
  (
    array[[1, 2, 3, 4, 5, 6],[7, 8, 9, 10, 11, 12]]
  , 3
  , 2
  , array[int4range(1,2, '[]'), int4range(2,4, '[]')]
  , array[array[13, 14], array[15, 16]]
  );

返回：
  array[[1, 2, 2, 13, 14, 13, 14, 4, 5, 5, 13, 14, 13, 14]
          ,[7, 8, 8, 15, 16, 15, 16, 10, 11, 11, 15, 16, 15, 16]] >>> sm_sc.fv_ele_replace |指定元素值替换为另外指定元素值。
入参：
  1. 原矩阵；
  2. 被替换的一个或多个元素值；
  3. 新元素值；|select
  sm_sc.fv_ele_replace
  (
    array[[12.3, 25.1],[3.25, 6.1]]
  , array[12.3, 3.25]
  , 1.0
  );

返回：
  array[[1.0, 25.1],[1.0, 6.1]] >>> sm_sc.fv_area_replace |指定位置区域替换切片或切块。
入参：
  1. 原矩阵；
  2. 被替换块在元矩阵的起始位置；
  3. 替换块矩阵；|select
  sm_sc.fv_area_replace
  (
    array[['a', 'b', 'c'],['e', 'f', 'g'],['h', 'i', 'j'],['x', 'y', 'z']]
  , array[3, 2]
  , array[['m', 'n'],['p', 'q']]
  );

返回：
  array[['a', 'b', 'c'],['e', 'f', 'g'],['h', 'm', 'n'],['x', 'p', 'q']] >>> sm_sc.fv_pos_replaces |指定若干位置替换为指定元素值。
入参：
  1. 原矩阵；
  2. 被替换位置清单；
  3. 新元素值；|select
  sm_sc.fv_area_replace
  (
    array[['a', 'b', 'c'],['e', 'f', 'g']]
  , array[[1, 3],[2, 2]]
  , 'd'
  );

返回：
  array[['a', 'b', 'd'],['e', 'd', 'g']] >>> sm_sc.fv_regexp_matches |文本矩阵元素值正则匹配。
入参：
  1. 原文本矩阵；
  2. 正则表达式；
  3. 正则表达式选项标记。缺省为 'g'；|select
  sm_sc.fv_regexp_matches
  (
    array[['abbbbbc122223', 'abc123adc'],['abc123', 'ac13']]
  , array['a.c']
  , 'gi'
  );

返回：
  array[[null, '"{{abc},{adc}}"'],['"{{abc}}"', null]] >>> sm_sc.fv_regexp_replace |文本矩阵元素值正则替换。
入参：
  1. 原文本矩阵；
  2. 正则表达式；
  3. 替换新文本；
  4. 正则表达式选项标记。缺省为 'g'；|select
  sm_sc.fv_regexp_replace
  (
    array[['abbbbbc122223', 'abc123adc'],['abc123', 'ac13']]
  , array[array['a.c'], array['1.*?3']]
  , 'fff'
  , 'gi'
  );

返回：
  array[['abbbbbc122223', 'fff123fff'],['abcfff', 'acfff']] >>> sm_sc.fv_nullif |元素避值。
入参：
  1. 原矩阵；
  2. 回避敏感值矩阵；|select
  sm_sc.fv_nullif
  (
    array[[12.3, -12.3],[45.6, -45.6]]
  , array[[12.3],[-45.6]]
  );

返回：
  array[[null,-12.3],[45.6,null]] >>> sm_sc.fv_coalesce
sm_sc.fv_coalesce_variadic|元素免空。
  sm_sc.fv_coalesce 入参：
    1. 优先首个非空元素获取；
    2. 次优先首个非空元素获取；
  sm_sc.fv_coalesce_variadic 入参：
    1...n. 依次序首个非空元素获取；|select
  sm_sc.fv_coalesce
  (
    array[null, 2.4, 5.6, 52.3]
  , array[1.2, 2.3, null, 52.1]
  );

返回：
  array[[],[]]
--------------------------
select
  sm_sc.fv_coalesce
  (variadic
    array[[null, 2.4, 5.6, 52.3]
            ,[null, 2.3, null, 52.1]
            ,[1.2, 2.8, null, null]]
  );

返回：
  array[{1.2, 2.4, 5.6, 52.3}] >>> sm_sc.fv_lpad |右对齐左填充，
超出长度部分截断。
入参：
  1. 原矩阵；
  2. 扩展填充的对齐长度；
  3. 填充值或值阵；|select
  sm_sc.fv_lpad
  (
    array[[1, 2, 3, 4, 5, 6],[-1, -2, -3, -4, -5, -6]]
  , 9
  , array[[7],[8]]
  );

返回：
  array[[7, 7, 7, 1, 2, 3, 4, 5, 6]
          ,[8, 8, 8, -1, -2, -3, -4, -5, -6]] >>> sm_sc.fv_rpad |左对齐右填充，
超出长度部分截断。
入参：
  1. 原矩阵；
  2. 扩展填充的对齐长度；
  3. 填充值或值阵；|select
  sm_sc.fv_rpad
  (
    array[[1, 2, 3, 4, 5, 6],[-1, -2, -3, -4, -5, -6]]
  , 9
  , array[[7],[8]]
  );

返回：
  array[[1, 2, 3, 4, 5, 6, 7, 7, 7]
          ,[-1, -2, -3, -4, -5, -6, 8, 8, 8]] >>> sm_sc.fv_apad |下对齐上填充，
超出长度部分截断。
入参：
  1. 原矩阵；
  2. 扩展填充的对齐长度；
  3. 填充值或值阵；|select
  sm_sc.fv_apad
  (
    array[[1, 2, 3, 4, 5, 6],[-1, -2, -3, -4, -5, -6]]
  , 9
  , array[[7],[8]]
  );

返回：
  array[[7, 7, 7, 7, 7, 7]
          ,[8, 8, 8, 8, 8, 8]
          ,[7, 7, 7, 7, 7, 7]
          ,[1, 2, 3, 4, 5, 6]
          ,[-1, -2, -3, -4, -5, -6]] >>> sm_sc.fv_bpad |上对齐下填充，
超出长度部分截断。
入参：
  1. 原矩阵；
  2. 扩展填充的对齐长度；
  3. 填充值或值阵；|select
  sm_sc.fv_bpad
  (
    array[[1, 2, 3, 4, 5, 6],[-1, -2, -3, -4, -5, -6]]
  , 9
  , array[[7],[8]]
  );

返回：
  array[[1, 2, 3, 4, 5, 6]
          ,[-1, -2, -3, -4, -5, -6]
          ,[7, 7, 7, 7, 7, 7]
          ,[8, 8, 8, 8, 8, 8]
          ,[7, 7, 7, 7, 7, 7]] >>> sm_sc.fv_trim |上下左右消去某元素值置空。
入参：
  1. 原矩阵；
  2. 被端头置空的元素值|select
  sm_sc.fv_trim
  (
    array[[2, 0, 0, 0, 0, 0]
            ,[1, 2, 0, 4, 0, 0]
            ,[0, 0, 1, 0, 2, 0]
            ,[0, 1, 2, 2, 0, 0]
            ,[1, 0, 1, 0, 0, 3]]
  , 0
  );

返回：
  array[[2, null, null, null, null, null]
          ,[1, 2, null, 4, null, null]
          ,[null, null, 1, 0, 2, null]
          ,[null, 1, 2, 2, null, null]
          ,[1, null, 1, null, null, 3]] >>> sm_sc.fv_ltrim |左消去某元素值置空。
入参：
  1. 原矩阵；
  2. 被端头置空的元素值|select
  sm_sc.fv_ltrim
  (
    array[[0, 1, 2, 3, 4, 5]
            ,[0, 0, 1, 2, 0, 4]
            ,[0, 0, 0, 1, 2, 3]
            ,[0, 0, 0, 0, 1, 2]
            ,[0, 0, 1, 0, 0, 3]]
  , 0
  );

返回：
  array[[null, 1, 2, 3, 4, 5]
          ,[null, null, 1, 2, 0, 4]
          ,[null, null, null, 1, 2, 3]
          ,[null, null, null, null, 1, 2]
          ,[null, null, 1, 0, 0, 3]] >>> sm_sc.fv_rtrim |右消去某元素值置空。
入参：
  1. 原矩阵；
  2. 被端头置空的元素值|select
  sm_sc.fv_rtrim
  (
    array[[0, 1, 2, 3, 4, 5, 0]
            ,[4, 0, 0, 1, 2, 0, 0]
            ,[0, 1, 2, 3, 0, 0, 0]
            ,[0, 1, 2, 0, 0, 0, 0]
            ,[0, 0, 1, 0, 0, 3, 0]]
  , 0
  );

返回：
  array[[0, 1, 2, 3, 4, 5, NULL]
          ,[4, 0, 0, 1, 2, NULL, NULL]
          ,[0, 1, 2, 3, NULL, NULL, NULL]
          ,[0, 1, 2, NULL, NULL, NULL, NULL]
          ,[0, 0, 1, 0, 0, 3, NULL]] >>> sm_sc.fv_atrim |上消去某元素值置空。
入参：
  1. 原矩阵；
  2. 被端头置空的元素值|select
  sm_sc.fv_atrim
  (
    array[[0, 0, 0, 0, 0, 2]
            ,[0, 0, 1, 2, 0, 4]
            ,[0, 1, 0, 2, 0, 0]
            ,[0, 0, 0, 0, 1, 2]
            ,[1, 0, 1, 0, 0, 3]]
  , 0
  );

返回：
  array[[NULL, NULL, NULL, NULL, NULL, 2]
          ,[NULL, NULL, 1, 2, NULL, 4]
          ,[NULL, 1, 0, 2, NULL, 0]
          ,[NULL, 0, 0, 0, 1, 2]
          ,[1, 0, 1, 0, 0, 3]] >>> sm_sc.fv_btrim |下消去某元素值置空。
入参：
  1. 原矩阵；
  2. 被端头置空的元素值|select
  sm_sc.fv_btrim
  (
    array[[2, 0, 0, 0, 0, 0]
            ,[1, 2, 0, 4, 0, 0]
            ,[0, 0, 1, 0, 2, 0]
            ,[0, 1, 2, 0, 0, 0]
            ,[1, 0, 1, 0, 0, 3]]
  , 0
  );

返回：
  array[[2, 0, 0, 0, 0, 0]
          ,[1, 2, 0, 4, 0, 0]
          ,[0, 0, 1, NULL, 2, 0]
          ,[0, 1, 2, NULL, NULL, 0]
          ,[1, NULL, 1, NULL, NULL, 3]] >> >>#### d. 矩阵的三角函数广播运算： >> >>> 函数名|函数说明|调用举例 >>> :-|:-|:- >>> sm_sc.fv_degrees |点(广播)弧度转角度。
入参：
  1. 原弧度矩阵； |select
  sm_sc.fv_degrees
  (
    array[[12.64, -12.64],[3.16, -3.16],[0.1, -0.1]]
  );

返回：
  array[[724.2187, -724.2187],[181.0547, -181.0547],[5.7296, -5.7296]] >>> sm_sc.fv_radians |点(广播)角度转弧度。
入参：
  1. 原角度矩阵； |select
  sm_sc.fv_radians
  (
    array[[89, -90],[181, -270],[0, -360.1]]
  );

返回：
  array[[1.5533, -1.5708],[3.1590, -4.7124],[0, -6.2849]] >>> sm_sc.fv_sin |点(广播)弧度正弦。
入参：
  1. 原弧度矩阵； |select
  sm_sc.fv_sin
  (
    array[[pi(), -pi()],[pi() / 2, pi() / 4]]::double precision[]
  );

返回：
  array[[1.5533, -1.5708],[3.1590, -4.7124],[0, -6.2849]] >>> sm_sc.fv_cos |点(广播)弧度余弦。
入参：
  1. 原弧度矩阵； |select
  sm_sc.fv_cos
  (
    array[[pi(), -pi()],[pi() / 2, pi() / 4]]::double precision[]
  );

返回：
  array[[-1, -1],[0, 0.7071]] >>> sm_sc.fv_tan |点(广播)弧度正切。
入参：
  1. 原弧度矩阵； |select
  sm_sc.fv_tan
  (
    array[[pi(), -pi()],[pi() / 2, pi() / 4]]::double precision[]
  );

返回：
  array[[0, 0],[1.6331e+16, 1]] >>> sm_sc.fv_cot |点(广播)弧度余切。
入参：
  1. 原弧度矩阵； |select
  sm_sc.fv_cot
  (
    array[[pi(), -pi()],[pi() / 2, pi() / 4]]::double precision[]
  );

返回：
  array[[-8.1656e+15, 8.1656e+15],[0, 1]] >>> sm_sc.fv_sind |点(广播)角度正弦。
入参：
  1. 原角度矩阵； |select
  sm_sc.fv_sind
  (
    array[[180, -180],[90, 45]]::double precision[]
  );

返回：
  array[[0, -0],[1, 0.7071]] >>> sm_sc.fv_cosd |点(广播)角度余弦。
入参：
  1. 原角度矩阵； |select
  sm_sc.fv_cosd
  (
    array[[180, -180],[90, 45]]::double precision[]
  );

返回：
  array[[-1, -1],[1, 0.7071]] >>> sm_sc.fv_tand |点(广播)角度正切。
入参：
  1. 原角度矩阵； |select
  sm_sc.fv_tand
  (
    array[[180, -180],[90, 45]]::double precision[]
  );

返回：
  array[[0, 0],[Infinity, 1]] >>> sm_sc.fv_cotd |点(广播)角度余切。
入参：
  1. 原角度矩阵； |select
  sm_sc.fv_cotd
  (
    array[[180, -180],[90, 45]]::double precision[]
  );

返回：
  array[[-Infinity, Infinity],[0, 1]] >>> sm_sc.fv_asin |点(广播)弧度反正弦。
入参：
  1. 原弧度矩阵； |select
  sm_sc.fv_asin
  (
    array[[1, -1],[0.5, 0.25]]::double precision[]
  );

返回：
  array[[1.5708, -1.5708],[0.5236, 0.2527]] >>> sm_sc.fv_acos |点(广播)弧度反余弦。
入参：
  1. 原弧度矩阵； |select
  sm_sc.fv_acos
  (
    array[[1, -1],[0.5, 0.25]]::double precision[]
  );

返回：
  array[[0, 3.1416],[1.0472, 1.3181]] >>> sm_sc.fv_atan |点(广播)弧度反正切。
入参：
  1. 原弧度矩阵； |select
  sm_sc.fv_atan
  (
    array[[1, -1],[0.5, 0.25]]::double precision[]
  );

返回：
  array[[0.7854, -0.7854],[0.4636, 0.2450]] >>> sm_sc.fv_asind |点(广播)角度反正弦。
入参：
  1. 原角度矩阵； |select
  sm_sc.fv_asind
  (
    array[[pi(), -pi()],[pi() / 2, pi() / 4]]::double precision[]
  );

返回：
  array[[90, -90],[30, 14.4775]] >>> sm_sc.fv_acosd |点(广播)角度反余弦。
入参：
  1. 原角度矩阵； |select
  sm_sc.fv_acosd
  (
    array[[pi(), -pi()],[pi() / 2, pi() / 4]]::double precision[]
  );

返回：
  array[[0, 180],[60, 75.5225]] >>> sm_sc.fv_atand |点(广播)角度反正切。
入参：
  1. 原角度矩阵； |select
  sm_sc.fv_atand
  (
    array[[1, -1],[1.0 / 2, 1.0 / 4],['-Infinity', 'Infinity']]::double precision[]
  );

返回：
  array[[45, -45],[26.5651, 14.0362],[-90, 90]] >>> sm_sc.fv_sinh |点(广播)双曲正弦。
入参：
  1. 原矩阵； |select
  sm_sc.fv_sinh
  (
    array[[pi(), -pi()],[pi() / 2, pi() / 4]]::double precision[]
  );

返回：
  array[[11.5487, -11.5487],[2.3013, 0.8687]] >>> sm_sc.fv_cosh |点(广播)双曲余弦。
入参：
  1. 原矩阵； |select
  sm_sc.fv_cosh
  (
    array[[pi(), -pi()],[pi() / 2, pi() / 4]]::double precision[]
  );

返回：
  array[[11.5920, 11.5920],[2.5092, 1.3246]] >>> sm_sc.fv_tanh |点(广播)双曲正切。
入参：
  1. 原矩阵； |select
  sm_sc.fv_tanh
  (
    array[[pi(), -pi()],[pi() / 2, pi() / 4]]::double precision[]
  );

返回：
  array[[0.9963, -0.9963],[0.9176, 0.6558]] >>> sm_sc.fv_asinh |点(广播)反双曲正弦。
入参：
  1. 原矩阵； |select
  sm_sc.fv_asinh
  (
    array[[1, -1],[0.5, 0.25],['-Infinity', 'Infinity']]::double precision[]
  );

返回：
  array[[0.8814, -0.8814],[0.4812, 0.2475],[-Infinity,Infinity]] >>> sm_sc.fv_acosh |点(广播)反双曲余弦。
入参：
  1. 原矩阵； |select
  sm_sc.fv_acosh
  (
    array[[1.2, 1.3],[1.5, 1.25],[1.0, 'Infinity']]::double precision[]
  );

返回：
  array[[0.6224, 0.7564],[0.9624, 0.6931],[0,Infinity]] >>> sm_sc.fv_atanh |点(广播)反双曲正切。
入参：
  1. 原矩阵； |select
  sm_sc.fv_atanh
  (
    array[[1, -1],[0.5, 0.25]]::double precision[]
  );

返回：
  array[[Infinity, -Infinity],[0.5493, 0.2554]] >> >>#### e. 波形处理： >> >>> 函数名|函数说明|调用举例 >>> :-|:-|:- >>> sm_sc.fv_grad_y_1st |矩阵y方向一阶差分。
输出高度比输入长度小1。
入参：
  1. 原矩阵； |select
  sm_sc.fv_grad_y_1st
  (
    array[[1, 2, 3, 4],[-1, -2, -3, -4],[-3, -2, -4, -1]]
  );

返回：
  array[[-2, -4, -6, -8],[-2, 0, -1, 3]] >>> sm_sc.fv_grad_y_2nd |矩阵y方向二阶差分。
输出高度比输入长度小2。
入参：
  1. 原矩阵； |select
  sm_sc.fv_grad_y_2nd
  (
    array[[1, 2, 3, 4],[-1, -2, -3, -4],[-3, -2, -4, -1]]
  );

返回：
  array[[0, 4, 5, 11]] >>> sm_sc.fv_grad_x_1st |矩阵x方向一阶差分。
输出长度比输入长度小1。
入参：
  1. 原矩阵； |select
  sm_sc.fv_grad_x_1st
  (
    array[[1, 2, 3, 4],[-1, -2, -3, -4],[-3, -2, -4, -1]]
  );

返回：
  array[[1, 1, 1],[-1, -1, -1],[1, -2, 3]] >>> sm_sc.fv_grad_x_2nd |矩阵x方向二阶差分。
输出长度比输入长度小2。
入参：
  1. 原矩阵； |select
  sm_sc.fv_grad_x_2nd
  (
    array[[1, 2, 3, 4],[-1, -2, -3, -4],[-3, -2, -4, -1]]
  );

返回：
  array[[0, 0],[-3, 5]] >>> sm_sc.fv_sgn_fft |一维快速傅里叶变换。
输出长度为2的整数幂。
入参：
  1. 原时域序列； |select
  sm_sc.fv_sgn_fft
  (
    array
    [
       1. , 0.97952994, 0.91895781, 0.82076344, 0.68896692, 0.52896401,
       0.34730525, 0.15142778, -0.05064917, -0.25065253, -0.44039415, -0.61210598,
       -0.75875812, -0.87434662, -0.95413926, -0.99486932, -0.99486932, -0.95413926,
       -0.87434662, -0.75875812, -0.61210598, -0.44039415, -0.25065253, -0.05064917,
       0.15142778, 0.34730525, 0.52896401, 0.68896692, 0.82076344, 0.91895781,
       0.97952994, 1.
    ]
  );

返回复数类型数组(sm_sc.typ_l_complex[])：
  array
  [
    1.00000000e+00+0.00000000e+00j, 1.61497357e+01+1.59061014e+00j,
    -3.53833224e-01-7.03818042e-02j, -1.26604779e-01-3.84051399e-02j,
    -6.41365736e-02-2.65662386e-02j, -3.75538211e-02-2.00729356e-02j,
    -2.37109631e-02-1.58431590e-02j, -1.55930224e-02-1.27968628e-02j,
    -1.04489194e-02-1.04489194e-02j, -7.01356383e-03-8.54605226e-03j,
    -4.63822579e-03-6.94159545e-03j, -2.96316279e-03-5.54368767e-03j,
    -1.77736596e-03-4.29094101e-03j, -9.52464878e-04-3.13985591e-03j,
    -4.09315616e-04-2.05776856e-03j, -1.00322243e-04-1.01858882e-03j,
     2.22044605e-16+0.00000000e+00j, -1.00322243e-04+1.01858882e-03j,
    -4.09315616e-04+2.05776856e-03j, -9.52464878e-04+3.13985591e-03j,
    -1.77736596e-03+4.29094101e-03j, -2.96316279e-03+5.54368767e-03j,
    -4.63822579e-03+6.94159545e-03j, -7.01356383e-03+8.54605226e-03j,
    -1.04489194e-02+1.04489194e-02j, -1.55930224e-02+1.27968628e-02j,
    -2.37109631e-02+1.58431590e-02j, -3.75538211e-02+2.00729356e-02j,
    -6.41365736e-02+2.65662386e-02j, -1.26604779e-01+3.84051399e-02j,
    -3.53833224e-01+7.03818042e-02j, 1.61497357e+01-1.59061014e+00j
  ] >>> sm_sc.fv_sgn_ifft |一维快速傅里叶逆变换。
输出长度为2的整数幂。
入参：
  1. 原频域序列； |select
  sm_sc.fv_sgn_ifft
  (
    array
    [
       1. , 0.97952994, 0.91895781, 0.82076344, 0.68896692, 0.52896401,
       0.34730525, 0.15142778, -0.05064917, -0.25065253, -0.44039415, -0.61210598,
       -0.75875812, -0.87434662, -0.95413926, -0.99486932, -0.99486932, -0.95413926,
       -0.87434662, -0.75875812, -0.61210598, -0.44039415, -0.25065253, -0.05064917,
       0.15142778, 0.34730525, 0.52896401, 0.68896692, 0.82076344, 0.91895781,
       0.97952994, 1.
    ]
  );

返回复数类型数组(sm_sc.typ_l_complex[])：
  array
  [
    -0.00014495-0.00021693j, -0.00009260-0.00017324j,
    -0.00005554-0.00013409j, -0.00002977-0.00009812j,
    -0.00001279-0.00006431j, -0.00000314-0.00003183j,
    0.00000000+0.00000000j , -0.00000314+0.00003183j,
    -0.00001279+0.00006431j, -0.00002977+0.00009812j,
    -0.00005554+0.00013409j, -0.00009260+0.00017324j,
    -0.00014495+0.00021693j, -0.00021917+0.00026707j,
    -0.00032653+0.00032653j, -0.00048729+0.00039991j,
    -0.00074097+0.00049510j, -0.00117356+0.00062728j,
    -0.00200427+0.00083020j, -0.00395641+0.00120017j,
    -0.01105730+0.00219944j, 0.50467924-0.04970657j
  ] >>> sm_sc.fv_sgn_fft2 |二维快速傅里叶变换。
输出高宽为2的整数幂。
入参：
  1. 原时域序列； |select
  sm_sc.fv_sgn_fft2
  (
    array[[1, 2, 3, 4],[4, 5, 6, 7],[8, 9, 10, 11]]
  );

返回：
  array[[70.0+0.0j, -6.0-6.0j, -6.0+0.0j, -6.0+6.0j]
          ,[-28.0+22.0j, 2.0-2.0j, 0.0-2.0j, -2.0-2.0j]
          ,[26.0+0.0j, -2.0-2.0j, -2.0+0.0j, -2.0+2.0j]
          ,[-28.0-22.0j, -2.0+2.0j, 0.0+2.0j, 2.0+2.0j]] >>> sm_sc.fv_sgn_ifft2 |二维快速傅里叶逆变换。
输出高宽为2的整数幂。
入参：
  1. 原频域序列； |select
  sm_sc.fv_sgn_ifft2
  (
    array[[1, 2, 3, 4],[4, 5, 6, 7],[8, 9, 10, 11]]
  );

返回：
  array[[4.3750+0.0000j, -0.3750+0.3750j, -0.3750+0.0000j, -0.3750-0.3750j]
          ,[-1.7500-1.3750j, 0.1250+0.1250j, 0.0000+0.1250j, -0.1250+0.1250j]
          ,[1.6250+0.0000j, -0.1250+0.1250j, -0.1250+0.0000j, -0.1250-0.1250j]
          ,[-1.7500+1.3750j, -0.1250-0.1250j, 0.0000-0.1250j, 0.1250-0.1250j]] >>> sm_sc.fv_sgn_kalman |卡尔曼滤波变换。
输出序列比输入序列长度大1。
入参：
  1. 原时域序列； |
-- create extension tablefunc;
with
-- 构造精确序列
cte_ods as
(
   select
     row_number() over() as row_no,
     a_x,
     10 * sin(a_x) :: float as ods_ele
   from generate_series(0.0::float, pi()::float, (pi() / 100)::float) tb_a(a_x)
)
,
-- 构造误差序列
cte_test as
(
   select
     row_no,
     ods_ele + normal_rand(1, 0.0, 0.5) :: float as test_ele -- 假定观测误差标准差 0.5
   from cte_ods
)
,
-- 执行卡尔曼滤波
cte_predict as
(
   select
     sm_sc.fv_sgn_kalman
     (
       array_agg(test_ele order by row_no),
       0.4 * 0.4 , -- 假定过程误差标准差 0.4
       0.5 * 0.5 , -- 假定观测误差标准差 0.5
       0.5 * 0.5
     ) as predict_arr
   from cte_test
)
-- 对比结果
select
   a_x, a_ods_ele, a_test_ele, a_predict_ele
   -- sum(abs(a_test_ele - a_ods_ele) - abs(a_predict_ele - a_ods_ele))
from unnest
(
   (select array_agg(a_x) from cte_ods),
   (select array_agg(ods_ele) from cte_ods),
   (select array_agg(test_ele) from cte_test),
   (select predict_arr from cte_predict)
)  tb_a(a_x, a_ods_ele, a_test_ele, a_predict_ele)

返回：
    a_x              a_ods_ele   a_test_ele     a_predict_ele
    0.00000000 0.00000000 -0.07238570 -0.07238570
    0.03141593 0.31410760 0.06269807 0.01152998
    0.06283186 0.62790530 0.90212888 0.50826981
    0.09424779 0.94108320 1.73031760 1.17427501
    0.12566372 1.25333250 0.59666534 0.86101867
    0.15707965 1.56434480 1.01786649 0.94599484
    0.18849558 1.87381340 2.09580312 1.56879714
    0.21991151 2.18143270 2.11825104 1.86639946
    0.25132744 2.48689910 2.55075390 2.23706481
    0.28274337 2.78991140 2.60066296 2.43399926
    0.31415930 3.09017030 2.45377347 2.44470949
    0.34557523 3.38737960 3.72143761 3.13621913
    0.37699116 3.68124590 2.99812719 3.06142489
    0.40840709 3.97147930 3.42792734 3.25993228
    0.43982302 4.25779340 4.31830536 3.83317505
    0.47123895 4.53990550 4.56145212 4.22762911
    0.50265488 4.81753720 5.06905005 4.68336488
    0.53407081 5.09041470 5.45222292 5.09979867
    0.56548674 5.35826850 5.81926993 5.48948327
    0.59690267 5.62083430 5.97156983 5.75059406
    0.62831860 5.87785310 6.19611739 5.99190124
    0.65973453 6.12907110 6.98108901 6.52767142
    0.69115046 6.37424050 5.99603643 6.23972389
    0.72256639 6.61311930 6.28735803 6.26552380
    0.75398232 6.84547170 5.74105687 5.98145868
    0.78539825 7.07106840 6.77602618 6.41181739
    0.81681418 7.28968690 6.85151619 6.64996985
    0.84823011 7.50111130 6.38093462 6.50425328
    0.87964604 7.70513300 7.66786487 7.13449600
    0.91106197 7.90155070 8.07567306 7.64426231
    0.94247790 8.09017060 7.87262345 7.76794872
    0.97389383 8.27080630 8.31935211 8.06660333
    1.00530976 8.44327980 8.86376730 8.49836836
    1.03672569 8.60742090 8.06964373 8.26615980
    1.06814162 8.76306740 9.41039761 8.88590917
    1.09955755 8.91006580 8.92835762 8.90890037
    1.13097348 9.04827110 8.68164490 8.78581282
    1.16238941 9.17754680 9.27285046 9.04960525
    1.19380534 9.29776530 9.65991384 9.38016447
    1.22522127 9.40880810 9.37680006 9.37834222
    1.25663720 9.51056560 9.17752884 9.26957640
    1.28805313 9.60293730 8.78020289 9.00451880
    1.31946906 9.68583200 9.57998840 9.31620831
    1.35088499 9.75916790 9.27521528 9.29400540
    1.38230092 9.82287280 9.78488155 9.55987687
    1.41371685 9.87688360 10.32271604 9.97305068
    1.44513278 9.92114720 10.41625520 10.21310193
    1.47654871 9.95561980 9.17540882 9.65105998
    1.50796464 9.98026740 9.11660215 9.36158353
    1.53938057 9.99506570 10.34605545 9.89479948
    1.57079650 10.00000000 10.35161797 10.14222442
    1.60221243 9.99506550 9.88948807 10.00533575
    1.63362836 9.98026720 10.25024667 10.13798596
    1.66504429 9.95561950 9.73600478 9.92026235
    1.69646022 9.92114680 10.15850842 10.04930270
    1.72787615 9.87688310 11.01563448 10.57269347
    1.75929208 9.82287210 10.40551561 10.48214553
    1.79070801 9.75916720 10.51001749 10.49724172
    1.82212394 9.68583110 9.82572837 10.13353238
    1.85353987 9.60293630 10.46598167 10.31359568
    1.88495580 9.51056450 9.31690803 9.77376337
    1.91637173 9.40880700 9.12661892 9.42325287
    1.94778766 9.29776410 9.47494195 9.45124904
    1.97920359 9.17754540 8.83534106 9.11765704
    2.01061952 9.04826960 8.42020767 8.73990007
    2.04203545 8.91006420 9.31084849 9.04914079
    2.07345138 8.76306570 8.58320157 8.79677582
    2.10486731 8.60741910 8.81196387 8.80500207
    2.13628324 8.44327800 8.83431931 8.82088106
    2.16769917 8.27080440 8.69911763 8.75493078
    2.19911510 8.09016850 8.49712138 8.61529441
    2.23053103 7.90154860 7.52881785 8.02683006
    2.26194696 7.70513080 7.73606742 7.86934535
    2.29336289 7.50110900 6.90444588 7.34673036
    2.32477882 7.28968450 7.20778566 7.27147425
    2.35619475 7.07106600 7.04657670 7.14966381
    2.38761068 6.84546910 6.19311495 6.63157173
    2.41902661 6.61311670 7.75630107 7.24075480
    2.45044254 6.37423780 6.12010764 6.63378275
    2.48185847 6.12906840 6.65184129 6.64356373
    2.51327440 5.87785030 5.50467567 6.02671193
    2.54469033 5.62083150 4.62287829 5.26635862
    2.57610626 5.35826560 4.54544759 4.87589420
    2.60752219 5.09041170 4.88442549 4.88051497
    2.63893812 4.81753420 4.73826616 4.80346926
    2.67035405 4.53990240 5.22731399 5.03303474
    2.70176998 4.25779020 4.36847656 4.67309251
    2.73318591 3.97147610 4.07646885 4.34994540
    2.76460184 3.68124270 4.36259811 4.35679844
    2.79601777 3.38737630 3.42840169 3.85395428
    2.82743370 3.09016700 3.66048294 3.74916510
    2.85884963 2.78990800 2.66247256 3.16058377
    2.89026556 2.48689580 2.18075736 2.62988395
    2.92168149 2.18142930 1.64406354 2.09593762
    2.95309742 1.87380990 2.32140082 2.21805443
    2.98451335 1.56434140 1.76298351 1.97157602
    3.01592928 1.25332900 1.88917658 1.92694631
    3.04734521 0.94107980 1.13478766 1.49789230
    3.07876114 0.62790180 -0.13328145 0.61440559
    3.11017707 0.31410420 -0.54286213 -0.01240112
                        0.31651924 >> >>#### f. 矩阵的切片粒度聚合、矩阵粒度聚合、以某切片值排序、切片粒度定位极值位置： >> >>> >>> >>> >>> >>> >>> >>> >>> >>> >>> >>> >>> >>> >>> >>> >>> >>> >>> >>> >>> >>> >>> >>> >>> >>> >>> >>> >>> >>> >>> >>> >>> >>> >>> >>> >>> >>> >>> >>> >>> >>> >>> >>> >>> >>> >>> >>> >>> >>> >>> >>> >>> >>> >>> >>> >>> >>> >>> >>> >>> >>> >>> >>> >>> >>> >>> >>> >>> >>> >>> >>> >>> >>> >>> >>> >>> >>>
函数名函数说明调用举例
sm_sc.fv_aggr_slice_sum 元素聚合合计。
入参：
  1. 原矩阵； 		select
  sm_sc.fv_aggr_slice_sum
  (
    array[[1.3, 2.25],[2.2, -3.0]]
  );

返回：
  2.75
sm_sc.fv_aggr_slice_prod 元素聚合连积。
入参：
  1. 原矩阵； 		select
  sm_sc.fv_aggr_slice_prod
  (
    array[[1.3, 2.25],[2.2, -3.0]]
  );

返回：
  -19.305
sm_sc.fv_aggr_slice_avg 元素聚合平均。
入参：
  1. 原矩阵； 		select
  sm_sc.fv_aggr_slice_avg
  (
    array[[1.3, 2.25],[2.2, -3.0]]
  );

返回：
  0.6875
sm_sc.fv_aggr_slice_max 元素聚合最大。
入参：
  1. 原矩阵； 		select
  sm_sc.fv_aggr_slice_max
  (
    array[[1.3, 2.25],[2.2, -3.0]]
  );

返回：
  2.25
sm_sc.fv_aggr_slice_min 元素聚合最小。
入参：
  1. 原矩阵； 		select
  sm_sc.fv_aggr_slice_min
  (
    array[[1.3, 2.25],[2.2, -3.0]]
  );

返回：
  -3.0
sm_sc.fv_aggr_slice_ptp 元素聚合跨度(最大-最小)。
入参：
  1. 原矩阵； 		select
  sm_sc.fv_aggr_slice_ptp
  (
    array[[1.3, 2.25],[2.2, -3.0]]
  );

返回：
  5.25
sm_sc.fv_aggr_slice_var_pop 元素聚合总体方差。
入参：
  1. 原矩阵； 		select
  sm_sc.fv_aggr_slice_var_pop
  (
    array[[1.3, 2.25],[2.2, -3.0]]
  );

返回：
  4.67546875
sm_sc.fv_aggr_slice_var_samp 元素聚合样本方差。
入参：
  1. 原矩阵； 		select
  sm_sc.fv_aggr_slice_var_samp
  (
    array[[1.3, 2.25],[2.2, -3.0]]
  );

返回：
  6.2339583
sm_sc.fv_aggr_slice_stddev_pop 元素聚合总体标准差。
入参：
  1. 原矩阵； 		select
  sm_sc.fv_aggr_slice_stddev_pop
  (
    array[[1.3, 2.25],[2.2, -3.0]]
  );

返回：
  2.162283
sm_sc.fv_aggr_slice_stddev_samp 元素聚合样本标准差。
入参：
  1. 原矩阵； 		select
  sm_sc.fv_aggr_slice_stddev_samp
  (
    array[[1.3, 2.25],[2.2, -3.0]]
  );

返回：
  2.4967896
sm_sc.fv_aggr_slice_mode 元素聚合众数。
入参：
  1. 原矩阵； 		select
  sm_sc.fv_aggr_slice_mode
  (
    array[[1.3, 2.25],[2.25, -3.0]]
  );

返回：
  2.25
sm_sc.fv_aggr_slice_median 元素聚合中位数。
入参：
  1. 原矩阵； 		select
  sm_sc.fv_aggr_slice_median
  (
    array[[1.3, 2.25],[2.2, -3.0]]
  );

返回：
  1.75
sm_sc.fv_aggr_slice_concat 元素聚合位元拼接。
入参：
  1. 原矩阵； 		select
  sm_sc.fv_aggr_slice_concat
  (
    array[['abc', 'de'],['fghi', 'jklmn']]
  );

返回：
  'abcdefghijklmn'
sm_sc.fv_aggr_slice_or 元素聚合位元、逻辑求或。
入参：
  1. 原矩阵； 		select
  sm_sc.fv_aggr_slice_or
  (
    array[[true, false],[true, false]]
  );

返回：
  true
--------------------------
select
  sm_sc.fv_aggr_slice_or
  (
    array[[B'010', B'011'],[B'101', B'011']]
  );

返回：
  B'111'
sm_sc.fv_aggr_slice_and 元素聚合位元、逻辑求与。
入参：
  1. 原矩阵； 		select
  sm_sc.fv_aggr_slice_and
  (
    array[[true, false],[true, false]]
  );

返回：
  false
--------------------------
select
  sm_sc.fv_aggr_slice_and
  (
    array[[B'010', B'011'],[B'101', B'011']]
  );

返回：
  B'000'
sm_sc.fv_aggr_slice_coalesce 元素聚合免空。
入参：
  1. 原矩阵； 		select
  sm_sc.fv_aggr_slice_coalesce
  (
    array[[null, 2.25],[2.2, -3.0]]
  );

返回：
  2.25
sm_sc.fv_aggr_slice_is_exists_null 空元素判定。
入参：
  1. 原矩阵； 		select
  sm_sc.fv_aggr_slice_is_exists_null
  (
    array[[null, 2.25],[2.2, -3.0]]
  );

返回：
  true
sm_sc.fv_aggr_y_sum 元素聚合y方向合计。
入参：
  1. 原矩阵； 		select
  sm_sc.fv_aggr_y_sum
  (
    array[[1.3, 2.25],[2.2, -3.0]]
  );

返回：
  array[[3.5, -0.75]]
sm_sc.fv_aggr_y_prod 元素聚合y方向连积。
入参：
  1. 原矩阵； 		select
  sm_sc.fv_aggr_y_prod
  (
    array[[1.3, 2.25],[2.2, -3.0]]
  );

返回：
  array[[2.86, -6.75]]
sm_sc.fv_aggr_y_avg 元素聚合y方向平均。
入参：
  1. 原矩阵； 		select
  sm_sc.fv_aggr_y_avg
  (
    array[[1.3, 2.25],[2.2, -3.0]]
  );

返回：
  array[[1.75, -0.375]]
sm_sc.fv_aggr_y_max 元素聚合y方向最大。
入参：
  1. 原矩阵； 		select
  sm_sc.fv_aggr_y_max
  (
    array[[1.3, 2.25],[2.2, -3.0]]
  );

返回：
  array[[2.2, 2.25]]
sm_sc.fv_aggr_y_min 元素聚合y方向最小。
入参：
  1. 原矩阵； 		select
  sm_sc.fv_aggr_y_min
  (
    array[[1.3, 2.25],[2.2, -3.0]]
  );

返回：
  array[[1.3, -3.0]]
sm_sc.fv_aggr_y_ptp 元素聚合y方向跨度(最大-最小)。
入参：
  1. 原矩阵； 		select
  sm_sc.fv_aggr_y_ptp
  (
    array[[1.3, 2.25],[2.2, -3.0]]
  );

返回：
  array[[0.9, 5.25]]
sm_sc.fv_aggr_y_var_pop 元素聚合y方向总体方差。
入参：
  1. 原矩阵； 		select
  sm_sc.fv_aggr_y_var_pop
  (
    array[[1.3, 2.25],[2.2, -3.0]]
  );

返回：
  array[[0.2025, 6.890625]]
sm_sc.fv_aggr_y_var_samp 元素聚合y方向样本方差。
入参：
  1. 原矩阵； 		select
  sm_sc.fv_aggr_y_var_samp
  (
    array[[1.3, 2.25],[2.2, -3.0]]
  );

返回：
  array[[0.405, 13.78125]]
sm_sc.fv_aggr_y_stddev_pop 元素聚合y方向总体标准差。
入参：
  1. 原矩阵； 		select
  sm_sc.fv_aggr_y_stddev_pop
  (
    array[[1.3, 2.25],[2.2, -3.0]]
  );

返回：
  array[[0.45, 2.625]]
sm_sc.fv_aggr_y_stddev_samp 元素聚合y方向样本标准差。
入参：
  1. 原矩阵； 		select
  sm_sc.fv_aggr_y_stddev_samp
  (
    array[[1.3, 2.25],[2.2, -3.0]]
  );

返回：
  array[[0.6364, 3.7123]]
sm_sc.fv_aggr_y_mode 元素聚合y方向众数。
入参：
  1. 原矩阵； 		select
  sm_sc.fv_aggr_y_mode
  (
    array[[1.3, 2.25],[2.2, -3.0],[1.3, -3.0]]
  );

返回：
  array[[1.3, -3.0]]
sm_sc.fv_aggr_y_median 元素聚合y方向中位数。
入参：
  1. 原矩阵； 		select
  sm_sc.fv_aggr_y_median
  (
    array[[1.3, 2.25],[2.2, -3.0]]
  );

返回：
  array[[1.75, -0.375]]
sm_sc.fv_aggr_y_concat 元素聚合y方向位元拼接
入参：
  1. 原矩阵； 		select
  sm_sc.fv_aggr_y_concat
  (
    array[['abc', 'de'],['fghi', 'jklmn']]
  );

返回：
  array[['abcfghi', 'dejklmn']]
sm_sc.fv_aggr_y_or 元素聚合y方向位元、逻辑求或。
入参：
  1. 原矩阵； 		select
  sm_sc.fv_aggr_y_or
  (
    array[[true, false],[true, false]]
  );

返回：
  array[[true, false]]
--------------------------
select
  sm_sc.fv_aggr_y_or
  (
    array[[B'010', B'011'],[B'101', B'011']]
  );

返回：
  array[[B'111', B'011']]
sm_sc.fv_aggr_y_and 元素聚合y方向位元、逻辑求与。
入参：
  1. 原矩阵； 		select
  sm_sc.fv_aggr_y_and
  (
    array[[true, false],[true, false]]
  );

返回：
  array[[true, false]]
--------------------------
select
  sm_sc.fv_aggr_y_and
  (
    array[[B'010', B'011'],[B'101', B'011']]
  );

返回：
  array[[B'000', B'011']]
sm_sc.fv_aggr_y_coalesce 元素聚合y方向免空。
入参：
  1. 原矩阵； 		select
  sm_sc.fv_aggr_y_coalesce
  (
    array[[null, 2.25],[2.2, -3.0]]
  );

返回：
  array[[2.2, 2.25]]
sm_sc.fv_aggr_y_is_exists_null 元素聚合y方向空元素判定。
入参：
  1. 原矩阵； 		select
  sm_sc.fv_aggr_y_is_exists_null
  (
    array[[null, 2.25],[2.2, -3.0]]
  );

返回：
  array[[true, false]]
sm_sc.fv_aggr_x_sum 元素聚合x方向合计。
入参：
  1. 原矩阵； 		select
  sm_sc.fv_aggr_x_sum
  (
    array[[1.3, 2.25],[2.2, -3.0]]
  );

返回：
  array[[3.55],[-0.8]]
sm_sc.fv_aggr_x_prod 元素聚合x方向连积。
入参：
  1. 原矩阵； 		select
  sm_sc.fv_aggr_x_prod
  (
    array[[1.3, 2.25],[2.2, -3.0]]
  );

返回：
  array[[2.925],[-6.60]]
sm_sc.fv_aggr_x_avg 元素聚合x方向平均。
入参：
  1. 原矩阵； 		select
  sm_sc.fv_aggr_x_avg
  (
    array[[1.3, 2.25],[2.2, -3.0]]
  );

返回：
  array[[1.775],[-0.4]]
sm_sc.fv_aggr_x_max 元素聚合x方向最大。
入参：
  1. 原矩阵； 		select
  sm_sc.fv_aggr_x_max
  (
    array[[1.3, 2.25],[2.2, -3.0]]
  );

返回：
  array[[2.25],[2.2]]
sm_sc.fv_aggr_x_min 元素聚合x方向最小。
入参：
  1. 原矩阵； 		select
  sm_sc.fv_aggr_x_min
  (
    array[[1.3, 2.25],[2.2, -3.0]]
  );

返回：
  array[[1.3],[-3.0]]
sm_sc.fv_aggr_x_ptp 元素聚合x方向跨度(最大-最小)。
入参：
  1. 原矩阵； 		select
  sm_sc.fv_aggr_x_ptp
  (
    array[[1.3, 2.25],[2.2, -3.0]]
  );

返回：
  array[[0.95],[5.2]]
sm_sc.fv_aggr_x_var_pop 元素聚合x方向总体方差。
入参：
  1. 原矩阵； 		select
  sm_sc.fv_aggr_x_var_pop
  (
    array[[1.3, 2.25],[2.2, -3.0]]
  );

返回：
  array[[0.225625],[6.76]]
sm_sc.fv_aggr_x_var_samp 元素聚合x方向样本方差。
入参：
  1. 原矩阵； 		select
  sm_sc.fv_aggr_x_var_samp
  (
    array[[1.3, 2.25],[2.2, -3.0]]
  );

返回：
  array[[0.45125],[13.52]]
sm_sc.fv_aggr_x_stddev_pop 元素聚合x方向总体标准差。
入参：
  1. 原矩阵； 		select
  sm_sc.fv_aggr_x_stddev_pop
  (
    array[[1.3, 2.25],[2.2, -3.0]]
  );

返回：
  array[[0.475],[2.6]]
sm_sc.fv_aggr_x_stddev_samp 元素聚合x方向样本标准差。
入参：
  1. 原矩阵； 		select
  sm_sc.fv_aggr_x_stddev_samp
  (
    array[[1.3, 2.25],[2.2, -3.0]]
  );

返回：
  array[[0.67175],[3.67696]]
sm_sc.fv_aggr_x_mode 元素聚合x方向众数。
入参：
  1. 原矩阵； 		select
  sm_sc.fv_aggr_x_mode
  (
    array[[1.3, 2.25, 2.25],[2.2, -3.0, 2.2],[1.3, -3.0, 3.0]]
  );

返回：
  array[[2.25],[2.2],[-3.0]]
sm_sc.fv_aggr_x_median 元素聚合x方向中位数。
入参：
  1. 原矩阵； 		select
  sm_sc.fv_aggr_x_median
  (
    array[[1.3, 2.25],[2.2, -3.0]]
  );

返回：
  array[[1.775],[-0.4]]
sm_sc.fv_aggr_x_concat 元素聚合x方向位元拼接
入参：
  1. 原矩阵； 		select
  sm_sc.fv_aggr_x_concat
  (
    array[['abc', 'de'],['fghi', 'jklmn']]
  );

返回：
  array[['abcde'],['fghijklmn']]
sm_sc.fv_aggr_x_or 元素聚合x方向位元、逻辑求或。
入参：
  1. 原矩阵； 		select
  sm_sc.fv_aggr_x_or
  (
    array[[true, false],[true, false]]
  );

返回：
  array[[true, true]]
--------------------------
select
  sm_sc.fv_aggr_x_or
  (
    array[[B'010', B'011'],[B'101', B'011']]
  );

返回：
  array[[B'011'],[B'111']]
sm_sc.fv_aggr_x_and 元素聚合x方向位元、逻辑求与。
入参：
  1. 原矩阵； 		select
  sm_sc.fv_aggr_x_and
  (
    array[[true, false],[true, false]]
  );

返回：
  array[[false, false]]
--------------------------
select
  sm_sc.fv_aggr_x_and
  (
    array[[B'010', B'011'],[B'101', B'011']]
  );

返回：
  array[[B'010'],[B'001']]
sm_sc.fv_aggr_x_coalesce 元素聚合x方向免空。
入参：
  1. 原矩阵； 		select
  sm_sc.fv_aggr_x_coalesce
  (
    array[[null, 2.25],[2.2, -3.0]]
  );

返回：
  array[[2.25],[2.2]]
sm_sc.fv_aggr_x_is_exists_null 元素聚合x方向空元素判定。
入参：
  1. 原矩阵； 		select
  sm_sc.fv_aggr_x_is_exists_null
  (
    array[[null, 2.25],[2.2, -3.0]]
  );

返回：
  array[[true], [false]]
sm_sc.fv_idx_1d_max 一维数组检索最大值位置。
入参：
  1. 原矩阵； 		select
  sm_sc.fv_idx_1d_max
  (
    array[1.2, 2.3, 5.6, 52.1]
  );

返回：
  4
sm_sc.fv_idx_y_max 二维数组各行检索最大值位置。
入参：
  1. 原矩阵； 		select
  sm_sc.fv_idx_y_max
  (
    array[[1.2, 2.3, 5.6, 52.1],[-1.2, 2.3, -5.6, 2.1]]
  );

返回：
  array[[4],[2]]
sm_sc.fv_idx_x_max 二维数组各列检索最大值位置。
入参：
  1. 原矩阵； 		select
  sm_sc.fv_idx_x_max
  (
    array[[1.3, 2.25],[2.2, -3.0]]
  );

返回：
  array[[2, 1]]
sm_sc.fv_idx_mx_max 二维数组检索最大值位置。
入参：
  1. 原矩阵； 		select
  sm_sc.fv_idx_mx_max
  (
    array[[1.3, 2.25],[2.2, -3.0]]
  );

返回：
  array[1, 2]
sm_sc.fv_idx_1d_min 一维数组检索最小值位置。
入参：
  1. 原矩阵； 		select
  sm_sc.fv_idx_1d_min
  (
    array[1.2, 2.3, 5.6, 52.1]
  );

返回：
  1
sm_sc.fv_idx_y_min 二维数组各行检索最小值位置。
入参：
  1. 原矩阵； 		select
  sm_sc.fv_idx_y_min
  (
    array[[1.3, 2.25],[2.2, -3.0]]
  );

返回：
  array[[1],[2]]
sm_sc.fv_idx_x_min 二维数组各列检索最小值位置。
入参：
  1. 原矩阵； 		select
  sm_sc.fv_idx_x_min
  (
    array[[1.3, 2.25],[2.2, -3.0]]
  );

返回：
  array[[1, 2]]
sm_sc.fv_idx_mx_min 二维数组检索最小值位置。
入参：
  1. 原矩阵； 		select
  sm_sc.fv_idx_mx_min
  (
    array[[1.3, 2.25],[2.2, -3.0]]
  );

返回：
  array[2, 2]
sm_sc.fv_ord_by_col 元素纵向排序，按照某列值排列行。
入参：
  1. 原矩阵；
  2. 列序号，按照该列元素值大小排序；
  3. 降序控制，缺省为升序； 		select
  sm_sc.fv_ord_by_col
  (
    array[[1.3, 2.25],[2.2, -3.0]]
  , 2
  );

返回：
  array[[2.2, -3.0],[1.3, 2.25]]
sm_sc.fv_ord_by_row 元素横向排序，按照某行值排列列。
入参：
  1. 原矩阵；
  2. 行序号，按照该行元素值大小排序；
  3. 降序控制，缺省为升序； 		select
  sm_sc.fv_ord_by_row
  (
    array[[1.3, 2.25],[2.2, -3.0]]
  , 1
  , true
  );

返回：
  array[[2.25, 1.3],[-3.0, 2.2]]
sm_sc.fa_mx_sum 矩阵粒度聚合合计 select
  sm_sc.fa_mx_sum(a_arr) as a_mx_sum,
  sm_sc.fa_mx_prod(a_arr) as a_mx_prod,
  sm_sc.fa_mx_avg(a_arr) as a_mx_avg,
  sm_sc.fa_mx_max(a_arr) as a_mx_max,
  sm_sc.fa_mx_min(a_arr) as a_mx_min,
  sm_sc.fa_mx_inner_prod(a_arr) as a_mx_inner_prod
from
  (
    select array[[1.3, 2.25],[2.2, -3.0]] as a_arr
    union all
    select array[[2.3, 5.6],[0.47, 2.6]] as a_arr
    union all
    select array[[2.6, -0.8],[0.63, 3.71]] as a_arr
  ) tb_a_arr(a_arr);

返回：
  a_mx_sum:
    array[[6.2, 7.05],[3.30, 3.31]]
  a_mx_prod:
    array[[7.774, -10.08],[0.65142, -28.938]]
  a_mx_avg:
    array[[2.0667, 2.35],[1.1, 1.1033]]
  a_mx_max:
    array[[2.6, 5.6],[2.2, 3.71]]
  a_mx_min:
    array[[1.3, -0.8],[0.47, -3.0]]
  a_mx_inner_prod:
    -30.59258
sm_sc.fa_mx_prod 矩阵粒度聚合连积
sm_sc.fa_mx_avg 矩阵粒度聚合平均
sm_sc.fa_mx_max 矩阵粒度聚合最大
sm_sc.fa_mx_min 矩阵粒度聚合最小
sm_sc.fa_mx_inner_prod 矩阵粒度聚合内积
sm_sc.fa_array_concat 矩阵粒度一阶数组聚合拼接 select
  sm_sc.fa_array_concat(a_arr)
from
(
  select array[1.2, 1.5, 1.8] as a_val
  union all
  select array[11.2, 21.5, 31.8] as a_val
  union all
  select array[31.2, 1.5, 21.8] as a_val
) tb_a_arr(a_arr);

返回：
  array[1.2, 1.5, 1.8, 11.2, 21.5, 31.8, 31.2, 1.5, 21.8]
sm_sc.fa_mx_concat_x 矩阵粒度聚合横向拼接 select
  sm_sc.fa_mx_concat_x(a_arr) as a_mx_concat_x,
  sm_sc.fa_mx_concat_y(a_arr) as a_mx_concat_y,
  sm_sc.fa_mx_concat_per_ele(a_arr) as a_mx_concat_per_ele
from
(
  select array[[B'110', B'100', B'101'],[B'101', B'1010', B'100']] as a_val
  union all
  select array[[B'1010', B'110', B'1010'],[B'010', B'1010', B'110']] as a_val
  union all
  select array[[B'1010', B'10', B'1010'],[B'10', B'101001010', B'00010']] as a_val
) tb_a_arr(a_arr);

返回：
  a_mx_concat_x:
    array[[B'110',B'100',B'101',B'1010',B'110',B'1010',B'1010',B'10',B'1010']
            ,[B'101',B'1010',B'100',B'010',B'1010',B'110',B'10',B'101001010',B'00010']]
  a_mx_concat_y:
    array[[B'110',B'100',B'101']
            ,[B'101',B'1010',B'100']
            ,[B'1010',B'110',B'1010']
            ,[B'010',B'1010',B'110']
            ,[B'1010',B'10',B'1010']
            ,[B'10',B'101001010',B'00010']]
  a_mx_concat_per_ele:
    array[[B'11010101010',B'10011010',B'10110101010']
            ,[B'10101010',B'10101010101001010',B'10011000010']]
sm_sc.fa_mx_concat_y 矩阵粒度聚合纵向拼接
sm_sc.fa_mx_concat_per_ele 每矩阵同位置对应元素聚合位元拼接
sm_sc.fa_mx_or 每矩阵同位置对应元素聚合位元、逻辑求或 select
  sm_sc.fa_mx_or(a_arr) as a_mx_or,
  sm_sc.fa_mx_and(a_arr) as a_mx_and
from
  (
    select array[[B'1101', B'100', B'101'],[B'10', B'100101010', B'10010']] as a_arr
    union all
    select array[[B'1010', B'110', B'100'],[B'00', B'100101010', B'10010']] as a_arr
    union all
    select array[[B'1010', B'101', B'010'],[B'10', B'101001010', B'00010']] as a_arr
  ) tb_a_arr(a_arr);

返回：
  a_mx_or:
    array[[B'1111', B'111', B'111'],[B'10', B'101101010', B'10010']]
  a_mx_and:
    array[[B'1000', B'100', B'000'],[B'00', B'100001010', B'00010']]
sm_sc.fa_mx_and 每矩阵同位置对应元素聚合位元、逻辑求与
sm_sc.fa_mx_coalesce 矩阵粒度聚合免空 select
  sm_sc.fa_mx_coalesce(a_arr)
from
(
  select array[[null, 12, null],[14, null, 16]] as a_val
  union all
  select array[[null, 22, 23],[null, null, 26]] as a_val
  union all
  select array[[31, 1.5, 1.8],[11.2, 11.5, 11.8]] as a_val
) tb_a_arr(a_arr);

返回：
  array[[31, 12, 23],[14, 11.5, 16]]
>> >>#### g. 机器学习的标准化函数： >> >>> 函数名|函数说明|调用举例 >>> :-|:-|:- >> sm_sc.fv_normalize_mx_0_1 |全矩阵0至1区间(线性)标准化。
入参：
  1. 原矩阵； |select
  sm_sc.fv_normalize_mx_0_1
  (
    array[[12.3, 25.1],[2.56, 3.25]]
  );

返回：
  array[[0.432121, 1.0],[0.0, 0.030612]] >> sm_sc.fv_normalize_mx_ne1_1 |全矩阵-1至1区间(线性)标准化。
入参：
  1. 原矩阵； |select
  sm_sc.fv_normalize_mx_ne1_1
  (
    array[[12.3, 25.1],[2.56, 3.25]]
  );

返回：
  array[[0.0664, 0.6343],[-0.3657, -0.3351]] >> sm_sc.fv_standlize_mx_l1l2ln |全矩阵 l1, l2...ln 范数归一化。
入参：
  1. 原矩阵；
  2. 范数次数； |select
  sm_sc.fv_standlize_mx_l1l2ln
  (
    array[[12.3, 25.1],[2.56, 3.25]]
  , 2
  );

返回：
  array[[0.4353, 0.8883],[0.0906, 0.1150]] >> sm_sc.fv_standlize_mx_log |全矩阵对数(非线性)标准化。
入参：
  1. 原矩阵； |select
  sm_sc.fv_standlize_mx_log
  (
    array[[12.3, 25.1],[2.56, 3.25]]
  );

返回：
  array[[0.7787, 1.0000],[0.2917, 0.3657]] >> sm_sc.fv_standlize_mx_softmax |全矩阵 softmax 标准化。
入参：
  1. 原矩阵； |select
  sm_sc.fv_standlize_mx_softmax
  (
    array[[4.3, 2.1],[2.56, 3.25]]
  );

返回：
  array[[0.6111, 0.0677],[0.1073, 0.2139]] >> sm_sc.fv_standlize_mx_zscore |全矩阵 z_score 标准化。
入参：
  1. 原矩阵； |select
  sm_sc.fv_standlize_mx_zscore
  (
    array[[12.3, 25.1],[2.56, 3.25]]
  );

返回：
  array[[0.1424, 1.3598],[-0.7839, -0.7183]] >> sm_sc.fv_normalize_x_0_1 |x方向0至1区间(线性)标准化。
入参：
  1. 原矩阵； |select
  sm_sc.fv_normalize_x_0_1
  (
    array[[2.3, 3.32, 5.1],[2.56, -2.1, 3.25]]
  );

返回：
  array[[0.0000, 0.3643, 1.0000],[0.8710, 0.0000, 1.0000]] >> sm_sc.fv_normalize_x_ne1_1 |x方向-1至1区间(线性)标准化。
入参：
  1. 原矩阵； |select
  sm_sc.fv_normalize_x_ne1_1
  (
    array[[2.3, 3.32, 5.1],[2.56, -2.1, 3.25]]
  );

返回：
  array[[-0.4548, -0.0905, 0.5452],[0.2474, -0.6237, 0.3763]] >> sm_sc.fv_standlize_x_l1l2ln |x方向 l1, l2...ln 范数归一化。
入参：
  1. 原矩阵；
  2. 范数次数； |select
  sm_sc.fv_standlize_x_l1l2ln
  (
    array[[2.3, 3.32, 5.1],[2.56, -2.1, 3.25]]
  , 3
  );

返回：
  array[[0.4063, 0.5865, 0.9009],[0.6526, -0.5353, 0.8285]] >> sm_sc.fv_standlize_x_log |x方向对数(非线性)标准化。
入参：
  1. 原矩阵； |select
  sm_sc.fv_standlize_x_log
  (
    array[[2.3, 3.32, 5.1],[2.56, 2.1, 3.25]]
  );

返回：
  array[[0.5112, 0.7365, 1.0000],[0.7975, 0.6295, 1.0000]] >> sm_sc.fv_standlize_x_softmax |x方向 softmax 标准化。
入参：
  1. 原矩阵； |select
  sm_sc.fv_standlize_x_softmax
  (
    array[[2.3, 3.32, 5.1],[2.56, -2.1, 3.25]]
  );

返回：
  array[[0.0495, 0.1372, 0.8134],[0.3330, 0.0032, 0.6639]] >> sm_sc.fv_standlize_x_zscore |x方向 z_score 标准化。
入参：
  1. 原矩阵； |select
  sm_sc.fv_standlize_x_zscore
  (
    array[[2.3, 3.32, 5.1],[2.56, -2.1, 3.25]]
  );

返回：
  array[[-0.8986, -0.1788, 1.0773],[0.4547, -1.1466, 0.6918]] >> sm_sc.fv_normalize_y_0_1 |y方向0至1区间(线性)标准化。
入参：
  1. 原矩阵； |select
  sm_sc.fv_normalize_y_0_1
  (
    array[[2.3, 5.1],[2.56, 3.25],[-1.8, 4.2]]
  );

返回：
  array[[0.9404, 1.0000],[1.0000, 0.0000],[0.0000, 0.5135]] >> sm_sc.fv_normalize_y_ne1_1 |y方向-1至1区间(线性)标准化。
入参：
  1. 原矩阵； |select
  sm_sc.fv_normalize_y_ne1_1
  (
    array[[12.3, 25.1],[2.56, 3.25],[-1.8, 4.2]]
  );

返回：
  array[[0.2936, 0.4955],[0.3532, -0.5045],[-0.6468, 0.0090]] >> sm_sc.fv_standlize_y_l1l2ln |y方向 l1, l2...ln 范数归一化。
入参：
  1. 原矩阵；
  2. 范数次数； |select
  sm_sc.fv_standlize_y_l1l2ln
  (
    array[[12.3, 25.1],[2.56, 3.25],[-1.8, 4.2]]
  , 2
  );

返回：
  array[[0.5922, 0.6927],[0.6592, 0.4414],[-0.4635, 0.5704]] >> sm_sc.fv_standlize_y_log |y方向对数(非线性)标准化。
入参：
  1. 原矩阵； |select
  sm_sc.fv_standlize_y_log
  (
    array[[12.3, 25.1],[2.56, 3.25],[1.8, 4.2]]
  );

返回：
  array[[0.8861, 1.0000],[1.0000, 0.7234],[0.6253, 0.8808]] >> sm_sc.fv_standlize_y_softmax |y方向 softmax 标准化。相当于 layer normalization。
入参：
  1. 原矩阵； |select
  sm_sc.fv_standlize_y_softmax
  (
    array[[12.3, 25.1],[2.56, 3.25],[-1.8, 4.2]]
  );

返回：
  array[[0.4322, 0.6395],[0.5606, 0.1005],[0.0072, 0.2600]] >> sm_sc.fv_standlize_y_zscore |y方向 z_score 标准化。相当于 batch normalization。
入参：
  1. 原矩阵； |select
  sm_sc.fv_standlize_y_zscore
  (
    array[[12.3, 25.1],[2.56, 3.25],[-1.8, 4.2]]
  );

返回：
  array[[0.5234, 0.9909],[0.6297, -1.0089],[-1.1531, 0.0180]] >> >>#### h. 机器学习的激活函数： >> >>> 函数名|函数说明|调用举例 >>> :-|:-|:- >>> sm_sc.fv_activate_elu |激活函数 elu。
入参：
  1. 原值；
  2. α值； |select
  sm_sc.fv_activate_elu
  (
    array[[1.2, -1.0],[0.0, -8.3]]
  , 0.1
  );

返回：
  array[[1.2000, -0.0632],[0.0000, -0.1000]] >>> sm_sc.fv_activate_gelu |激活函数 gelu。
入参：
  1. 原值； |select
  sm_sc.fv_activate_gelu
  (
    array[[1.2, -1.0],[0.0, -8.3]]
  );

返回：
  array[[1.0617, -0.1588],[0.0000, 0.0000]] >>> sm_sc.fv_activate_leaky_relu |激活函数 leaky_relu。
入参：
  1. 原值；
  2. α值； |select
  sm_sc.fv_activate_leaky_relu
  (
    array[[1.2, -1.0],[0.0, -8.3]]
  , 0.1
  );

返回：
  array[[1.2000, -0.1000],[0.0000, -0.8300]] >>> sm_sc.fv_activate_relu |激活函数 relu。
入参：
  1. 原值； |select
  sm_sc.fv_activate_relu
  (
    array[[1.2, -1.0],[0.0, -8.3]]
  );

返回：
  array[[1.2, 0.0],[0.0, 0.0]] >>> sm_sc.fv_activate_selu |激活函数 selu。
入参：
  1. 原值； |select
  sm_sc.fv_activate_selu
  (
    array[[1.2, -1.0],[0.0, -8.3]]
  );

返回：
  array[[1.2608, -1.1113],[0.0, -1.7577]] >>> sm_sc.fv_activate_sigmoid |激活函数 sigmoid。
入参：
  1. 原值； |select
  sm_sc.fv_activate_sigmoid
  (
    array[[1.2, -1.0],[0.0, -8.3]]
  );

返回：
  array[[0.7685, 0.2689],[0.5000, 0.0002]] >>> sm_sc.fv_activate_softplus |激活函数 softplus。
入参：
  1. 原值； |select
  sm_sc.fv_activate_softplus
  (
    array[[1.2, -1.0],[0.0, -8.3]]
  );

返回：
  array[[1.4633, 0.3133],[0.6931, 0.0002]] >> sm_sc.fv_activate_swish |激活函数 swish，也做 silu。
入参：
  1. 原值； |select
  sm_sc.fv_activate_swish
  (
    array[[1.2, -1.0],[0.0, -8.3]]
  );

返回：
  array[[0.9222, -0.2689],[0.0000, -0.0021]] >> >>#### i. 计算图的 json 序列化、反序列化： >> >>> 函数名|函数说明|调用举例 >>> :-|:-|:- >> sm_sc.ft_computational_graph_deserialize |json 计算图配置或代数式/等式文本反序列化为表记录。
本函数依托于临时表 sm_sc._vt_fn_compu_graph_deseri__graph 实现。
入参：
  1. 原值；json 计算图或代数式/等式文本；
      json 计算图格式说明如下：
        a. 花括号以及其中内容：表达式。
            表达式指变量或由变量和表达式以及运算类型组成的运算关系；
        b. out_param: 因变量名。
            表达式只有一个因变量；
        c. opr: 基础运算类型名称或注册的自定义运算类型名称；
        d. in_params: 自变量名称。
            其 value 值为方括号以及其中内容: 自变量或自变量集合；
        e. out_value: 常量值。

出参列：
  1. o_out_param: 中间结果因变量或最终因变量；
  2. o_in_param: 中间结果自变量或最终自变量；
  3. o_in_value: 常量数值；
  4. o_param_loc: 自变量在该步运算的入参顺序号；
  5. o_out_opr: 运算类型名； |-- 以下列函数表达式为例： "v_z_in = (v_x_in * v_y_in) + exp(2 * v_y_in)"
select * from sm_sc.ft_computational_graph_deserialize('
{
   "out_param": "v_z_in",
   "opr": "sm_sc.fv_opr_add",
   "in_params":
   [
       {
           "opr": "sm_sc.fv_opr_mul",
           "in_params":
           [
               {
                   "out_param": "v_x_in"
               },
               {
                   "out_param": "v_y_in"
               }
           ]
       },
       {
           "opr": "sm_sc.fv_opr_exp",
           "in_params":
           [
               {
                   "opr": "sm_sc.fv_opr_mul",
                   "in_params":
                   [
                       {
                           "out_value": 2
                       },
                       {
                           "out_param": "v_y_in"
                       }
                   ]
               }
           ]
       }
   ]
}
'::jsonb);

返回：
  o_out_param                                            o_in_param                                     o_in_value o_param_loc o_out_opr
                                                                    v_z_in                                                                  1    
  5fba12605bdc0e173138d1053c5e2d71    v_x_in                                                                  1    sm_sc.fv_opr_mul
  5fba12605bdc0e173138d1053c5e2d71    v_y_in                                                                  2    sm_sc.fv_opr_mul
  85a10bcd87dd33ec3668cf8719912cb6                                                                        2.0    1    sm_sc.fv_opr_mul
  85a10bcd87dd33ec3668cf8719912cb6    v_y_in                                                                  2    sm_sc.fv_opr_mul
  c37766ac76959dc0ab92af50ad916b13    85a10bcd87dd33ec3668cf8719912cb6              1    sm_sc.fv_opr_exp
  v_z_in                                                        5fba12605bdc0e173138d1053c5e2d71              1    sm_sc.fv_opr_add
  v_z_in                                                        c37766ac76959dc0ab92af50ad916b13              2    sm_sc.fv_opr_add
--------------------------
select * from sm_sc.ft_computational_graph_deserialize('v_z_in = (v_x_in * v_y_in) + exp(2 * v_y_in)');

返回：
  o_out_param                                            o_in_param                                     o_in_value o_param_loc o_out_opr
  3ad526261da71248975a90310b0da8f7    e4dd85e5f4b1451eaef35f03a5e44c5f              1    sm_sc.fv_opr_exp
  8efff79710388489d3fba3597afa8aac    v_x_in                                                                  1    sm_sc.fv_opr_mul
  8efff79710388489d3fba3597afa8aac    v_y_in                                                                  2    sm_sc.fv_opr_mul
  ce2101d23207b306073a470e7832654e    8efff79710388489d3fba3597afa8aac              1    sm_sc.fv_opr_add
  ce2101d23207b306073a470e7832654e    3ad526261da71248975a90310b0da8f7              2    sm_sc.fv_opr_add
  e4dd85e5f4b1451eaef35f03a5e44c5f                                                                        2.0    1    sm_sc.fv_opr_mul
  e4dd85e5f4b1451eaef35f03a5e44c5f    v_y_in                                                                  2    sm_sc.fv_opr_mul
  v_z_in                                                        ce2101d23207b306073a470e7832654e              1     >> >>#### j. 机器学习的卷积、池化： >> >>> 函数名|函数说明|调用举例 >>> :-|:-|:- >> sm_sc.fv_conv_2d_v_im2col |矩阵卷积(im2col 方法)。
入参：
  1. 原矩阵；
  2. 卷积核矩阵；
  3. 卷积核偏移量；
  4. 滑动窗口纵向和横向步长。
      本参数为长度为2的一维数组；
  5. 上下左右补齐行数/列数。
      本参数为长度为4的一维数组；
  6. 补齐填充元素值； |select
   sm_sc.fv_conv_2d_v_im2col
   (
    array
    [
      [1,2,3,4,5,6]
    ,[10,20,30,40,50,60]
    ,[100,200,300,400,500,600]
    ,[-1,-2,-3,-4,-5,-6]
    ,[-10,-20,-30,-40,-50,-60]
    ]
  , array[[1.1, 1.1, 1.1],[1.1, 2.1, 1.1],[1.1, 1.1, 1.1]]
  , 0.0
  , array[2, 2]
  , array[1, 1, 1, 0]
  , 0.0
   );

返回：
  array
  [
    [37.3000, 111.9000, 186.5000]
  ,[459.7000, 1379.1000, 2298.5000]
  ,[-46.3000, -138.9000, -231.5000]
  ] >> sm_sc.fv_pool_avg |平均池化。
入参：
  1. 原矩阵；
  2. 池化窗口高宽大小；
  4. 滑动窗口纵向和横向步长。
      本参数为长度为2的一维数组；
  5. 上下左右补齐行数/列数。
      本参数为长度为4的一维数组；
  6. 补齐填充元素值 |select sm_sc.fv_pool_avg
  (
    array
    [
      [1.0,2.0,3.0,4.0,5.0,6.0,7.0]
    ,[10.0,20.0,30.0,40.0,50.0,60.0,70.0]
    ,[100.0,200.0,300.0,400.0,500.0,600.0,700.0]
    ,[-1.0,-2.0,-3.0,-4.0,-5.0,-6.0,-7.0]
    ,[-10.0,-20.0,-30.0,-40.0,-50.0,-60.0,-70.0]
    ]
    , array[3, 3]
    , array[2, 2]
  );

返回：
  array
  [
    [3.6667, 11.0000, 18.3333, 23.8333]
  ,[36.3333, 109.0000, 181.6667, 236.1667]
  ,[-5.5000, -16.5000, -27.5000, -35.7500]
  ] >> sm_sc.fv_pool_max |最大值池化。
入参：
  1. 原矩阵；
  2. 池化窗口高宽大小；
  4. 滑动窗口纵向和横向步长。
      本参数为长度为2的一维数组；
  5. 上下左右补齐行数/列数。
      本参数为长度为4的一维数组；
  6. 补齐填充元素值 |select sm_sc.fv_pool_max
  (
    array
    [
      [1.0,2.0,3.0,4.0,5.0,6.0,7.0]
    ,[10.0,20.0,30.0,40.0,50.0,60.0,70.0]
    ,[100.0,200.0,300.0,400.0,500.0,600.0,700.0]
    ,[-1.0,-2.0,-3.0,-4.0,-5.0,-6.0,-7.0]
    ,[-10.0,-20.0,-30.0,-40.0,-50.0,-60.0,-70.0]
    ]
    , array[3, 3]
    , array[2, 2]
  );

返回：
  array
  [
    [300.0000, 500.0000, 700.0000]
  ,[300.0000, 500.0000, 700.0000]
  ] >> sm_sc.fv_pool_min |最小值池化。
入参：
  1. 原矩阵；
  2. 池化窗口高宽大小；
  4. 滑动窗口纵向和横向步长。
      本参数为长度为2的一维数组；
  5. 上下左右补齐行数/列数。
      本参数为长度为4的一维数组；
  6. 补齐填充元素值 |select sm_sc.fv_pool_min
  (
    array
    [
      [1.0,2.0,3.0,4.0,5.0,6.0,7.0]
    ,[10.0,20.0,30.0,40.0,50.0,60.0,70.0]
    ,[100.0,200.0,300.0,400.0,500.0,600.0,700.0]
    ,[-1.0,-2.0,-3.0,-4.0,-5.0,-6.0,-7.0]
    ,[-10.0,-20.0,-30.0,-40.0,-50.0,-60.0,-70.0]
    ]
    , array[3, 3]
    , array[2, 2]
  );

返回：
  array
  [
    [1.0000, 3.0000, 5.0000]
  ,[-30.0000, -50.0000, -70.0000]
  ] >> sm_sc.fv_pool_sum |合计求和池化。
入参：
  1. 原矩阵；
  2. 池化窗口高宽大小；
  4. 滑动窗口纵向和横向步长。
      本参数为长度为2的一维数组；
  5. 上下左右补齐行数/列数。
      本参数为长度为4的一维数组；
  6. 补齐填充元素值 |select sm_sc.fv_pool_sum
  (
    array
    [
      [1.0,2.0,3.0,4.0,5.0,6.0,7.0]
    ,[10.0,20.0,30.0,40.0,50.0,60.0,70.0]
    ,[100.0,200.0,300.0,400.0,500.0,600.0,700.0]
    ,[-1.0,-2.0,-3.0,-4.0,-5.0,-6.0,-7.0]
    ,[-10.0,-20.0,-30.0,-40.0,-50.0,-60.0,-70.0]
    ]
    , array[3, 3]
    , array[2, 2]
  );

返回：
  array
  [
    [666.0000, 1332.0000, 1998.0000]
  ,[534.0000, 1068.0000, 1602.0000]
  ] >> sm_sc.fv_pool_ptp |跨度池化。
入参：
  1. 原矩阵；
  2. 池化窗口高宽大小；
  4. 滑动窗口纵向和横向步长。
      本参数为长度为2的一维数组；
  5. 上下左右补齐行数/列数。
      本参数为长度为4的一维数组；
  6. 补齐填充元素值 |select sm_sc.fv_pool_ptp
  (
    array
    [
      [1.0,2.0,3.0,4.0,5.0,6.0,7.0]
    ,[10.0,20.0,30.0,40.0,50.0,60.0,70.0]
    ,[100.0,200.0,300.0,400.0,500.0,600.0,700.0]
    ,[-1.0,-2.0,-3.0,-4.0,-5.0,-6.0,-7.0]
    ,[-10.0,-20.0,-30.0,-40.0,-50.0,-60.0,-70.0]
    ]
    , array[3, 3]
    , array[2, 2]
  );

返回：
  array
  [
    [299.0000, 497.0000, 695.0000]
  ,[330.0000, 550.0000, 770.0000]
  ] >> sm_sc.fv_pool_prod |连积池化。
入参：
  1. 原矩阵；
  2. 池化窗口高宽大小；
  4. 滑动窗口纵向和横向步长。
      本参数为长度为2的一维数组；
  5. 上下左右补齐行数/列数。
      本参数为长度为4的一维数组；
  6. 补齐填充元素值 |select sm_sc.fv_pool_prod
  (
    array
    [
      [1.0,2.0,3.0,4.0,5.0,6.0,7.0]
    ,[10.0,20.0,30.0,40.0,50.0,60.0,70.0]
    ,[100.0,200.0,300.0,400.0,500.0,600.0,700.0]
    ,[-1.0,-2.0,-3.0,-4.0,-5.0,-6.0,-7.0]
    ,[-10.0,-20.0,-30.0,-40.0,-50.0,-60.0,-70.0]
    ]
    , array[3, 3]
    , array[2, 2]
  );

返回：
  array
  [
    [216000000000, 216000000000000, 9261000000000000]
  ,[216000000000, 216000000000000, 9261000000000000]
  ] >> sm_sc.fv_pool_mode |众数池化。
入参：
  1. 原矩阵；
  2. 池化窗口高宽大小；
  4. 滑动窗口纵向和横向步长。
      本参数为长度为2的一维数组；
  5. 上下左右补齐行数/列数。
      本参数为长度为4的一维数组；
  6. 补齐填充元素值 |select sm_sc.fv_pool_mode
  (
    array
    [
      [1.0,2.0,3.0,4.0,5.0,6.0,7.0]
    ,[10.0,20.0,30.0,40.0,50.0,60.0,70.0]
    ,[100.0,200.0,300.0,400.0,500.0,600.0,700.0]
    ,[-1.0,-2.0,-3.0,-4.0,-5.0,-6.0,-7.0]
    ,[-10.0,-20.0,-30.0,-40.0,-50.0,-60.0,-70.0]
    ]
    , array[3, 3]
    , array[2, 2]
  );

返回：
  array
  [
    [1.0000, 3.0000, 5.0000]
  ,[-30.0000, -50.0000, -70.0000]
  ] >> sm_sc.fv_pool_median |中位数池化。
入参：
  1. 原矩阵；
  2. 池化窗口高宽大小；
  4. 滑动窗口纵向和横向步长。
      本参数为长度为2的一维数组；
  5. 上下左右补齐行数/列数。
      本参数为长度为4的一维数组；
  6. 补齐填充元素值 |select sm_sc.fv_pool_median
  (
    array
    [
      [1.0,2.0,3.0,4.0,5.0,6.0,7.0]
    ,[10.0,20.0,30.0,40.0,50.0,60.0,70.0]
    ,[100.0,200.0,300.0,400.0,500.0,600.0,700.0]
    ,[-1.0,-2.0,-3.0,-4.0,-5.0,-6.0,-7.0]
    ,[-10.0,-20.0,-30.0,-40.0,-50.0,-60.0,-70.0]
    ]
    , array[3, 3]
    , array[2, 2]
  );

返回：
  array
  [
    [20.0000, 40.0000, 60.0000]
  ,[-2.0000, -4.0000, -6.0000]
  ] >> sm_sc.fv_pool_coalesce |免空池化。
入参：
  1. 原矩阵；
  2. 池化窗口高宽大小；
  4. 滑动窗口纵向和横向步长。
      本参数为长度为2的一维数组；
  5. 上下左右补齐行数/列数。
      本参数为长度为4的一维数组；
  6. 补齐填充元素值 |select sm_sc.fv_pool_coalesce
  (
    array
    [
      [null,2.0,3.0,4.0,5.0,6.0,7.0]
    ,[10.0,20.0,null,40.0,50.0,60.0,70.0]
    ,[100.0,200.0,300.0,400.0,500.0,null,700.0]
    ,[-1.0,null,-3.0,-4.0,-5.0,-6.0,-7.0]
    ,[-10.0,-20.0,-30.0,-40.0,-50.0,-60.0,null]
    ]
    , array[3, 3]
    , array[2, 2]
  );

返回：
  array
  [
    [2.0, 3.0, 5.0]
  ,[100.0, 300.0, 500.0]
  ] >> sm_sc.fv_conv_2d_grp_x |矩阵x方向卷积。
入参：
  1. 由2D转1D后的每行向量再次构成的2D原矩阵；
      例如：100张 28\*14 像素的图片，
                先将2D像素转长度为392的1D向量，
                再聚合成高宽为 100\*392 的2D矩阵；
  2. 2D样本的宽度。
      通常是图像的宽度，即参数一例子中的 14；
  3. 卷积核降维后的单行矩阵。
      如果带有偏移量，那么该一维数组长度多1。
      例如：3\*4卷积核矩阵降维后，
                 如果没有偏移量，则为1\*12矩阵，
                 如果有偏移量，则为1\*12 + 1 = 13矩阵；
  4. 卷积核窗口的宽度。
      例如：即参数三例子中的 4；
  5. 卷积核滑动的纵向与横向步长。
      该参数为长度为2的一维数组；
  6. 上下左右补齐行数/列数。
      该参数为长度为4的一维数组；
  7. 补齐填充； |select
   sm_sc.fv_conv_2d_grp_x
   (
    array
    [
      [1.0,2.0,3.0,4.0,5.0,6.0
        , 10.0,20.0,30.0,40.0,50.0,60.0
        , 100.0,200.0,300.0,400.0,500.0,600.0
        , -1.0,-2.0,-3.0,-4.0,-5.0,-6.0
        , -10.0,-20.0,-30.0,-40.0,-50.0,-60.0
      ],
      [1.0,2.0,3.0,4.0,5.0,6.0
        , -1.0,-2.0,-3.0,-4.0,-5.0,-6.0
        , 10.0,20.0,30.0,40.0,50.0,60.0
        , 100.0,200.0,300.0,400.0,500.0,600.0
        , -10.0,-20.0,-30.0,-40.0,-50.0,-60.0
      ],
      [1.0,2.0,3.0,4.0,5.0,6.0
        , -1.0,-2.0,-3.0,-4.0,-5.0,-6.0
        , 10.0,20.0,30.0,40.0,50.0,60.0
        , -10.0,-20.0,-30.0,-40.0,-50.0,-60.0
        , 100.0,200.0,300.0,400.0,500.0,600.0
      ]
    ]
    , 6
    , array[[1.1, 1.1, 1.1, 1.1, 2.1, 1.1, 1.1, 1.1, 1.1, 0.5]]
    , 3
    , array[2, 2]
    , array[1, 1, 1, 0]
    , 0
   );

返回：
  array
  [
    [37.30,111.90,186.50,459.70,1379.10,2298.50,-46.30,-138.90,-231.50]
  ,[1.00,3.00,5.00,369.70,1109.10,1848.50,287.00,861.00,1435.00]
  ,[1.00,3.00,5.00,6.70,20.10,33.50,397.00,1191.00,1985.00]
  ] >> sm_sc.fv_pool_avg_2d_grp_x |矩阵x方向平均池化。
入参：
  1. 由2D转1D后的每行向量再次构成的2D原矩阵；
      例如：100张 28\*14 像素的图片，
                先将2D像素转长度为392的1D向量，
                再聚合成高宽为 100\*392 的2D矩阵；
  2. 2D样本的宽度。
      通常是图像的宽度，即参数一例子中的 14；
  4. 池化窗口高宽大小。
      该参数为长度为2的一维数组；
  5. 池化滑动的纵向与横向步长。
      该参数为长度为2的一维数组；
  6. 上下左右补齐行数/列数。
      该参数为长度为4的一维数组；
  7. 补齐填充； |select
   sm_sc.fv_pool_avg_2d_grp_x
   (
    array
    [
      [1.0,2.0,3.0,4.0,5.0,6.0,7.0
        , 10.0,20.0,30.0,40.0,50.0,60.0,70.0
        , 100.0,200.0,300.0,400.0,500.0,600.0,700.0
        , -1.0,-2.0,-3.0,-4.0,-5.0,-6.0,-7.0
        , -10.0,-20.0,-30.0,-40.0,-50.0,-60.0,-70.0
      ],
      [1.0,2.0,3.0,4.0,5.0,6.0,7.0
        , -1.0,-2.0,-3.0,-4.0,-5.0,-6.0,-7.0
        , 10.0,20.0,30.0,40.0,50.0,60.0,70.0
        , 100.0,200.0,300.0,400.0,500.0,600.0,700.0
        , -10.0,-20.0,-30.0,-40.0,-50.0,-60.0,-70.0
      ],
      [1.0,2.0,3.0,4.0,5.0,6.0,7.0
        , -1.0,-2.0,-3.0,-4.0,-5.0,-6.0,-7.0
        , 10.0,20.0,30.0,40.0,50.0,60.0,70.0
        , -10.0,-20.0,-30.0,-40.0,-50.0,-60.0,-70.0
        , 100.0,200.0,300.0,400.0,500.0,600.0,700.0
      ]
    ]
    , 7
    , array[3, 3]
    , array[2, 2]
   );

返回：
  array
  [
    [3.67,11.00,18.33,23.83,36.33,109.00,181.67,236.17,-5.50,-16.50,-27.50,-35.75]
  ,[0.00,0.00,0.00,0.00,36.33,109.00,181.67,236.17,45.00,135.00,225.00,292.50]
  ,[0.00,0.00,0.00,0.00,-0.33,-1.00,-1.67,-2.17,45.00,135.00,225.00,292.50]
  ] >> sm_sc.fv_pool_max_2d_grp_x |矩阵x方向最大值池化。
入参：
  1. 由2D转1D后的每行向量再次构成的2D原矩阵；
      例如：100张 28\*14 像素的图片，
                先将2D像素转长度为392的1D向量，
                再聚合成高宽为 100\*392 的2D矩阵；
  2. 2D样本的宽度。
      通常是图像的宽度，即参数一例子中的 14；
  4. 池化窗口高宽大小。
      该参数为长度为2的一维数组；
  5. 池化滑动的纵向与横向步长。
      该参数为长度为2的一维数组；
  6. 上下左右补齐行数/列数。
      该参数为长度为4的一维数组；
  7. 补齐填充； |select
   sm_sc.fv_pool_max_2d_grp_x
   (
    array
    [
      [1.0,2.0,3.0,4.0,5.0,6.0,7.0
        , 10.0,20.0,30.0,40.0,50.0,60.0,70.0
        , 100.0,200.0,300.0,400.0,500.0,600.0,700.0
        , -1.0,-2.0,-3.0,-4.0,-5.0,-6.0,-7.0
        , -10.0,-20.0,-30.0,-40.0,-50.0,-60.0,-70.0
      ],
      [1.0,2.0,3.0,4.0,5.0,6.0,7.0
        , -1.0,-2.0,-3.0,-4.0,-5.0,-6.0,-7.0
        , 10.0,20.0,30.0,40.0,50.0,60.0,70.0
        , 100.0,200.0,300.0,400.0,500.0,600.0,700.0
        , -10.0,-20.0,-30.0,-40.0,-50.0,-60.0,-70.0
      ],
      [1.0,2.0,3.0,4.0,5.0,6.0,7.0
        , -1.0,-2.0,-3.0,-4.0,-5.0,-6.0,-7.0
        , 10.0,20.0,30.0,40.0,50.0,60.0,70.0
        , -10.0,-20.0,-30.0,-40.0,-50.0,-60.0,-70.0
        , 100.0,200.0,300.0,400.0,500.0,600.0,700.0
      ]
    ]
    , 7
    , array[3, 3]
    , array[2, 2]
   );

返回：
  array
  [
    [300.0,500.0,700.0,300.0,500.0,700.0]
  ,[30.0,50.0,70.0,300.0,500.0,700.0]
  ,[30.0,50.0,70.0,300.0,500.0,700.0]
  ] >> >>#### k. 机器学习的 lambda： >> >>> 函数名|函数说明|调用举例 >>> :-|:-|:- >> sm_sc.fv_algebra_execute |对于基础运算或自定义运算，代数式或函数式计算数值。
重载1：
  入参：
    1. 代数式；
重载2：
  入参：
    1. 函数名；
    1. 入参列表；|select
  sm_sc.fv_algebra_execute
  (
    '2.5 + 3.6'
  );

返回：
  6.1
--------------------------
select
  sm_sc.fv_algebra_execute
  (
    'sm_sc.fv_opr_mul'
  , array[1.5, 2.0, 3.4]
  );

返回：
  10.2 >> sm_sc.fv_lambda_arr |前行传播节点输出因变量 lambda。
入参：
  1. 神经网络节点序号。
      本参数不参与实际计算，仅用于控制、调试跟踪与日志；
  2. lambda 命名，即运算类型。
      支持范围参看第三章第三节神经网络节点支持运算类型；
  3. 第一目入参自变量。
      该参数为二维数组；
  4. 第二目入参自变量。
      该参数为二维数组；对于单目运算，本参数为空；
  5. 神经网络节点粒度的超参数配置。
      例如：激活函数的α值、卷积/池化的窗口的滑动步长；
      详见字典表：
          select \* from sm_sc.tb_dic_enum
          where enum_name = 'node_fn_asso_value'
      该参数为二维数组；对于单目运算，本参数为空； |
select
  sm_sc.fv_lambda_arr
  (
    100001
    , 'elu'
    , array[[1.23, 3.34],[-7.2, -0.25]]
    , null
    , array[0.1]
  );

返回：
  array[[1.2300, 3.3400],[-0.0999, -0.0221]] >> sm_sc.fv_lambda_arr_delta |反向传播节点因变量对自变量求导 lambda。
该 lambda 适用于前向传播即可求出导数的运算类型。
入参：
  1. 神经网络节点序号。
      本参数不参与实际计算，仅用于控制、调试跟踪与日志；
  2. lambda 命名，即运算类型。
      支持范围参看第三章第三节神经网络节点支持运算类型；
  3. 待求导数的自变量入参矩阵；
  4. 待求导数的自变量入参位置；
  5. 另一目自变量入参矩阵。
      对于单目运算，本参数为空；
  6. 神经网络节点粒度的超参数配置。
      例如：激活函数的α值、卷积/池化的窗口的滑动步长；
      详见字典表：
          select \* from sm_sc.tb_dic_enum
          where enum_name = 'node_fn_asso_value'
      该参数为二维数组；对于单目运算，本参数为空；
  7. 因变量矩阵；
  8. 自变量的高宽规格；
      一些运算类型可省去传自变量，而只传规格即可。
      包括：agg_concat_x, agg_concat_y, agg_sum, agg_avg,
                 slice_x, slice_y, add, sub 等 |select
  sm_sc.fv_lambda_arr_delta
  (
    100001
    , 'pow'
    , array[[1.23, 3.34],[2.2, 0.25]]
    , 2
    , array[[1.5, 1.3],[0.7, 0.25]]
    , null
    , array[[1.5, 1.3],[0.7, 0.25]] ^\` array[[1.23, 3.34],[2.2, 0.25]]
  );

返回：
  array[[0.6676, 0.6302],[-0.1627, -0.9803]] >> sm_sc.fv_lambda_arr_dloss_dindepdt |反向传播损失函数对节点自变量求导 lambda。
该 lambda 适用于反向传播阶段才能求出导数的运算类型。
入参：
  1. 神经网络节点序号。
      本参数不参与实际计算，仅用于控制、调试跟踪与日志；
  2. lambda 命名，即运算类型。
      支持范围参看第三章第三节神经网络节点支持运算类型；
  3. 待求导数的自变量入参矩阵；
  4. 待求导数的自变量入参位置；
  5. 另一目自变量入参矩阵。
      对于单目运算，本参数为空；
  6. 神经网络节点粒度的超参数配置。
      例如：激活函数的α值、卷积/池化的窗口的滑动步长；
      详见字典表：
          select \* from sm_sc.tb_dic_enum
          where enum_name = 'node_fn_asso_value'
      该参数为二维数组；对于单目运算，本参数为空；
  7. 因变量矩阵；
  8. 损失函数对该神经元因变量导数； |select
  sm_sc.fv_lambda_arr_dloss_dindepdt
  (
    100001
    , 'softmax_x'
    , array[[1.23, 3.34, 0.96],[2.2, 0.25, 7.7]]
    , 2
    , null
    , null
    , sm_sc.fv_standlize_x_softmax(array[[1.23, 3.34, 0.96],[2.2, 0.25, 7.7]])
    , (-\` array[[0.0, 0.0, 1.0],[0.0, 0.0, 1.0]])
      /\` sm_sc.fv_standlize_x_softmax(array[[1.23, 3.34, 0.96],[2.2, 0.25, 7.7]])
  );

返回：
  array[[0.0999, 0.8239, -0.9238],[0.0041, 0.0006, -0.0046]] >> sm_sc.fv_lambda_arr_len |神经网络节点(自变量与因变量)矩阵高宽的审查。
该审查发生在训练准备过程中。
根据入参规格和超参数配置，得出出参高宽规格。
入参：
  1. 神经网络节点序号。
      本参数不参与实际计算，仅用于控制、调试跟踪与日志；
  2. lambda 命名，即运算类型；
      支持范围参看第三章第三节神经网络节点支持运算类型；
  3. 运算入参第一目矩阵高宽规格；
  4. 运算入参第二目矩阵高宽规格；
  5. 超参数配置； |select
  sm_sc.fv_lambda_arr_len
  (
    1000001
  , 'conv_2d'
  , array[70, 784]
  , array[1, 25]
  , array[28, 5, 5, 1, 1, 2, 2, 2, 2, 0]
  );

返回：
  array[70, 784] >> >>#### l. 机器学习的神经网络专用： >> >>> 函数名|函数说明|调用举例 >>> :-|:-|:- >> sm_sc.fv_idx_samp_by_samp |采样再采样序号跟踪。
入参：
  1. 本次采样前样本的原始序号的范围集合；
  2. 本次采样到的样本在旧集合的位置序号的范围集合； |select
  sm_sc.fv_idx_samp_by_samp
  (
    array
    [
      int4range(1, 3, '[]'),
      int4range(8, 12, '[]'),
      int4range(13, 15, '[]')
    ],
    array
    [
      int4range(4, 6, '[]'),
      int4range(8, 12, '[]')
    ]
  )

返回：
  array[int4range(8, 10, '[]'),
           int4range(12, 12, '[]'),
           int4range(13, 15, '[]')] >> sm_sc.ft_nn_buff_slice_rand_pick |从规约的 buff 表中分组随机拣取单次训练的小批量。
当次批量内记录不重复。
入参：
  1. 训练任务标识；
  2. 训练集所有样本按照分类分组排序后的样本编号范围划定；
  3. 训练集中每个分类分组采用数量。
      不同分组可以配置不同采样数量；
出参列：
  1. 抽到的样本编号；
  2. 抽到样本的入参向量； |-- 以 mnist 数据集，配置训练任务为例，
-- 假定配置训练任务编号为：2022030501；
select
  o_ord_no,
  o_slice_rand_pick
from
  sm_sc.ft_nn_buff_slice_rand_pick
  (
    2022030501,
    array
    [
      int4range(1, 5923, '[]'),
      int4range(5924, 12665, '[]'),
      int4range(12666, 18623, '[]'),
      int4range(18624, 24754, '[]'),
      int4range(24755, 30596, '[]'),
      int4range(30597, 36017, '[]'),
      int4range(36018, 41935, '[]'),
      int4range(41936, 48200, '[]'),
      int4range(48201, 54052, '[]'),
      int4range(54053, 60001, '[]')
    ],
    array_fill(7, array[10])
  ) tb_a;

返回：
  -- 10个分类分组，每组随机抽取7个样本，
  -- 共70条采样。 >> sm_sc.fv_nn_in_out |训练集测试集单条输入，返回判断或预测结果向量。
本函数依托于临时表 sm_sc.__vt_tmp_nn_node 实现。
入参：
  1. 输出模型的训练任务标识；
  2. 测试集或验证集单条样本入参向量； |-- 假定已经有训练好的模型任务：2022030501。
select
  ord_no,
  i_y,
  sm_sc.fv_nn_in_out
  (
    2022030501,
    array[i_x]
  ) as a_pred_out_arr
from sm_sc.tb_nn_train_input_buff
where work_no = 2022030501
  and ord_no = round((random() * 60001) + 0.5)

返回(其中 a_pred_out_arr 为返回值，i_y 做为真实值对比)：
  i_y:
    array[0.0, 1.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0]
  a_pred_out_arr:
    array[[0.0001, 0.9193, 0.0028, 0.0337, 0.0010, 0.0048, 0.0013, 0.0125, 0.0190, 0.0053]] >> sm_sc.ft_nn_node2node_path |两节点之间的前向路径
入参：
  1. 输出模型的训练任务标识；
  2. 起始节点；
  3. 到达节点； |-- 假定已经有训练的模型任务：2022030501。
select
  o_back_node_no,
  o_fore_node_no,
  o_path_ord_no,
  o_node_type
from sm_sc.ft_nn_node2node_path(2022030501, 103010025, 104030008)

注：
  返回字段 o_node_type 的枚举值：
    1. main: 路径上沿途节点;
    2. leaf: 非沿途节点，但是是配套入参;

返回：
  o_back_node_no    o_fore_node_no    o_path_ord_no    o_node_type
  103010015             104010008             1                          leaf
  103010025             104010008             2                          main
  103010035             104010008             3                          leaf
  103010044             104010008             4                          leaf
  104010008             104020008             1                          main
  104020008             104030008             1                          main >> sm_sc.fv_nn_node2node_val |两节点之间的前向传播数值
入参：
  1. 输出模型的训练任务标识；
  2. 起始节点；
  3. 到达节点； |-- 假定已经有训练的模型任务：2022030501。
select sm_sc.fv_nn_node2node_val(2022030501, 103010025, 104030008)

返回(一个二维数组): 略 >> >>#### m. 机器学习的编码、解码： >> >>> 函数名|函数说明|调用举例 >>> :-|:-|:- >> sm_sc.fv_huffman |霍夫曼编码。
本函数依托于临时表 sm_sc.__vt_tmp_huffman 实现。
入参：
  1. 原始数值集合组成的一维数组； |select
  sm_sc.fv_huffman
  (
    array[1, 2, 3, 8, 9, 13, 19]
  );

返回：
  array[B'00101', B'00100',B'0011',B'001',B'11',B'10',B'01'] >> sm_sc.fv_onehot |独热编码。
入参：
  1. 原始数值集合组成的一维数组； |select
  sm_sc.fv_onehot
  (
    array[1, 2, 3, 1, 4, 3, 5, 6]
  );

返回：
  array
  [[1.0, 0.0, 0.0, 0.0, 0.0, 0.0]
  ,[0.0, 1.0, 0.0, 0.0, 0.0, 0.0]
  ,[0.0, 0.0, 1.0, 0.0, 0.0, 0.0]
  ,[1.0, 0.0, 0.0, 0.0, 0.0, 0.0]
  ,[0.0, 0.0, 0.0, 1.0, 0.0, 0.0]
  ,[0.0, 0.0, 1.0, 0.0, 0.0, 0.0]
  ,[0.0, 0.0, 0.0, 0.0, 1.0, 0.0]
  ,[0.0, 0.0, 0.0, 0.0, 0.0, 1.0]] >> >>#### n. 机器学习的损失函数： >> >>> 函数名|函数说明|调用举例 >>> :-|:-|:- >> sm_sc.fv_loss |求取损失函数。
入参：
  1. 损失函数类型；
      详见字典表：
          select \* from sm_sc.tb_dic_enum
          where enum_name = 'loss_fn_type'
  2. 训练输出预测值矩阵；
  3. 训练集的真实值编码； |select
  sm_sc.fv_loss
  (
    1
  , array[[1, 2, 3],[2, 3, 4]]
  , array[[1.1, 2.1, 3.2],[2.2, 3.3, 4.2]]
  )

返回：
  0.3391 >> sm_sc.fv_dloss_dz |损失函数对预测值求导。
入参：
  1. 损失函数类型；
      详见字典表：
          select \* from sm_sc.tb_dic_enum
          where enum_name = 'loss_fn_type'
  2. 训练输出预测值矩阵；
  3. 训练集的真实值编码； |select
  sm_sc.fv_dloss_dz
  (
    1
  , array[[1, 2, 3],[2, 3, 4]]
  , array[[1.1, 2.1, 3.2],[2.2, 3.3, 4.2]]
  )

返回：
  array[[-0.0707, -0.0707, -0.1414],[-0.1414, -0.2121, -0.1414]] >> >>#### o. 复数运算： >> >>> 函数名|函数说明|调用举例 >>> :-|:-|:- >> sm_sc.fv_opr_add |复数相加 |select
  sm_sc.fv_opr_add
  (
    (12.3, -12.3),
    (-45.6, -45.6)
  );

返回：
  (-33.3, -57.9) >> sm_sc.fv_opr_sub |复数相减 |select
  sm_sc.fv_opr_sub
  (
    (12.3, -12.3),
    (-45.6, -45.6)
  );

返回：
  (57.9, 33.3) >> sm_sc.fv_opr_sub |复数相反数 |select
  sm_sc.fv_opr_sub
  (
    (12.3, -12.3)
  );

返回：
  (-12.3, 12.3) >> sm_sc.fv_opr_mul |复数相乘 |select
  sm_sc.fv_opr_mul
  (
    (12.3, -12.3),
    (-45.6, -45.6)
  );

返回：
  (1121.76, 0.0) >> sm_sc.fv_opr_div |复数相除 |select
  sm_sc.fv_opr_div
  (
    (12.3, -12.3),
    (-45.6, -45.6)
  );

返回：
  (0.0 ,0.2697) >> sm_sc.fv_opr_div |复数倒数 |select
  sm_sc.fv_opr_div
  (
    (12.3, -12.3)
  );

返回：
  (0.0407, 0.0407) >> sm_sc.fv_opr_pow |复数幂 |select
  sm_sc.fv_opr_pow
  (
    (2.3, -0.8),
    (1.6, -3.6)
  );

返回：
  (-1.0288, 0.7009) >> sm_sc.fv_opr_exp |复数自然常数幂 |select
  sm_sc.fv_opr_exp
  (
    (2.3, -0.8)
  );

返回：
  (6.9491, -7.1550) >> sm_sc.fv_opr_log |复数对数 |select
  sm_sc.fv_opr_log
  (
    (12.3, -12.3),
    (-45.6, -45.6)
  );

返回：
  (1.5671, -0.3940) >> sm_sc.fv_opr_ln |复数自然对数 |select
  sm_sc.fv_opr_ln
  (
    (12.3, -12.3)
  );

返回：
  (2.8562, -0.7854) >> sm_sc.fv_sin |复数正弦 |select
  sm_sc.fv_sin
  (
    (2.3, -2.3)
  );

返回：
  (3.7563, 3.2894) >> sm_sc.fv_cos |复数余弦 |select
  sm_sc.fv_cos
  (
    (3.3, -1.3)
  );

返回：
  (-0.3109, 1.6771) >> sm_sc.fv_opr_real |复数实部 |select
  sm_sc.fv_opr_real
  (
    (2.3, -2.3)
  );

返回：
  2.3 >> sm_sc.fv_opr_imaginary |复数虚部 |select
  sm_sc.fv_opr_imaginary
  (
    (2.3, -2.3)
  );

返回：
  -2.3 >> sm_sc.fv_opr_norm |复数的模 |select
  sm_sc.fv_opr_norm
  (
    (2.3, -2.3)
  );

返回：
  3.2527 >> sm_sc.fv_opr_conjugate |复数共轭 |select
  sm_sc.fv_opr_conjugate
  (
    (2.4, -6.3)
  );

返回：
  (2.4, 6.3) >> sm_sc.fv_opr_conjugate_45 |复数实虚对换 |select
  sm_sc.fv_opr_conjugate_45
  (
    (2.4, -6.3)
  );

返回：
  (-6.3, 2.4) >> sm_sc.fv_opr_round |复数四舍五入 |select
  sm_sc.fv_opr_round
  (
    (12.34854, -12.3483)
  );

返回：
  (12, -12) >> sm_sc.fv_opr_floor |复数数位地板值 |select
  sm_sc.fv_opr_floor
  (
    (1482.37878, -178672.3543)
  , -1
  );

返回：
  (1480, -178680) >> sm_sc.fv_opr_ceil |复数数位天花板值 |select
  sm_sc.fv_opr_ceil
  (
    (12.3233333, -12.3788)
  , 2
  );

返回：
  (12.33, -12.37) >> sm_sc.fv_opr_trunc |复数数位截取值 |select
  sm_sc.fv_opr_trunc
  (
    (12.31231, -12.32333)
  , 3
  );

返回：
  (12.312, -12.323) >> >>#### p. 对 postgresql 补充的 udf 公共函数： >> >>> 函数名|函数说明|调用举例 >>> :-|:-|:- >> sm_sc.fa_coalesce |免空聚合 |select
  sm_sc.fa_coalesce(a_val) as a_coal_agg,
  sm_sc.fa_coalesce(a_val order by a_no) as a_coal_agg_asc,
  sm_sc.fa_coalesce(a_val order by a_no desc) as a_coal_agg_desc
from
(
  select null as a_val, 1 as a_no
  union all
  select 'abc', 3
  union all
  select 'cde', 2
  union all
  select 'fgh', 4
  union all
  select null, 5
) tb_a(a_val)；

返回：
  a_coal_agg: 'abc'
  a_coal_agg_asc: 'cde'
  a_coal_agg_desc: 'fgh' >> sm_sc.fa_prod |连乘聚合 |select
  sm_sc.fa_prod(a_val) as a_prod_agg
from
(
  select 3.0 as a_val
  union all
  select 2.5
  union all
  select 4.8
) tb_a(a_val)

返回：36.0 >> sm_sc.fv_enum_rand_pick |枚举随机拣取，不重复。
入参：
  1. 枚举类型名称；
  2. 随机采样数量； |-- create type sm_sc.typ_enum_day as
-- enum('SUN','MON','TUE','WED','THU','FRI','SAT');
select
  sm_sc.fv_enum_rand_pick
  (
    'sm_sc.typ_enum_day'
  , 3
  );

返回：array['TUE', 'MON', 'SUN'] >> sm_sc.fv_enum_rand |枚举随机取值，可重复。
入参：
  1. 枚举类型名称；
  2. 随机采样数量； |-- create type sm_sc.typ_enum_day as
-- enum('SUN','MON','TUE','WED','THU','FRI','SAT');
select
  sm_sc.fv_enum_rand
  (
    'sm_sc.typ_enum_day'
  , 3
  );

返回：array['TUE', 'MON', 'MON'] >> sm_sc.fv_o_distance |两向量欧式距离。
入参：
  1. 向量1；
  2. 向量2； |select
  sm_sc.fv_o_distance
  (
    array[1.0, 2.0]
  , array[4.0, 6.0]
  );

返回：5.0 >> >>#### q. 导数公式推导： >> >>> 函数名|函数说明|调用举例 >>> :-|:-|:- >>> sm_sc.fv_gradient |代数式导数推导。
本函数依托于以下临时表实现。
  1. sm_sc._vt_fn_grad__graph；
  2. sm_sc._vt_fn_grad__algebra；
  3. sm_sc._vt_fn_grad__forward；
  4. sm_sc._vt_fn_grad__chain；
重载1.
  入参：
    1. 求导目标自变量名称；
    2. 代数式的序列化 json；
重载2.
  入参：
    1. 求导目标自变量名称；
    2. 代数式文本表达； |select
  sm_sc.fv_gradient
  (
    'v_x' :: text,
    '
    {
      "out_param": "v_z",
      "opr": "sm_sc.fv_opr_pow",
      "in_params":
      [
        {
          "out_param": "v_x"
        },
        {
          "out_param": "v_x"
        }
      ]
    }
    ' :: jsonb
  );

返回：
  (((v_x ^ v_x) * ln(v_x)) + (v_x * (v_x ^ (v_x - 1.00000000))))
--------------------------
select
  sm_sc.fv_gradient
  (
    'v_x'
  , '(v_x * v_y) + exp(v_x * v_y) + power(v_x, 2)'::text
  );

返回：(v_y + (2.00000000 * v_x) + (exp((v_x * v_y)) * v_y)) >>> sm_sc.ft_gradient |代数式导数数值计算。
入参：
  1. 求导目标自变量名称列表；
  2.包含自变量代入数值的代数式的序列化 json；
出参列:
  1. 求导目标自变量名称；
  2.导数值； |select
  o_indepdt_vars_name,
  o_grad
from
sm_sc.ft_gradient
(
  array['v_x_in', 'v_y_in'],
  '
  {
    "out_param": "v_z_in",
    "opr": "sm_sc.fv_opr_add",
    "in_params":
    [
      {
        "opr": "sm_sc.fv_opr_mul",
        "in_params":
        [
          {
            "out_param": "v_x_in",
            "out_value": 1.5
          },
          {
            "out_param": "v_y_in",
            "out_value": 1.5
          }
        ]
      },
      {
        "opr": "sm_sc.fv_opr_exp",
        "in_params":
        [
          {
            "opr": "sm_sc.fv_opr_mul",
            "in_params":
            [
              {
                "out_param": "v_x_in",
                "out_value": 1.5
              },
              {
                "out_param": "v_y_in",
                "out_value": 1.5
              }
            ]
          }
        ]
      },
      {
        "opr": "sm_sc.fv_opr_pow",
        "in_params":
        [
          {
            "out_param": "v_x_in",
            "out_value": 1.5
          },
          {
            "out_value": 2
          }
        ]
      }
    ]
  }
  '::jsonb
);

返回：
  o_indepdt_vars_name        o_grad
  v_x_in                                18.73160376
  v_y_in                                15.73160376 >>> sm_sc.ft_gradient_graph |代数式文本导数推导(输出为树形结构)。
入参：
  1. 求导目标自变量名称；
  2.代数式文本表达；
出参列：
  1. 中间因变量；
  2. 中间自变量；
  3. 常量数值；
  4. 入参位置顺序号；
  5. 运算操作类型； |select
  o_out_param_x,
  o_in_param_x,
  o_in_value_x,
  o_param_loc_x,
  o_out_opr_x
from sm_sc.ft_gradient_graph('v_x', '3 * v_x * v_y'::text)

返回：
  o_out_param_x                                              o_in_param_x                                                      o_in_value_x      o_param_loc_x        o_out_opr_x
                                                                          1ecb1aeee9bba546541394669cfbb68e                                            1        
  04460d66750dc2c536e3aef4a66df70a        3a98ec1e00cca8e4d330b49c896699c3                                            1                                sm_sc.fv_opr_mul
  04460d66750dc2c536e3aef4a66df70a        e38869fbedbaa92e1aef2ee286e1a751                                            2                                sm_sc.fv_opr_mul
  1ecb1aeee9bba546541394669cfbb68e        04460d66750dc2c536e3aef4a66df70a                                            1                                sm_sc.fv_opr_add
  3a98ec1e00cca8e4d330b49c896699c3                                                                                      1.0                        1                                
  e38869fbedbaa92e1aef2ee286e1a751        v_y                                                                                                      1                                sm_sc.fv_opr_mul
  e38869fbedbaa92e1aef2ee286e1a751                                                                                      3.0                        1                                sm_sc.fv_opr_mul >>> sm_sc.ft_gradient_opr_graph |基础算子的导数推导。
入参：
  1. 求导目标自变量名称；
  2.运算操作类型；
  3.运算操作类型；求导目标自变量入参位置顺序号；
  4.其他入参名称清单。
     如果是常量则填 null；
  5.其他入参常量清单。
     如果是量则填 null；
  5.指定求导结果变量名称； |select
  o_out_param,
  o_in_param,
  o_in_value,
  o_param_loc,
  o_out_opr,
from sm_sc.ft_gradient_opr_graph
(
  'x',
  'sm_sc.fv_opr_div',
  2,
  null,
  array[1.2]
);

返回：
  o_out_param                                                o_in_param                                                  o_in_value    o_param_loc    o_out_opr
  b0ae53f5ac4c3091753f8e4e4c352039      x                                                                                            1                        sm_sc.fv_opr_pow
  b0ae53f5ac4c3091753f8e4e4c352039                                                                            -2.0                2                        sm_sc.fv_opr_pow
  6da6d6058c859b21588e829d71a7e6b3                                                                            1.2                  1                        sm_sc.fv_opr_mul
  6da6d6058c859b21588e829d71a7e6b3      b0ae53f5ac4c3091753f8e4e4c352039                              2                        sm_sc.fv_opr_mul
  8881836ea7405adb788660db93f5f116                                                                            0.0                  1                        sm_sc.fv_opr_sub
  8881836ea7405adb788660db93f5f116      6da6d6058c859b21588e829d71a7e6b3                              2                        sm_sc.fv_opr_sub
                                                                        8881836ea7405adb788660db93f5f116                              1                         >>> sm_sc.fv_gradient_jacobi |雅可比矩阵导数推导。
入参：
  1. 自变量名称清单；
  2. 代数式清单； |select
  sm_sc.fv_gradient_jacobi
  (
    array['r', 'a', 'b']
  , array['r*cos(a)\*sin(b)', 'r\*sin(a)\*sin(b)', 'r\*cos(b)']
  )

返回：
  array
  [
    [
      '(sin(b) \* cos(a))',
      '((sin(b) \* r) \* (0.0 - sin(a)))',
      '((r \* cos(a)) \* cos(b))'
    ],
    [
      '(sin(b) \* sin(a))',
      '((r \* sin(b)) \* cos(a))',
      '((r \* sin(a)) \* cos(b))'
    ],
    [
      'cos(b)',
      '0.0',
      '(r \* (0.0 - sin(b)))'
    ]
  ] >>> sm_sc.fv_gradient_opr |基础算子的数值求导。
入参：
  1. 求导目标自变量值；
  2.运算操作类型；
  3. 求导目标自变量入参顺序位置；
  4. 因变量值；
  5. 另一目自变量入参数值； |select sm_sc.fv_gradient_opr
(
  8.0,
  'sm_sc.fv_opr_log',
  2,
  null,
  2.0
);

返回：0.18033688 >> >>#### r. 一些矩阵运算求导： >>> 函数名|函数说明|调用举例 >>> :-|:-|:- >>> sm_sc.fv_d_new |数值求导 new。
入参：
  1. 自变量矩阵；
  2. new 函数高宽方向重复次数； |select
  sm_sc.fv_d_new
  (
    array[[0.5, -0.2, 0.25, 1.3, -0.9, -0.1]
         ,[-0.5, -0.2, -0.25, 1.3, 0.9, 0.1]
         ,[0.5, 0.2, 0.25, -1.3, 0.9, 0.05]],
    array[1, 3]
  );

返回：
  array[[-0.15, 1.0],[0.15, 1.2],[1.65, -1.05]] >>> sm_sc.fv_d_activate_elu |数值求导 elu。
入参：
  1. 自变量矩阵；
  2. α值； |select
  sm_sc.fv_d_activate_elu
  (
    array[[1.0, -2.0],[3.0, 4.0]]
  , 0.3
  );

返回：
  array[[1.0, 0.0406],[1.0, 1.0]] >>> sm_sc.fv_d_activate_gelu |数值求导 gelu。
入参：
  1. 自变量矩阵； |select
  sm_sc.fv_d_activate_gelu
  (
    array[[1.0, -2.0],[3.0, 4.0]]
  );

返回：
  array[[1.0830, -0.0861],[1.0116, 1.0003]] >>> sm_sc.fv_d_activate_leaky_relu |数值求导 leaky_relu。
入参：
  1. 自变量矩阵；
  2. α值； |select
  sm_sc.fv_d_activate_leaky_relu
  (
    array[[1.0, -2.0],[3.0, 4.0]]
  , 0.3
  );

返回：
  array[[1.0000, 0.3000],[1.0000, 1.0000]] >>> sm_sc.fv_d_activate_relu |数值求导 relu。
入参：
  1. 自变量矩阵； |select
  sm_sc.fv_d_activate_relu
  (
    array[[1.0, -2.0],[3.0, 4.0]]
  );

返回：
  array[[1.0000, 0.0000],[1.0000, 1.0000]] >>> sm_sc.fv_d_activate_selu |数值求导 selu。
入参：
  1. 自变量矩阵； |select
  sm_sc.fv_d_activate_selu
  (
    array[[1.0, -2.0],[3.0, 4.0]]
  );

返回：
  array[[1.0507, 0.2379],[1.0507, 1.0507]] >>> sm_sc.fv_d_activate_sigmoid |数值求导 sigmoid。
入参：
  1. 自变量矩阵； |select
  sm_sc.fv_d_activate_sigmoid
  (
    array[[1.0, -2.0],[3.0, 4.0]]
  );

返回：
  array[[0.1966, 0.1050],[0.0452, 0.0177]] >>> sm_sc.fv_d_activate_softplus |数值求导 softplus。
入参：
  1. 自变量矩阵； |select
  sm_sc.fv_d_activate_softplus
  (
    array[[1.0, -2.0],[3.0, 4.0]]
  );

返回：
  array[[0.7311, 0.1192],[0.9526, 0.9820]] >>> sm_sc.fv_d_activate_swish |数值求导 swish。
入参：
  1. 自变量矩阵； |select
  sm_sc.fv_d_activate_swish
  (
    array[[1.0, -2.0],[3.0, 4.0]]
  );

返回：
  array[[0.9277, -0.0908],[1.0881, 1.0527]] >>> sm_sc.fv_d_standlize_softmax_dloss_dindepdt |单行或单列数组 softmax 的损失函数对自变量求导。
入参：
  1. 因变量矩阵：
  2. 损失函数对因变量求导矩阵；
  3. 自变量矩阵： |select
  sm_sc.fv_d_standlize_softmax_dloss_dindepdt
  (
    sm_sc.fv_standlize_mx_softmax(array[[1, 2, 3, 4, 5]]),
    -\` array[[0.0, 0.0, 0.0, 0.0, 1.0]] /\` sm_sc.fv_standlize_mx_softmax(array[[1, 2, 3, 4, 5]]),
    array[[1, 2, 3, 4, 5]]
  );

返回：
  array[[0.0117, 0.0317, 0.0861, 0.2341, -0.3636]] >>> sm_sc.fv_d_standlize_zscore_dloss_dindepdt |单行或单列数组 zscore 的损失函数对自变量求导。
入参：
  1. 因变量矩阵：
  2. 损失函数对因变量求导矩阵；
  3. 自变量矩阵： |select
  sm_sc.fv_d_standlize_zscore_dloss_dindepdt
  (
    sm_sc.fv_standlize_mx_zscore(array[[1, 2, 3, 4, 5]]),
    -\` array[[0.0, 0.0, 0.0, 0.0, 1.0]] /\` sm_sc.fv_standlize_mx_softmax(array[[1, 2, 3, 4, 5]]),
    array[[1, 2, 3, 4, 5]]
  );

返回：
  array[[0.0000, 0.0000, 0.0000, 0.0000, -5.7640]] >>> sm_sc.fv_d_standlize_mx_softmax_dloss_dindepdt |全矩阵 softmax 损失函数对自变量求导。
入参：
  1. 因变量矩阵：
  2. 损失函数对因变量求导矩阵；
  3. 自变量矩阵： |select
  sm_sc.fv_d_standlize_mx_softmax_dloss_dindepdt
  (
    sm_sc.fv_standlize_mx_softmax(array[[1, 5],[2, 4],[3, 3],[4, 2],[5, 1]]),
    (-\` array[[0.0, 1.0],[0.0, 0.0],[0.0, 0.0],[0.0, 0.0],[1.0, 0.0]]
      /\` sm_sc.fv_standlize_mx_softmax(array[[1, 5],[2, 4],[3, 3],[4, 2],[5, 1]])),
    array[[1, 5],[2, 4],[3, 3],[4, 2],[5, 1]]
  );

返回：
  array[[0.0117, -0.3636, 0.0317, 0.2341, 0.0861]
          ,[0.0861, 0.2341, 0.0317, -0.3636, 0.0117]] >>> sm_sc.fv_d_standlize_mx_zscore_dloss_dindepdt |全矩阵 zscore 损失函数对自变量求导。
入参：
  1. 因变量矩阵：
  2. 损失函数对因变量求导矩阵；
  3. 自变量矩阵： |select
  sm_sc.fv_d_standlize_mx_zscore_dloss_dindepdt
  (
    sm_sc.fv_standlize_mx_zscore(array[[1, 5],[2, 4],[3, 3],[4, 2],[5, 1]]),
    (-\` array[[0.0, 1.0],[0.0, 0.0],[0.0, 0.0],[0.0, 0.0],[1.0, 0.0]]
      /\` sm_sc.fv_standlize_mx_zscore(array[[1, 5],[2, 4],[3, 3],[4, 2],[5, 1]])),
    array[[1, 5],[2, 4],[3, 3],[4, 2],[5, 1]]
  );

返回：
  array[[0.0000, -5.4500, 0.0000, 0.0000, 0.0000]
          ,[0.0000, 0.0000, 0.0000, -5.4500, 0.0000]] >>> sm_sc.fv_d_standlize_x_softmax_dloss_dindepdt |x方向 softmax 损失函数对自变量求导。
入参：
  1. 因变量矩阵：
  2. 损失函数对因变量求导矩阵；
  3. 自变量矩阵： |select
  sm_sc.fv_d_standlize_x_softmax_dloss_dindepdt
  (
    sm_sc.fv_standlize_x_softmax(array[[1, 2, 3, 4, 5],[5, 4, 3, 2, 1]]),
    (-\` array[[0.0, 0.0, 0.0, 0.0, 1.0],[1.0, 0.0, 0.0, 0.0, 0.0]]
      /\` sm_sc.fv_standlize_x_softmax(array[[1, 2, 3, 4, 5],[5, 4, 3, 2, 1]])),
    array[[1, 2, 3, 4, 5],[5, 4, 3, 2, 1]]
  );

返回：
  array[[0.0117, 0.0317, 0.0861, 0.2341, -0.3636]
          ,[-0.3636, 0.2341, 0.0861, 0.0317, 0.0117]] >>> sm_sc.fv_d_standlize_x_zscore_dloss_dindepdt |x方向 zscore 损失函数对自变量求导。
入参：
  1. 因变量矩阵：
  2. 损失函数对因变量求导矩阵；
  3. 自变量矩阵： |select
  sm_sc.fv_d_standlize_x_zscore_dloss_dindepdt
  (
    sm_sc.fv_standlize_x_zscore(array[[1, 2, 3, 4, 5],[5, 4, 3, 2, 1]]),
    (-\` array[[0.0, 0.0, 0.0, 0.0, 1.0],[1.0, 0.0, 0.0, 0.0, 0.0]]
      /\` sm_sc.fv_standlize_x_zscore(array[[1, 2, 3, 4, 5],[5, 4, 3, 2, 1]])),
    array[[1, 2, 3, 4, 5],[5, 4, 3, 2, 1]]
  );

返回：
  array[[0.0000, 0.0000, 0.0000, 0.0000, -2.9000]
          ,[-2.9000, 0.0000, 0.0000, 0.0000, 0.0000]] >>> sm_sc.fv_d_standlize_y_softmax_dloss_dindepdt |y方向 softmax 损失函数对自变量求导。
入参：
  1. 因变量矩阵：
  2. 损失函数对因变量求导矩阵；
  3. 自变量矩阵： |select sm_sc.fv_d_standlize_y_softmax_dloss_dindepdt
  (
    sm_sc.fv_standlize_y_softmax(array[[1, 5],[2, 4],[3, 3],[4, 2],[5, 1]]),
    (-\` array[[0.0, 1.0],[0.0, 0.0],[0.0, 0.0],[0.0, 0.0],[1.0, 0.0]]
      /\` sm_sc.fv_standlize_y_softmax(array[[1, 5],[2, 4],[3, 3],[4, 2],[5, 1]])),
    array[[1, 5],[2, 4],[3, 3],[4, 2],[5, 1]]
  );

返回：
  array[[0.0117, -0.3636],[0.0317, 0.2341]
          ,[0.0861, 0.0861],[0.2341, 0.0317],[-0.3636, 0.0117]] >>> sm_sc.fv_d_standlize_y_zscore_dloss_dindepdt |y方向 zscore 损失函数对自变量求导。
入参：
  1. 因变量矩阵：
  2. 损失函数对因变量求导矩阵；
  3. 自变量矩阵： |select sm_sc.fv_d_standlize_y_zscore_dloss_dindepdt
  (
    sm_sc.fv_standlize_y_zscore(array[[1, 5],[2, 4],[3, 3],[4, 2],[5, 1]]),
    (-\` array[[0.0, 1.0],[0.0, 0.0],[0.0, 0.0],[0.0, 0.0],[1.0, 0.0]]
      /\` sm_sc.fv_standlize_y_zscore(array[[1, 5],[2, 4],[3, 3],[4, 2],[5, 1]])),
    array[[1, 5],[2, 4],[3, 3],[4, 2],[5, 1]]
  );

返回：
  array[[0.0000, -2.9000],[0.0000, 0.0000]
          ,[0.0000, 0.0000],[0.0000, 0.0000],[-2.9000, 0.0000]] >> >>#### s. 线性代数： >> >>> 函数名|函数说明|调用举例 >>> :-|:-|:- >> sm_sc.fv_mx_col_mix |初等列变换，某一位置参照同行另一位置清零。
入参：
  1. 原始矩阵：
  2. 将要被清零位置的列序号；
  3. 将要被清零位置的行序号：
  4. 倍数列： |select
  sm_sc.fv_mx_col_mix
  (
    array[[1.9, 34.5, 0.55, 45.7, 400.5]
         ,[45.9, 4.6, 34.5, 0.55, 45.7]
         ,[3.2, 7.7, 1.9, 34.5, 0.55]
         ,[4.7, 9.0, 4.6, 34.5, 0.55]]
    , 2
    , 3
    , 4
  );

返回：
  array[[1.9000, 24.3003, 0.5500, 45.7000, 400.5000]
          ,[45.9000, 4.4772, 34.5000, 0.5500, 45.7000]
          ,[3.2000, 0.0000, 1.9000, 34.5000, 0.5500]
          ,[4.7000, 1.3000, 4.6000, 34.5000, 0.5500]] >> sm_sc.fv_mx_row_mix |初等行变换，某一位置参照同列另一位置清零。
入参：
  1. 原始矩阵：
  2. 将要被清零位置的行序号；
  3. 将要被清零位置的列序号：
  4. 倍数行： |select
  sm_sc.fv_mx_row_mix
  (
    array[[1.9, 34.5, 0.55, 45.7, 400.5]
         ,[45.9, 4.6, 34.5, 0.55, 45.7]
         ,[3.2, 7.7, 1.9, 34.5, 0.55]
         ,[4.7, 9.0, 4.6, 34.5, 0.55]]
    , 2
    , 3
    , 4
  );

返回：
  array[[1.9000, 34.5000, 0.5500 ,45.7000, 400.5000]
          ,[10.6500, -62.9000, 0.0000, -258.2000, 41.5750]
          ,[3.2000, 7.7000, 1.9000, 34.5000, 0.5500]
          ,[4.7000, 9.0000, 4.6000, 34.5000, 0.5500]] >> sm_sc.fv_mx_determinant |矩阵行列式。
本函数依托于临时表 sm_sc.__vt_tmp_matrix 实现。
入参：
  1. 原始矩阵： |select
  sm_sc.fv_mx_determinant
  (
    array[[1, 2, 3],[0, 8, 9],[4, 5, 6]]
  );

返回：-21.0 >> sm_sc.fv_mx_inversion |逆矩阵。
本函数依托于临时表 sm_sc.__vt_tmp_matrix 实现。
入参：
  1. 原始矩阵： |select
  sm_sc.fv_mx_inversion
  (
    array[[1, 2, 3],[0, 8, 9],[4, 5, 6]]
  );

返回：
  array[[-0.1429, -0.1429, 0.2857]
          ,[-1.7143, 0.2857, 0.4286]
          ,[1.5238, -0.1429, -0.3810]] >> sm_sc.fv_arr_norm_1 |向量1范数。
入参：
  1. 原始矩阵： |select
  sm_sc.fv_arr_norm_1
  (
    array[1, 2, 3]
  );

返回：6.0 >> sm_sc.fv_arr_norm_2 |向量2范数。
入参：
  1. 原始矩阵： |select
  sm_sc.fv_arr_norm_2
  (
    array[1, 2, 3]
  );

返回：3.7417 >> sm_sc.fv_arr_norm_nega_inf |向量负无穷范数。
入参：
  1. 原始矩阵： |select
  sm_sc.fv_arr_norm_nega_inf
  (
    array[1, 2, 3]
  );

返回：1.0 >> sm_sc.fv_arr_norm_posi_inf |向量正无穷范数。
入参：
  1. 原始矩阵： |select
  sm_sc.fv_arr_norm_posi_inf
  (
    array[1, 2, 3]
  );

返回：3.0 >> sm_sc.fv_arr_norm_p |向量p范数。
入参：
  1. 原始矩阵：
  2. 范数级数 p： |select
  sm_sc.fv_arr_norm_p
  (
    array[1, 2, 3]
  , 3
  );

返回：3.3079 >> sm_sc.fv_mx_norm_col |列和范数 1-范数 列模。
入参：
  1. 原始矩阵： |select
  sm_sc.fv_mx_norm_col
  (
    array[[1, -2, 0, 7],[5, 0, 3, 4]
            ,[0, 0, 0, 0],[0, -2, 0, -6]]
  );

返回：17.0 >> sm_sc.fv_mx_norm_inf |行和范数 无穷-范数 行模。
入参：
  1. 原始矩阵： |select
  sm_sc.fv_mx_norm_inf
  (
    array[[1, -2, 0, 7],[5, 0, 3, 4]
            ,[0, 0, 0, 0],[0, -2, 0, -6]]
  );

返回：12.0 >> sm_sc.fv_mx_norm_l0 |L0-范数。
入参：
  1. 原始矩阵： |select
  sm_sc.fv_mx_norm_l0
  (
    array[[1, -2, 0, 7],[5, 0, 3, 4]
            ,[0, 0, 0, 0],[0, -2, 0, -6]]
  );

返回：8.0 >> sm_sc.fv_mx_norm_l1 |L1-范数。
入参：
  1. 原始矩阵： |select
  sm_sc.fv_mx_norm_l1
  (
    array[[1, -2, 0, 7],[5, 0, 3, 4]
            ,[0, 0, 0, 0],[0, -2, 0, -6]]
  );

返回：30.0 >> sm_sc.fv_mx_norm_l2_f |L2(F)-范数。
入参：
  1. 原始矩阵： |select
  sm_sc.fv_mx_norm_l2_f
  (
    array[[1, -2, 0, 7],[5, 0, 3, 4]
            ,[0, 0, 0, 0],[0, -2, 0, -6]]
  );

返回：12.0 >> sm_sc.fv_mx_norm_l21 |L21-范数。
入参：
  1. 原始矩阵： |select
  sm_sc.fv_mx_norm_l21
  (
    array[[1, -2, 0, 7],[5, 0, 3, 4]
            ,[0, 0, 0, 0],[0, -2, 0, -6]]
  );

返回：20.9773 >> sm_sc.fv_mx_is_symmetry |判断矩阵是否对称矩阵。
入参：
  1. 原始矩阵： |select
  sm_sc.fv_mx_is_symmetry
  (
    array[[1, -2, 0, 7],[5, 0, 3, 4]
            ,[0, 0, 0, 0],[0, -2, 0, -6]]
  );

返回：false >> sm_sc.fv_mx_rank |矩阵的秩。
本函数依托于临时表 sm_sc.__vt_tmp_matrix 实现。
入参：
  1. 原始矩阵： |select
  sm_sc.fv_mx_rank
  (
    array[[1, -2, 0, 7],[5, 0, 3, 4]
            ,[0, 0, 0, 0],[0, -2, 0, -6]]
  );

返回：3 >> sm_sc.fv_mx_row_step |行阶梯矩阵，上梯形。
本函数依托于临时表 sm_sc.__vt_tmp_matrix 实现。
入参：
  1. 原始矩阵： |select
  sm_sc.fv_mx_row_step
  (
    array[1, 2, 3]
  );

返回：
  array[[1.0000, 2.0000, 3.0000]
          ,[0.0000, 8.0000, 9.0000]
          ,[0.0000, 0.0000, -2.6250]] >> sm_sc.fv_mx_rows_step_simple |行阶梯最简，对角线，矩阵的线性方程组求解。
本函数依托于临时表 sm_sc.__vt_tmp_matrix 实现。
入参：
  1. 原始矩阵： |select
  sm_sc.fv_mx_rows_step_simple
  (
    array[[1, -2, 0, 7],[5, 0, 3, 4]
            ,[0, 0, 0, 0],[0, -2, 0, -6]]
  );

返回：
  array[[1.0000, 0.0000, 0.0000, 13.0000]
          ,[0.0000, 1.0000, 0.0000, 3.0000]
          ,[0.0000, 0.0000, 1.0000, -20.3333]
          ,[0.0000, 0.0000, 0.0000, 0.0000]] >> sm_sc.fv_mx_times_col |指定某列乘系数。
入参：
  1. 原始矩阵：
  2. 乘系数的列序号：
  3. 乘系数值： |select
  sm_sc.fv_mx_times_col
  (
    array[[1, -2, 0, 7],[5, 0, 3, 4]
            ,[0, 0, 0, 0],[0, -2, 0, -6]]
  , 4
  , 1.5
  );

返回：
  array[[1, -2, 0, 10.5]
          ,[5, 0, 3, 6.0]
          ,[0, 0, 0, 0.0]
          ,[0, -2, 0, -9.0]] >> sm_sc.fv_mx_times_row |指定某行乘系数。
入参：
  1. 原始矩阵：
  2. 乘系数的行序号：
  3. 乘系数值： |select
  sm_sc.fv_mx_times_row
  (
    array[[1, -2, 0, 7],[5, 0, 3, 4]
            ,[0, 0, 0, 0],[0, -2, 0, -6]]
  , 4
  , 1.5
  );

返回：
  array[[1, -2, 0, 7]
          ,[5, 0, 3, 4]
          ,[0, 0, 0, 0]
          ,[0.0, -3.0, 0.0, -9.0]] >> sm_sc.fv_mx_reorder_col |列序重排。
入参：
  1. 原始矩阵：
  2. 旧列序号重新排列，存放在新列位置： |select
  sm_sc.fv_mx_reorder_col
  (
    array[[1, -2, 0, 7],[5, 0, 3, 4]
            ,[0, 0, 0, 0],[0, -2, 0, -6]]
  , array[null,3,4,2]
  );

返回：
  array[[1, 0, 7, -2]
          ,[5, 3, 4, 0]
          ,[0, 0, 0, 0]
          ,[0, 0, -6, -2]] >> sm_sc.fv_mx_reorder_row |行序重排。
入参：
  1. 原始矩阵：
  2. 旧行序号重新排列，存放在新行位置： |select
  sm_sc.fv_mx_reorder_row
  (
    array[[1, -2, 0, 7],[5, 0, 3, 4]
            ,[0, 0, 0, 0],[0, -2, 0, -6]]
  , array[null,3,4,2]
  );

返回：
  array[[1, -2, 0, 7]
          ,[0, 0, 0, 0]
          ,[0, -2, 0, -6]
          ,[5, 0, 3, 4]] >> sm_sc.ft_mx_lu |lu 分解。
入参：
  1. 原始矩阵：
出参列：
  1. q 矩阵；
  2. r 矩阵； |select
  o_mx_l, o_mx_u
from
  sm_sc.ft_mx_lu
  (
    array[[1, 2, 3, 4],[0, 8, 9, 10]
            ,[4, 5, 6, 7],[5, 7, 2, 10]]
  );

返回：
  o_mx_l:
    array[1.0000, 0.0000, 0.0000, 0.0000]
           ,[0.0000, 1.0000, 0.0000, 0.0000]
           ,[4.0000, -0.3750, 1.0000, 0.0000]
           ,[5.0000, -0.3750, 3.6667, 1.0000]]
  o_mx_u:
    array[1.0000, 2.0000, 3.0000, 4.0000]
           ,[0.0000, 8.0000, 9.0000, 10.0000]
           ,[0.0000, 0.0000, -2.6250, -5.2500]
           ,[0.0000, 0.0000, 0.0000, 13.0000]] >> sm_sc.ft_mx_qr |qr 分解。
入参：
  1. 原始矩阵：
出参列：
  1. q 矩阵；
  2. r 矩阵； |select
  o_mx_q, o_mx_r
from
  sm_sc.ft_mx_qr
  (
    array[[1, 2, 3, 4],[0, 8, 9, 10]
            ,[4, 5, 6, 7],[5, 7, 2, 10]]
  );

返回：
  o_mx_q:
    array[0.1543, 0.0800, 0.3341, 0.9264]
           ,[0.0000, 0.9950, 0.0276, -0.0958]
           ,[0.6172, -0.0533, 0.7020, -0.3514]
           ,[0.7715, 0.0267, -0.6284, 0.0958]]
  o_mx_r:
    array[6.4807, 8.7953, 5.7092, 12.6529]
           ,[0.0000, 8.0401, 8.9285, 10.1634]
           ,[0.0000, 0.0000, 4.2056, 0.2422]
           ,[0.0000, 0.0000, 0.0000, 1.2458]] >> >### 2. 运算符列表 > >> 运算符|运算符位置|运算符说明|举例 >> :-|:-|:- >> \+\` |双目 |点(广播)加。
等价函数: sm_sc.fv_opr_add |select
  array[[1.3, -8.8],[2.2, -3.0]]
  \+\`
  array[[-2.6, 11.3],[-4.6, 5.1]];

返回：
  array[[-1.3, 2.5],[-2.4, 2.1]] >> \-\` |双目 |点(广播)减。
等价函数: sm_sc.fv_opr_sub |select
  array[[1.3, -8.8],[2.2, -3.0]]
  \-\`
  array[[-2.6, 11.3],[-4.6, 5.1]];

返回：
  array[[3.9, -20.1],[6.8, -8.1]] >> \-\` |单目左侧 |点(广播)相反数。
等价函数: sm_sc.fv_opr_sub |select
  \-\`
  array[[-2.6, 11.3],[-4.6, 5.1]];

返回：
  array[[2.6, -11.3],[4.6, -5.1]] >> \*\` |双目 |点(广播)乘。
等价函数: sm_sc.fv_opr_mul |select
  array[[1.3, -8.8],[2.2, -3.0]]
  \*\`
  array[[-2.6, 11.3],[-4.6, 5.1]];

返回：
  array[[-3.38, -99.44],[-10.12, -15.30]] >> \/\` |双目 |点(广播)除。
等价函数: sm_sc.fv_opr_div |select
  array[[1.3, -8.8],[2.2, -3.0]]
  \/\`
  array[[-2.6, 11.3],[-4.6, 5.1]];

返回：
  array[[-0.5000, -0.7788],[-0.4783, -0.5882]] >> \/\` |单目左侧 |点(广播)倒数。
等价函数: sm_sc.fv_opr_div |select
  \/\`
  array[[-2.6, 11.3],[-4.6, 5.1]];

返回：
  array[[-0.3846, 0.0885],[-0.2174, 0.1961]] >> \%\` |双目 |点(广播)求余。
等价函数: sm_sc.fv_opr_mod |select
  array[[10, -29],[12, -33]]
  \%\`
  array[[-3, 11],[-5, 5]];

返回：
  array[[1, -7],[2, -3]] >> \^\` |双目 |点(广播)幂。
等价函数: sm_sc.fv_opr_pow |select
  array[[1.3, 8.8],[2.2, 3.0]]
  \^\`
  array[[-2.6, 1.3],[-4.6, 5.1]];

返回：
  array[[0.5055, 16.8977],[0.0266, 271.2179]] >> \^\` |单目左侧 |点(广播)自然常数幂。
等价函数: sm_sc.fv_opr_exp |select
  \^\`
  array[[1.3, -8.8],[2.2, -3.0]];

返回：
  array[[3.6693, 0.0002],[9.0250, 0.0498]] >> \^\!\` |双目 |点(广播)对数。
等价函数: sm_sc.fv_opr_log |select
  array[[1.3, 8.8],[2.2, 3.0]]
  \^\!\`
  array[[2.6, 11.3],[4.6, 5.1]];

返回：
  array[[3.6419, 1.1150],[1.9355, 1.4830]] >> \^\!\` |单目左侧 |点(广播)自然对数。
等价函数: sm_sc.fv_opr_ln |select
  \^\!\`
  array[[2.6, 11.3],[4.6, 5.1]];

返回：
  array[[0.9555, 2.4248},{1.5261, 1.6292]] >> \|\` |双目 |点(广播)位、逻辑或操作。
等价函数: sm_sc.fv_opr_or |select
  array[[true, false],[true, false]]
  \|\`
  array[[false, true],[false, true]];

返回：
  array[[true, true],[true, true]]
--------------------------
select
  array[[B'010', B'011'],[B'101', B'011']]
  \|\`
  array[[B'011', B'101'],[B'011', B'101']];

返回：
  array[[B'011', B'111'],[B'111', B'111']] >> \&\` |双目 |点(广播)位、逻辑与操作。
等价函数: sm_sc.fv_opr_and |select
  array[[true, false],[true, false]]
  \&\`
  array[[false, true],[false, true]];

返回：
  array[[false, false],[false, false]]
--------------------------
select
  array[[B'010', B'011'],[B'101', B'011']]
  \&\`
  array[[B'011', B'101'],[B'011', B'101']];

返回：
  array[[B'010', B'001'],[B'001', B'001']] >> \~\` |单目左侧 |点(广播)位、逻辑非操作。
等价函数: sm_sc.fv_opr_not |select
  \~\`
  array[[false, true],[false, true]];

返回：
  array[[true, false],[true, false]]
--------------------------
select
  \~\`
  array[[B'011', B'101'],[B'011', B'101']];

返回：
  array[[B'100', B'010'],[B'100', B'010']] >> \#\` |双目 |点(广播)位、逻辑异或操作。
等价函数: sm_sc.fv_opr_xor |select
  array[[true, false],[true, false]]
  \#\`
  array[[false, true],[false, true]];

返回：
  array[[true, true],[true, true]]
--------------------------
select
  array[[B'010', B'011'],[B'101', B'011']]
  \#\`
  array[[B'011', B'101'],[B'011', B'101']];

返回：
  array[[B'001', B'110'],[B'110', B'110']] >> \!\#\` |双目 |点(广播)位、逻辑同或操作。
等价函数: sm_sc.fv_opr_xnor |select
  array[[true, false],[true, false]]
  \!\#\`
  array[[false, true],[false, true]];

返回：
  array[[false, false],[false, false]]
--------------------------
select
  array[[B'010', B'011'],[B'101', B'011']]
  \!\#\`
  array[[B'011', B'101'],[B'011', B'101']];

返回：
  array[[B'110', B'001'],[B'001', B'001']] >> \~\` |双目 |点(广播)文本正则是否匹配。
等价函数: sm_sc.fv_opr_is_regexp_match |select
  array[['abbbbbc122223', 'abc123'],['abc123', 'ac13']]
  \~\`
  array[['a.c', '1.\*?3'],['1.3', 'a.\*?c']];

返回：
  array[[false, true],[true, true]] >> \~\` |单目左侧 |点(广播)复元素共轭。
等价函数: sm_sc.fv_opr_conjugate |select
  \~\`
  array[[(12.3, -25.1), (-2.56, 3.25)]
          ,[(12.3, 0.0), (0.0, 3.25)]] :: sm_sc.typ_l_complex[];

返回：
  array[[(12.3, 25.1), (-2.56, -3.25)]
           ,[(12.3, 0.0), (0.0, -3.25)]] :: sm_sc.typ_l_complex[] >> \@\~\` |单目左侧 |点(广播)复元素实部。
等价函数: sm_sc.fv_opr_real |select
  \@\~\`
  array[[(12.3, -25.1), (-2.56, 3.25)]
          ,[(12.3, 0.0), (0.0, 3.25)]] :: sm_sc.typ_l_complex[];

返回：
  array[[12.3000, -2.5600],[12.3000, 0.0000]] >> \~\@\` |单目左侧 |点(广播)复元素虚部。
等价函数: sm_sc.fv_opr_imaginary |select
  \~\@\`
  array[[(12.3, -25.1), (-2.56, 3.25)]
          ,[(12.3, 0.0), (0.0, 3.25)]] :: sm_sc.typ_l_complex[];

返回：
  array[[-25.1000, 3.2500],[0.0000, 3.2500]] >> \~\^\` |单目左侧 |点(广播)复元素实虚对换。
等价函数: sm_sc.fv_opr_conjugate_45 |select
  \~\^\`
  array[[(12.3, -25.1), (-2.56, 3.25)]
          ,[(12.3, 0.0), (0.0, 3.25)]] :: sm_sc.typ_l_complex[];

返回：
  array[[(-25.1, 12.3), (3.25, -2.56)]
           ,[(0.0, 12.3), (3.25, 0.0)]] :: sm_sc.typ_l_complex[] >> \|\|\` |双目 |点(广播)位、字串拼接操作。
等价函数: sm_sc.fv_opr_concat |select
  array[['abc', 'efgh'],['hijk', 'lm']]
  \|\|\`
  array[['no', 'pqr'],['stu', 'vwxyz']];

返回：
  array[['abcno', 'efghpqr'],['hijkstu', 'lmvwxyz']] >> \<\<\` |单目右侧 |点(广播)位左移操作。
等价函数: sm_sc.fv_opr_shift_left |select
  array[[B'010', B'011'],[B'101', B'011']]
  \<\<\`
  array[[1, 2],[-1, -2]];

返回：
  array[[B'100', B'100'],[B'010', B'000']] >> \>\>\` |单目右侧 |点(广播)位右移操作。
等价函数: sm_sc.fv_opr_shift_right |select
  array[[B'010', B'011'],[B'101', B'011']]
  \>\>\`
  array[[1, 2],[-1, -2]];

返回：
  array[[B'001', B'000'],[B'010', B'100']] >> \=\=\` |双目 |点(广播)相等判断。
等价函数: sm_sc.fv_opr_is_equal |select
  array[[1.3, -8.8],[2.2, -3.0]]
  \=\=\`
  array[[-2.6, 11.3],[-4.6, -3.0]];

返回：
  array[[false, false],[false, true]] >> \<\` |双目 |点(广播)小于判断。
等价函数: sm_sc.fv_opr_is_less |select
  array[[1.3, -8.8],[2.2, -3.0]]
  \<\`
  array[[-2.6, 11.3],[-4.6, -3.0]];

返回：
  array[[false, true],[false, false]] >> \>\` |双目 |点(广播)大于判断。
等价函数: sm_sc.fv_opr_is_greater |select
  array[[1.3, -8.8],[2.2, -3.0]]
  \>\`
  array[[-2.6, 11.3],[-4.6, -3.0]];

返回：
  array[[true, false],[true, false]] >> \<\=\` |双目 |点(广播)小于等于判断。
等价函数: sm_sc.fv_opr_is_less_ex |select
  array[[1.3, -8.8],[2.2, -3.0]]
  \<\=\`
  array[[-2.6, 11.3],[-4.6, -3.0]];

返回：
  array[[false, true],[false, true]] >> \>\=\` |双目 |点(广播)大于等于判断。
等价函数: sm_sc.fv_opr_is_greater_ex |select
  array[[1.3, -8.8],[2.2, -3.0]]
  \>\=\`
  array[[-2.6, 11.3],[-4.6, -3.0]];

返回：
  array[[true, false],[true, true]] >> \<\>\` |双目 |点(广播)大小判断。
等价函数: sm_sc.fv_opr_compare |select
  array[[1.3, -8.8],[2.2, -3.0]]
  \<\>\`
  array[[-2.6, 11.3],[-4.6, -3.0]];

返回：
  array[[1, -1],[1, 0]] >> \<\>\` |单目左侧 |点(广播)实元素正负判断。
等价函数: sm_sc.fv_opr_sign |select
  \<\>\`
  array[[-2.6, 11.3],[-4.6, 0.0]];

返回：
  array[[-1, 1],[-1, 0]] >> \@\<\` |双目 |点(广播)元素值取小。
等价函数: sm_sc.fv_opr_least |select
  array[[1.3, -8.8],[2.2, -3.0]]
  \@\<\`
  array[[-2.6, 11.3],[-4.6, 5.1]];

返回：
  array[[-2.6, -8.8],[-4.6, -3.0]] >> \@\>\` |双目 |点(广播)元素值取大。
等价函数: sm_sc.fv_opr_greatest |select
  array[[1.3, -8.8],[2.2, -3.0]]
  \@\>\`
  array[[-2.6, 11.3],[-4.6, 5.1]];

返回：
  array[[1.3, 11.3],[2.2, 5.1]] >> \@\` |单目左侧 |点(广播)实元素绝对值、复数的模。
等价函数: sm_sc.fv_opr_abs |select
  \@\`
  array[[-2.6, 11.3],[-4.6, 5.1]];

返回：
  array[[2.6, 11.3],[4.6, 5.1]]
--------------------------
select
  \@\`
  array[[(12.3, -25.1), (-2.56, 3.25)]
          ,[(12.3, 0.0), (0.0, 3.25)]] :: sm_sc.typ_l_complex[];

返回：
  array[[27.9517, 4.1372],[12.3, 3.25]] >> \~\=\` |双目 |点(广播)四舍五入。
等价函数: sm_sc.fv_opr_round |select
  array[[1.327, -8.886],[2.2, -3.036]]
  \~\=\`
  2;

返回：
  array[[1.33, -8.89],[2.20, -3.04]] >> \~\=\` |单目右侧 |点(广播)四舍五入取整。
等价函数: sm_sc.fv_opr_round |select
  array[[1.327, -8.886],[2.2, -3.036]]
  \~\=\`;

返回：
  array[[1, -9],[2, -3]] >> \~\<\` |双目 |点(广播)数位地板值。
等价函数: sm_sc.fv_opr_floor |select
  array[[1.327, -8.886],[2.2, -3.036]]
  \~\<\`
  2;

返回：
  array[[1.32, -8.89],[2.2, -3.04]] >> \~\<\` |单目右侧 |点(广播)数位地板值取整。
等价函数: sm_sc.fv_opr_floor |select
  array[[1.327, -8.886],[2.2, -3.036]]
  \~\<\`;

返回：
  array[[1, -9],[2, -4]] >> \~\>\` |双目 |点(广播)数位天花板值。
等价函数: sm_sc.fv_opr_ceil |select
  array[[1.327, -8.886],[2.2, -3.036]]
  \~\>\`
  2;

返回：
  array[[1.33, -8.88],[2.2, -3.03]] >> \~\>\` |单目右侧 |点(广播)数位天花板值取整。
等价函数: sm_sc.fv_opr_ceil |select
  array[[1.327, -8.886],[2.2, -3.036]]
  \~\>\`;

返回：
  array[[2, -8],[3, -3]] >> \>\<\` |双目 |点(广播)数位截取值。
等价函数: sm_sc.fv_opr_trunc |select
  array[[1.327, -8.886],[2.2, -3.036]]
  \>\<\`
  2;

返回：
  array[[1.32, -8.88],[2.20, -3.03]] >> \>\<\` |单目右侧 |点(广播)数位截取值取整。
等价函数: sm_sc.fv_opr_trunc |select
  array[[1.327, -8.886],[2.2, -3.036]]
  \>\<\`;

返回：
  array[[1, -8],[2, -3]] >> \|\|\~\| |单目左侧 |上下镜像。
等价函数: sm_sc.fv_opr_mirror_y |select
  \|\|\~\|
  array[[-2.6, 11.3],[-4.6, 5.1]];

返回：
  array[[-4.6, 5.1],[-2.6, 11.3]] >> \|\-\~\| |单目左侧 |左右镜像。
等价函数: sm_sc.fv_opr_mirror_x |select
  \|\-\~\|
  array[[-2.6, 11.3],[-4.6, 5.1]];

返回：
  array[[11.3, -2.6],[5.1, -4.6]] >> \|\<\~\| |单目左侧 |左旋90°(逆时针)。
等价函数: sm_sc.fv_opr_turn_left |select
  \|\<\~\|
  array[[-2.6, 11.3],[-4.6, 5.1]];

返回：
  array[[11.3, 5.1],[-2.6, -4.6]] >> \|\>\~\| |单目左侧 |右旋90°(顺时针)。
等价函数: sm_sc.fv_opr_turn_right |select
  \|\>\~\|
  array[[-2.6, 11.3],[-4.6, 5.1]];

返回：
  array[[-4.6, -2.6],[5.1, 11.3]] >> \|\~\~\| |单目左侧 |旋转180°(双对角转置)。
等价函数: sm_sc.fv_opr_turn_back |select
  \|\~\~\|
  array[[-2.6, 11.3],[-4.6, 5.1]];

返回：
  array[[5.1, -4.6],[11.3, -2.6]] >> \|\^\~\| |单目左侧 |正转置(左下右上互换)。
等价函数: sm_sc.fv_opr_transpose |select
  \|\^\~\|
  array[[-2.6, 11.3],[-4.6, 5.1]];

返回：
  array[[-2.6, -4.6],[11.3, 5.1]] >> \|\^\~\`\| |单目左侧 |共轭矩阵(区别于正转置)。
等价函数: sm_sc.fv_opr_conjugate_i |select
  \|\^\~\`\|
  array[[(12.3, -25.1), (-2.56, 3.25)]
          ,[(12.3, 0.0), (0.0, 3.25)]] :: sm_sc.typ_l_complex[];

返回：
  array[[(12.30, 25.10), (12.30, 0.00)]
           ,[(-2.56, -3.25), (0.00, -3.25)]] :: sm_sc.typ_l_complex[] >> \|\~\^\| |单目左侧 |右下左上互换转置。
等价函数: sm_sc.fv_opr_transpose_i |select
  \|\~\^\|
  array[[-2.6, 11.3],[-4.6, 5.1]];

返回：
  array[[5.1, 11.3],[-4.6, -2.6]] >> \|\-\|\| |双目 |上下拼接。
等价函数: sm_sc.fv_opr_concat_y |select
  array[[1.3, -8.8],[2.2, -3.0]]
  \|\-\|\|
  array[[-2.6, 11.3],[-4.6, 5.1]];

返回：
  array[[1.3, -8.8],[2.2, -3.0],[-2.6, 11.3],[-4.6, 5.1]] >> \|\|\|\| |双目 |左右拼接。
等价函数: sm_sc.fv_opr_concat_x |select
  array[[1.3, -8.8],[2.2, -3.0]]
  \|\|\|\|
  array[[-2.6, 11.3],[-4.6, 5.1]];

返回：
  array[[1.3, -8.8, -2.6, 11.3],[2.2, -3.0, -4.6, 5.1]] >> \|\`\| |双目 |内积；数量积。
等价函数: sm_sc.fv_opr_prod_inner |select
  array[[1.3, -8.8],[2.2, -3.0]]
  \|\`\|
  array[[-2.6, 11.3],[-4.6, 5.1]];

返回：-128.24 >> \|\`\^\| |双目 |内积幂；数量积幂。
等价函数: sm_sc.fv_opr_prod_inner_pow |select
  array[[1.3, -8.8],[2.2, -3.0]]
  \|\`\^\|
  3.0;

返回：-695.627 >> \|\*\*\| |双目 |矩阵乘法：相乘、外积。
等价函数: sm_sc.fv_opr_prod_mx |select
  array[[1.3, -8.8],[2.2, -3.0]]
  \|\*\*\|
  array[[-2.6, 11.3],[-4.6, 5.1]];

返回：
  array[[37.1000, -30.1900],[8.0800, 9.5600]] >> \|\*\*\| |单目右侧 |矩阵乘法其转置。
等价函数: sm_sc.fv_opr_prod_mx_left |select
  array[[1.3, -8.8],[2.2, -3.0]]
  \|\*\*\|;

返回：
  array[[79.1300, 29.2600],[29.2600, 13.8400]] >> \|\*\*\| |单目左侧 |矩阵转置乘法该矩阵。
等价函数: sm_sc.fv_opr_prod_mx_right |select
  \|\*\*\|
  array[[-2.6, 11.3],[-4.6, 5.1]];

返回：
  array[[27.9200, -52.8400],[-52.8400, 153.7000]] >> \|\*\^\| |双目 |方阵矩阵乘法幂。
等价函数: sm_sc.fv_opr_prod_mx_pow |select
  array[[1.3, -8.8],[2.2, -3.0]]
  \|\*\^\|
  3;

返回：
  array[[1.3000,-8.8000],[2.2000,-3.0000]] >> \|\@\+\| |单目左侧 |元素聚合合计。
等价函数: sm_sc.fv_aggr_slice_sum |select
  \|\@\+\|
  array[[-2.6, 11.3],[-4.6, 5.1]];

返回：9.2 >> \|\@\*\| |单目左侧 |元素聚合连积。
等价函数: sm_sc.fv_aggr_slice_prod |select
  \|\@\*\|
  array[[-2.6, 11.3],[-4.6, 5.1]];

返回：689.2548 >> \|\@\/\| |单目左侧 |元素聚合平均。
等价函数: sm_sc.fv_aggr_slice_avg |select
  \|\@\/\|
  array[[-2.6, 11.3],[-4.6, 5.1]];

返回：2.3 >> \|\@\>\| |单目左侧 |元素聚合最大。
等价函数: sm_sc.fv_aggr_slice_max |select
  \|\@\>\|
  array[[-2.6, 11.3],[-4.6, 5.1]];

返回：11.3 >> \|\@\<\| |单目左侧 |元素聚合最小。
等价函数: sm_sc.fv_aggr_slice_min |select
  \|\@\<\|
  array[[-2.6, 11.3],[-4.6, 5.1]];

返回：-4.6 >> \|\@\/\=\| |单目左侧 |元素聚合跨度(最大-最小)。
等价函数: sm_sc.fv_aggr_slice_ptp |select
  \|\@\/\=\|
  array[[-2.6, 11.3],[-4.6, 5.1]];

返回：15.9 >> \|\@\#\| |单目左侧 |元素聚合总体方差。
等价函数: sm_sc.fv_aggr_slice_var_pop |select
  \|\@\#\|
  array[[-2.6, 11.3],[-4.6, 5.1]];

返回：40.115 >> \|\@\#\`\| |单目左侧 |元素聚合样本方差。
等价函数: sm_sc.fv_aggr_slice_var_samp |select
  \|\@\#\`\|
  array[[-2.6, 11.3],[-4.6, 5.1]];

返回：53.4867 >> \|\@\%\| |单目左侧 |元素聚合总体标准差。
等价函数: sm_sc.fv_aggr_slice_stddev_pop |select
  \|\@\%\|
  array[[-2.6, 11.3],[-4.6, 5.1]];

返回：6.3336 >> \|\@\%\`\| |单目左侧 |元素聚合样本标准差。
等价函数: sm_sc.fv_aggr_slice_stddev_samp |select
  \|\@\%\`\|
  array[[-2.6, 11.3],[-4.6, 5.1]];

返回：7.3135 >> \|\@\/\>\| |单目左侧 |元素聚合众数。
等价函数: sm_sc.fv_aggr_slice_mode |select
  \|\@\/\>\|
  array[[-4.6, 11.3],[-4.6, 5.1]];

返回：-4.6 >> \|\@\/\<\| |单目左侧 |元素聚合中位数。
等价函数: sm_sc.fv_aggr_slice_median |select
  \|\@\/\<\|
  array[[-2.6, 11.3],[-4.6, 5.1]];

返回：1.25 >> \|\@\|\|\| |单目左侧 |元素聚合位元拼接。
等价函数: sm_sc.fv_aggr_slice_concat |select
  \|\@\|\|\|
  array[[B'10', B'001'],[B'01', B'1']];

返回：B'10001011' >> \|\@\|\`\| |单目左侧 |元素聚合位元、逻辑求或。
等价函数: sm_sc.fv_aggr_slice_or |select
  \|\@\|\`\|
  array[[B'001', B'101'],[B'100', B'010']];

返回：B'111'
--------------------------
select
  \|\@\|\`\|
  array[[true, false],[true, true]];

返回：true >> \|\@\&\`\| |单目左侧 |元素聚合位元、逻辑求与。
等价函数: sm_sc.fv_aggr_slice_and |select
  \|\@\&\`\|
  array[[B'001', B'101'],[B'100', B'010']];

返回：B'000'
--------------------------
select
  \|\@\&\`\|
  array[[true, false],[true, true]];

返回：false >> \|\@\=\| |单目左侧 |元素聚合免空。
等价函数: sm_sc.fv_aggr_slice_coalesce |select
  \|\@\=\|
  array[[null, 11.3],[null, 5.1]];

返回：11.3 >> \|\|\+\| |单目左侧 |元素聚合y方向合计。
等价函数: sm_sc.fv_aggr_y_sum |select
  \|\|\+\|
  array[[-2.6, 11.3],[-4.6, 5.1]];

返回：array[[-7.2, 16.4]] >> \|\|\*\| |单目左侧 |元素聚合y方向连积。
等价函数: sm_sc.fv_aggr_y_prod |select
  \|\|\*\|
  array[[-2.6, 11.3],[-4.6, 5.1]];

返回：array[[11.96, 57.63]] >> \|\|\/\| |单目左侧 |元素聚合y方向平均。
等价函数: sm_sc.fv_aggr_y_avg |select
  \|\|\/\|
  array[[-2.6, 11.3],[-4.6, 5.1]];

返回：array[[-3.6000, 8.2000]] >> \|\|\>\| |单目左侧 |元素聚合y方向最大。
等价函数: sm_sc.fv_aggr_y_max |select
  \|\|\>\|
  array[[-2.6, 11.3],[-4.6, 5.1]];

返回：array[[-2.6, 11.3]] >> \|\|\<\| |单目左侧 |元素聚合y方向最小。
等价函数: sm_sc.fv_aggr_y_min |select
  \|\|\<\|
  array[[-2.6, 11.3],[-4.6, 5.1]];

返回：array[[-4.6, 5.1]] >> \|\|\/\=\| |单目左侧 |元素聚合y方向跨度(最大-最小)。
等价函数: sm_sc.fv_aggr_y_ptp |select
  \|\|\/\=\|
  array[[-2.6, 11.3],[-4.6, 5.1]];

返回：array[[2.0, 6.2]] >> \|\|\#\| |单目左侧 |元素聚合y方向总体方差。
等价函数: sm_sc.fv_aggr_y_var_pop |select
  \|\|\#\|
  array[[-2.6, 11.3],[-4.6, 5.1]];

返回：array[[1.0, 9.61]] >> \|\|\#\`\| |单目左侧 |元素聚合y方向样本方差。
等价函数: sm_sc.fv_aggr_y_var_samp |select
  \|\|\#\`\|
  array[[-2.6, 11.3],[-4.6, 5.1]];

返回：array[[2.0, 19.22]] >> \|\|\%\| |单目左侧 |元素聚合y方向总体标准差。
等价函数: sm_sc.fv_aggr_y_stddev_pop |select
  \|\|\%\|
  array[[-2.6, 11.3],[-4.6, 5.1]];

返回：array[[1.0, 3.1]] >> \|\|\%\`\| |单目左侧 |元素聚合y方向样本标准差。
等价函数: sm_sc.fv_aggr_y_stddev_samp |select
  \|\|\%\`\|
  array[[-2.6, 11.3],[-4.6, 5.1]];

返回：array[[1.4142, 4.3841]] >> \|\|\/\>\| |单目左侧 |元素聚合y方向众数。
等价函数: sm_sc.fv_aggr_y_mode |select
  \|\|\/\>\|
  array[[-2.6, 11.3],[-2.6, 5.1]];

返回：array[[-2.6, 5.1]] >> \|\|\/\<\| |单目左侧 |元素聚合y方向中位数。
等价函数: sm_sc.fv_aggr_y_median |select
  \|\|\/\<\|
  array[[-2.6, 11.3],[-4.6, 5.1]];

返回：array[[-3.6, 8.2]] >> \|\|\|\|\| |单目左侧 |元素聚合y方向位元拼接。
等价函数: sm_sc.fv_aggr_y_concat |select
  \|\|\|\|\|
  array[[B'10', B'001'],[B'01', B'1']];

返回：array[[B'1001', B'0011']] >> \|\|\|\`\| |单目左侧 |元素聚合y方向位元、逻辑求或。
等价函数: sm_sc.fv_aggr_y_or |select
  \|\|\|\`\|
  array[[B'001', B'101'],[B'100', B'010']];

返回：array[[B'101', B'111']]
--------------------------
select
  \|\|\|\`\|
  array[[true, false],[true, true]];

返回：array[[true, true]] >> \|\|\&\`\| |单目左侧 |元素聚合y方向位元、逻辑求与。
等价函数: sm_sc.fv_aggr_y_and |select
  \|\|\&\`\|
  array[[B'001', B'101'],[B'100', B'010']];

返回：array[[B'000', B'000']]
--------------------------
select
  \|\|\&\`\|
  array[[true, false],[true, true]];

返回：array[[true, false]] >> \|\|\=\| |单目左侧 |元素聚合y方向免空。
等价函数: sm_sc.fv_aggr_y_coalesce |select
  \|\|\=\|
  array[[-2.6, null],[null, 5.1]];

返回：array[[-2.6, 5.1]] >> \|\-\+\| |单目左侧 |元素聚合x方向合计。
等价函数: sm_sc.fv_aggr_x_sum |select
  \|\-\+\|
  array[[-2.6, 11.3],[-4.6, 5.1]];

返回：array[[8.7],[0.5]] >> \|\-\*\| |单目左侧 |元素聚合x方向连积。
等价函数: sm_sc.fv_aggr_x_prod |select
  \|\-\*\|
  array[[-2.6, 11.3],[-4.6, 5.1]];

返回：array[[-29.38],[23.46]] >> \|\-\/\| |单目左侧 |元素聚合x方向平均。
等价函数: sm_sc.fv_aggr_x_avg |select
  \|\-\/\|
  array[[-2.6, 11.3],[-4.6, 5.1]];

返回：array[[4.35],[0.25]] >> \|\-\>\| |单目左侧 |元素聚合x方向最大。
等价函数: sm_sc.fv_aggr_x_max |select
  \|\-\>\|
  array[[-2.6, 11.3],[-4.6, 5.1]];

返回：array[[11.3],[5.1]] >> \|\-\<\| |单目左侧 |元素聚合x方向最小。
等价函数: sm_sc.fv_aggr_x_min |select
  \|\-\<\|
  array[[-2.6, 11.3],[-4.6, 5.1]];

返回：array[[-2.6],[-4.6]] >> \|\-\/\=\| |单目左侧 |元素聚合x方向跨度(最大-最小)。
等价函数: sm_sc.fv_aggr_x_ptp |select
  \|\-\/\=\|
  array[[-2.6, 11.3],[-4.6, 5.1]];

返回：array[[13.9],[9.7]] >> \|\-\#\| |单目左侧 |元素聚合x方向总体方差。
等价函数: sm_sc.fv_aggr_x_var_pop |select
  \|\-\#\|
  array[[-2.6, 11.3],[-4.6, 5.1]];

返回：array[[48.3025],[23.5225]] >> \|\-\#\`\| |单目左侧 |元素聚合x方向样本方差。
等价函数: sm_sc.fv_aggr_x_var_samp |select
  \|\-\#\`\|
  array[[-2.6, 11.3],[-4.6, 5.1]];

返回：array[[96.6050],[47.0450]] >> \|\-\%\| |单目左侧 |元素聚合x方向总体标准差。
等价函数: sm_sc.fv_aggr_x_stddev_pop |select
  \|\-\%\|
  array[[-2.6, 11.3],[-4.6, 5.1]];

返回：array[[6.95],[4.85]] >> \|\-\%\`\| |单目左侧 |元素聚合x方向样本标准差。
等价函数: sm_sc.fv_aggr_x_stddev_samp |select
  \|\-\%\`\|
  array[[-2.6, 11.3],[-4.6, 5.1]];

返回：array[[9.8288],[6.8589]] >> \|\-\/\>\| |单目左侧 |元素聚合x方向众数。
等价函数: sm_sc.fv_aggr_x_mode |select
  \|\-\/\>\|
  array[[-2.6, -2.6],[-4.6, 5.1]];

返回：array[[-2.6],[-4.6]] >> \|\-\/\<\| |单目左侧 |元素聚合x方向中位数。
等价函数: sm_sc.fv_aggr_x_median |select
  \|\-\/\<\|
  array[[-2.6, 11.3],[-4.6, 5.1]];

返回：array[[4.35],[0.25]] >> \|\-\|\|\| |单目左侧 |元素聚合x方向位元拼接。
等价函数: sm_sc.fv_aggr_x_concat |select
  \|\-\|\|\|
  array[[B'10', B'001'],[B'01', B'1']];

返回：array[[B'10001',B'011']] >> \|\-\|\`\| |单目左侧 |元素聚合x方向位元、逻辑求或。
等价函数: sm_sc.fv_aggr_x_or |select
  \|\-\|\`\|
  array[[B'001', B'101'],[B'100', B'010']];

返回：array[[B'101',B'110']]
--------------------------
select
  \|\-\|\`\|
  array[[true, false],[true, true]];

返回：array[[true, true]] >> \|\-\&\`\| |单目左侧 |元素聚合x方向位元、逻辑求与。
等价函数: sm_sc.fv_aggr_x_and |select
  \|\-\&\`\|
  array[[B'001', B'101'],[B'100', B'010']];

返回：array[[B'001',B'000']]
--------------------------
select
  \|\-\&\`\|
  array[[true, false],[true, true]];

返回：array[[false, true]] >> \|\-\=\| |单目左侧 |元素聚合x方向免空。
等价函数: sm_sc.fv_aggr_x_coalesce |select
  \|\-\=\|
  array[[null, 11.3],[-4.6, null]];

返回：array[[11.3],[4.6]] > >### 3. 存储过程介绍 >> >> 过程名|主要操作表|过程说明 >> :-|:- >> sm_sc.prc_linear_regression |1. sm_sc.tb_classify_task:
    分类任务训练任务表，用于规划任务，并存放训练出来的权重值数组；
2. sm_sc.tb_nn_train_input_buff:
    编码后的训练集数据表，用于传入训练集； |线性回归。
入参：
  1. 训练任务标识：
  2. 学习率：
  3. 规划训练次数：
  4. 损失函数梯度阈值： >> sm_sc.prc_logistic_regression |1. sm_sc.tb_classify_task:
    分类任务训练任务表，用于规划任务，并存放训练出来的权重值数组；
2. sm_sc.tb_nn_train_input_buff:
    编码后的训练集数据表，用于传入训练集； |逻辑回归。
入参：
  1. 训练任务标识：
  2. 学习率：
  3. 规划训练次数：
  4. 损失函数梯度阈值： >> sm_sc.prc_kmeans_pp |1. sm_sc.tb_cluster_task:
    kmean 聚类任务数据表，用于传入 kmeans 硬聚类数据集，输出聚类结果；
2. sm_sc.__vt_kmean_ods_array:
    编码后的训练集数据表，用执行时装入数据；
3. sm_sc.tb_nn_train_input_buff:
    编码后的训练集数据表，用于传入训练集； |kmeans 硬聚类。
入参：
  1. 训练任务标识： >> sm_sc.prc_dbscan_pp |1. sm_sc.tb_cluster_task:
    聚类任务数据表，用于传入 dbscan 软聚类数据集，输出聚类结果；
2. sm_sc.__vt_dbscan_ods_array:
    编码后的训练集数据表，用执行时装入数据；
3. sm_sc.tb_nn_train_input_buff:
    编码后的训练集数据表，用于传入训练集； |dbscan 软聚类。
入参：
  1. 训练任务标识： >> sm_sc.prc_nn_prepare |1. sm_sc.tb_nn_node：
    神经网络节点与属性表，用于配置神经网络节点。
    训练过程中，寄存属性参数和梯度； |深度学习任务训练准备。
入参：
  1. 训练任务标识：
  2. 规划训练次数： >> sm_sc.prc_nn_train |1. sm_sc.tb_nn_node：
    神经网络节点与属性表，用于配置神经网络节点。
    训练过程中，寄存属性参数和梯度；
2. sm_sc.tb_nn_path:
    神经网络路径表，用于配置神经网络传播路径；
3.sm_sc.__vt_nn_node:
    神经网络节点与属性表，导出模型，存放训练好的属性参数； |深度学习任务训练执行。
入参：
  1. 训练任务标识：
  2. 损失函数类型：
  3. 学习率：
  4. 损失函数梯度阈值： >### 4. 神经网络节点支持运算类型 > >> lambda 命名，即运算类型|调用函数|运算目数|是否支持反向传播求导|对于双目运算，第一目第二目求导公式是否一致|求导时机|求导是否需要自变量|求导是否需要因变量|求导用到高宽规格|求导是否用到样本编号 >> :-|:-|:-|:-|:-|:-|:-|:-|:-|:- >> const | |1 | | | | | | | >> buff_slice_rand_pick|sm_sc.ft_nn_buff_slice_rand_pick|1| | | | | | | >> exp |sm_sc.fv_opr_exp |1 |是| |前向传播后 | |是| | >> ln |sm_sc.fv_opr_ln |1 |是| |前向传播同步 |是| | | >> sin |sm_sc.fv_sin |1 |是| |前向传播同步 |是| | | >> cos |sm_sc.fv_cos |1 |是| |前向传播同步 |是| | | >> tan |sm_sc.fv_tan |1 |是| |前向传播同步 |是| | | >> cot |sm_sc.fv_cot |1 |是| |前向传播同步 |是| | | >> sec |sm_sc.fv_sec |1 |是| |前向传播同步 |是| | | >> csc |sm_sc.fv_csc |1 |是| |前向传播同步 |是| | | >> asin |sm_sc.fv_asin |1 |是| |前向传播同步 |是| | | >> acos |sm_sc.fv_acos |1 |是| |前向传播同步 |是| | | >> atan |sm_sc.fv_atan |1 |是| |前向传播同步 |是| | | >> acot |sm_sc.fv_acot |1 |是| |前向传播同步 |是| | | >> asec |sm_sc.fv_asec |1 |是| |前向传播同步 |是| | | >> acsc |sm_sc.fv_acsc |1 |是| |前向传播同步 |是| | | >> sinh |sm_sc.fv_sinh |1 |是| |前向传播同步 |是| | | >> cosh |sm_sc.fv_cosh |1 |是| |前向传播同步 |是| | | >> tanh |sm_sc.fv_tanh |1 |是| |前向传播后 | |是| | >> coth |sm_sc.fv_coth |1 |是| |前向传播同步 |是| | | >> sech |sm_sc.fv_sech |1 |是| |前向传播同步 |是| | | >> csch |sm_sc.fv_csch |1 |是| |前向传播同步 |是| | | >> asinh |sm_sc.fv_asinh |1 |是| |前向传播同步 |是| | | >> acosh |sm_sc.fv_acosh |1 |是| |前向传播同步 |是| | | >> atanh |sm_sc.fv_atanh |1 |是| |前向传播同步 |是| | | >> acoth |sm_sc.fv_acoth |1 |是| |前向传播同步 |是| | | >> asech |sm_sc.fv_asech |1 |是| |前向传播同步 |是| | | >> acsch |sm_sc.fv_acsch |1 |是| |前向传播同步 |是| | | >> sigmoid |sm_sc.fv_sigmoid |1 |是| |前向传播后 | |是| | >> relu |sm_sc.fv_activate_relu |1 |是| |前向传播同步 |是| | | >> leaky_relu |sm_sc.fv_activate_leaky_relu |1 |是| |前向传播同步 |是| | | >> elu |sm_sc.fv_activate_elu |1 |是| |前向传播同步 |是| | | >> selu |sm_sc.fv_activate_selu |1 |是| |前向传播同步 |是| | | >> gelu |sm_sc.fv_activate_gelu |1 |是| |前向传播同步 |是| | | >> swish |sm_sc.fv_activate_swish |1 |是| |前向传播同步 |是| | | >> softplus |sm_sc.fv_activate_softplus |1 |是| |前向传播同步 |是| | | >> softmax_mx |sm_sc.fv_standlize_mx_softmax |1 |是| |反向传播 |是|是| | >> softmax_x |sm_sc.fv_standlize_x_softmax |1 |是| |反向传播 |是|是| | >> softmax_y |sm_sc.fv_standlize_y_softmax |1 |是| |反向传播 |是|是| | >> zscore_mx |sm_sc.fv_standlize_mx_zscore |1 |是| |反向传播 |是|是| | >> zscore_x |sm_sc.fv_standlize_x_zscore |1 |是| |反向传播 |是|是| | >> zscore_y |sm_sc.fv_standlize_y_zscore |1 |是| |反向传播 |是|是| | >> rand_pick_x |sm_sc.ft_rand_slice_x_pick |1 |是| |反向传播 | |是| |是 >> rand_pick_y |sm_sc.ft_rand_slice_x_pick |1 |是| |反向传播 | |是| |是 >> slice_x | |1 |是| |前向传播同步 | | |是| >> slice_y | |1 |是| |前向传播同步 | | |是| >> sample_x |sm_sc.fv_sample_x |1 |是| |反向传播 | |是| | >> sample_y |sm_sc.fv_sample_y |1 |是| |反向传播 | |是| | >> pool_max |sm_sc.fv_pool_max_2d_grp |1 |是| |反向传播 |是|是| | >> pool_avg |sm_sc.fv_pool_avg_2d_grp |1 |是| |反向传播 |是|是| | >> new |sm_sc.fv_new |1 |是| |反向传播 | |是| | >> add |sm_sc.fv_opr_add |2 |是|是|前向传播同步 | | |是| >> mul |sm_sc.fv_opr_mul |2 |是|是|前向传播同步 |是| | | >> sub |sm_sc.fv_opr_sub |2 |是| |前向传播同步 | | |是| >> div |sm_sc.fv_opr_div |2 |是| |前向传播同步 |是| | | >> pow |sm_sc.fv_opr_pow |2 |是| |前向传播后 |是|是| | >> log |sm_sc.fv_opr_log |2 |是| |前向传播后 |是|是| | >> prod_mx |sm_sc.fv_opr_prod_mx_py |2 |是| |前向传播同步 |是|是| | >> conv_2d |sm_sc.fv_conv_2d_grp_x |2 |是| |反向传播 |是|是| | >> agg_sum |sm_sc.fa_mx_sum |n |是| |反向传播 | | |是| >> agg_prod |sm_sc.fa_mx_prod |n |是| |反向传播 | |是|是| >> agg_avg |sm_sc.fa_mx_avg |n |是| |反向传播 | | |是| >> agg_max |sm_sc.fa_mx_max |n |是| |反向传播 | |是|是| >> agg_min |sm_sc.fa_mx_min |n |是| |前向传播后 | |是|是| >> agg_concat_x |sm_sc.fa_mx_concat_x |n |是| |反向传播 | | |是| >> agg_concat_y |sm_sc.fa_mx_concat_y |n |是| |反向传播 | | |是|