Vectorized

Full name Microsoft.VisualBasic.Math.SIMD.Vectorization.Vectorized Assembly Microsoft.VisualBasic.Runtime Members 97

向量化运算的统一词汇表: 脚本向量化改写器所发射的全部调用都指向本模块。

00 Remarks

为什么需要独立的一套词汇: SimdExtensions 已被大量既有代码以 Imports Microsoft.VisualBasic.Math.SIMD 的方式直接引用, 其成员名 (SimdAdd / SimdAbs / SimdSum …) 都被占用。而 VB 对「两个已导入模块之中的同名成员」会直接报 BC30562(名称不明确) —— 即使签名不同、即使调用处写了显式泛型实参也无法化解。因此本模块统一采用 Vec* 前缀, 与 SimdExtensions 完全不存在重名。

为什么放在 Math.SIMD.Vectorization 子命名空间: 生成代码只需要 Imports Microsoft.VisualBasic.Math.SIMD.Vectorization 一条导入语句, 这样既能看到本模块的 Vec* 成员, 又不会把 Microsoft.VisualBasic.Math.SIMD 之中那些泛化命名的历史门面类(Add / Subtract / Multiply / Divide / Modulo / Exponent)带进脚本作用域, 从而不会与脚本自身定义的类型产生歧义。

实现策略:

有真 SIMD 内核可用的一律转调 / /

(基于 );

框架/硬件没有对应内核的运算(整除 \、取余 Mod、乘积归约、逐元素映射)

退化为标量循环, 与运行时既有 Modulo / Exponent 门面处于同一实现水平;

归约刻意走的顺序内核而不是 SimdParallel 的分块并行,

以保证脚本的浮点结果可复现(并行归约的加法次序不确定)。

长度契约: 向量⊕向量运算假设两侧长度一致, 与 SimdEngine 保持一致, 不额外做长度校验(长度不足时由运行时自身的边界检查抛出)。

词汇完整性: 本模块按「数值类型 × 运算形态」把词汇一次性补全, 因此其中 VecSquare 与 VecReciprocal 目前没有对应的改写来源 (脚本里的 v * v / 1 / v 分别被发射为 VecMultiply / VecScalarDivide, 以保持 VB 的逐元素类型语义), 它们作为词汇表的一部分保留, 供脚本直接调用。

01 Syntax

Microsoft.VisualBasic.Math.SIMD.Vectorization.Vectorized

02 Methods

Name	Overloads	Summary
ZipMap	1	逐元素二元运算的标量循环实现(VB 不支持泛型运算符约束, 因此运算由调用方注入)
ZipScalarMap	1	向量 ⊕ 标量的标量循环实现
ScalarZipMap	1	标量 ⊕ 向量的标量循环实现(标量位于左操作数一侧)
VecAdd	1	逐元素相加: out(i) = v1(i) + v2(i)
VecSubtract	1	逐元素相减: out(i) = v1(i) - v2(i)
VecMultiply	1	逐元素相乘: out(i) = v1(i) * v2(i)
VecDivide	2	逐元素真除法(VB 的 /): out(i) = v1(i) / v2(i)
VecIntegerDivide	2	逐元素整除(VB 的 \, Int32)
VecModulo	4	逐元素取余(VB 的 Mod, Double)
VecPower	1	逐元素幂(VB 的 ^): out(i) = v1(i) ^ v2(i)
VecAddScalar	1	向量加标量: out(i) = v(i) + scalar
VecSubtractScalar	1	向量减标量: out(i) = v(i) - scalar
VecScalarSubtract	1	标量减向量: out(i) = scalar - v(i)
VecMultiplyScalar	1	向量乘标量: out(i) = v(i) * scalar
VecDivideScalar	2	向量除以标量: out(i) = v(i) / scalar
VecScalarDivide	2	标量除以向量: out(i) = scalar / v(i)
VecIntegerDivideScalar	2	向量整除标量(VB 的 \, Int32)
VecScalarIntegerDivide	2	标量整除向量(VB 的 \, Int32)
VecModuloScalar	4	向量对标量取余(VB 的 Mod, Double)
VecScalarModulo	4	标量对向量取余(VB 的 Mod, Double)
VecPowerScalar	1	向量的标量次幂(VB 的 v ^ n)
VecScalarPower	1	标量的向量次幂(VB 的 b ^ v)
VecNegate	1	逐元素取负: out(i) = -v(i)
VecAbs	1	逐元素绝对值: out(i) = \|v(i)
VecSquare	1	逐元素平方: out(i) = v(i) * v(i)
VecSqrt	2	逐元素平方根
VecExp	2	逐元素自然指数
VecLog	3	逐元素任意底对数
VecSign	2	逐元素符号函数
VecFloor	2	逐元素向下取整
VecCeiling	2	逐元素向上取整
VecTruncate	2	逐元素截断取整
VecReciprocal	2	逐元素倒数: out(i) = 1 / v(i)
VecMap	1	任意一元函数的逐元素映射: out(i) = f(v(i))
VecConvert	1	逐元素元素类型转换。
VecSum	5	向量求和 SUM(v)(Double)
VecMean	4	向量均值(Double)
VecMin	5	向量最小值
VecMax	5	向量最大值
VecProduct	5	向量乘积 PRODUCT(v); 空向量返回乘法单位元 1
VecCount	1	向量元素个数 COUNT(v)
VecAdd	1
VecSubtract	1
VecMultiply	1
VecAddScalar	1
VecSubtractScalar	1
VecScalarSubtract	1
VecMultiplyScalar	1
VecNegate	1
VecAbs	1
VecSquare	1
VecMap	1
VecConvert	1
VecCount	1

03 Members

method ZipMap #

ZipMap``1(``0(), ``0(), Func(Of ``0, ``0, ``0))

逐元素二元运算的标量循环实现(VB 不支持泛型运算符约束, 因此运算由调用方注入)

method ZipScalarMap #

ZipScalarMap``1(``0(), ``0, Func(Of ``0, ``0, ``0))

向量 ⊕ 标量的标量循环实现

method ScalarZipMap #

ScalarZipMap``1(``0, ``0(), Func(Of ``0, ``0, ``0))

标量 ⊕ 向量的标量循环实现(标量位于左操作数一侧)

method VecAdd #

VecAdd``1(``0(), ``0())

逐元素相加: out(i) = v1(i) + v2(i)

method VecSubtract #

VecSubtract``1(``0(), ``0())

逐元素相减: out(i) = v1(i) - v2(i)

method VecMultiply #

VecMultiply``1(``0(), ``0())

逐元素相乘: out(i) = v1(i) * v2(i)

method VecDivide #

VecDivide(Double(), Double())

逐元素真除法(VB 的 /): out(i) = v1(i) / v2(i)

Remarks

只提供 Double/Single 形态 —— VB 的 / 对整型操作数会先把结果提升为 Double, 改写器在调用之前已经完成提升。

method VecDivide overload 2 #

VecDivide(Single(), Single())

逐元素真除法(VB 的 /, Single)

method VecIntegerDivide #

VecIntegerDivide(Int32(), Int32())

逐元素整除(VB 的 \, Int32)

method VecIntegerDivide overload 2 #

VecIntegerDivide(Int64(), Int64())

逐元素整除(VB 的 \, Int64)

method VecModulo overload 2 #

VecModulo(Int32(), Int32())

逐元素取余(VB 的 Mod, Int32)

method VecModulo overload 3 #

VecModulo(Int64(), Int64())

逐元素取余(VB 的 Mod, Int64)

method VecModulo overload 4 #

VecModulo(Single(), Single())

逐元素取余(VB 的 Mod, Single)

method VecModulo #

VecModulo(Double(), Double())

逐元素取余(VB 的 Mod, Double)

method VecPower #

VecPower(Double(), Double())

逐元素幂(VB 的 ^): out(i) = v1(i) ^ v2(i)

Remarks

VB 的 ^ 无论操作数为何种数值类型, 结果恒为 Double。

method VecAddScalar #

VecAddScalar``1(``0(), ``0)

向量加标量: out(i) = v(i) + scalar

method VecSubtractScalar #

VecSubtractScalar``1(``0(), ``0)

向量减标量: out(i) = v(i) - scalar

method VecScalarSubtract #

VecScalarSubtract``1(``0, ``0())

标量减向量: out(i) = scalar - v(i)

method VecMultiplyScalar #

VecMultiplyScalar``1(``0(), ``0)

向量乘标量: out(i) = v(i) * scalar

method VecDivideScalar #

VecDivideScalar(Double(), Double)

向量除以标量: out(i) = v(i) / scalar

method VecDivideScalar overload 2 #

VecDivideScalar(Single(), Single)

向量除以标量(Single)

method VecScalarDivide #

VecScalarDivide(Double, Double())

标量除以向量: out(i) = scalar / v(i)

method VecScalarDivide overload 2 #

VecScalarDivide(Single, Single())

标量除以向量(Single)

method VecIntegerDivideScalar #

VecIntegerDivideScalar(Int32(), Int32)

向量整除标量(VB 的 \, Int32)

method VecIntegerDivideScalar overload 2 #

VecIntegerDivideScalar(Int64(), Int64)

向量整除标量(VB 的 \, Int64)

method VecScalarIntegerDivide #

VecScalarIntegerDivide(Int32, Int32())

标量整除向量(VB 的 \, Int32)

method VecScalarIntegerDivide overload 2 #

VecScalarIntegerDivide(Int64, Int64())

标量整除向量(VB 的 \, Int64)

method VecModuloScalar overload 2 #

VecModuloScalar(Int32(), Int32)

向量对标量取余(VB 的 Mod, Int32)

method VecModuloScalar overload 3 #

VecModuloScalar(Int64(), Int64)

向量对标量取余(VB 的 Mod, Int64)

method VecModuloScalar overload 4 #

VecModuloScalar(Single(), Single)

向量对标量取余(VB 的 Mod, Single)

method VecModuloScalar #

VecModuloScalar(Double(), Double)

向量对标量取余(VB 的 Mod, Double)

method VecScalarModulo overload 2 #

VecScalarModulo(Int32, Int32())

标量对向量取余(VB 的 Mod, Int32)

method VecScalarModulo overload 3 #

VecScalarModulo(Int64, Int64())

标量对向量取余(VB 的 Mod, Int64)

method VecScalarModulo overload 4 #

VecScalarModulo(Single, Single())

标量对向量取余(VB 的 Mod, Single)

method VecScalarModulo #

VecScalarModulo(Double, Double())

标量对向量取余(VB 的 Mod, Double)

method VecPowerScalar #

VecPowerScalar(Double(), Double)

向量的标量次幂(VB 的 v ^ n)

method VecScalarPower #

VecScalarPower(Double, Double())

标量的向量次幂(VB 的 b ^ v)

method VecNegate #

VecNegate``1(``0())

逐元素取负: out(i) = -v(i)

method VecAbs #

VecAbs``1(``0())

逐元素绝对值: out(i) = |v(i)|

method VecSquare #

VecSquare``1(``0())

逐元素平方: out(i) = v(i) * v(i)

method VecSqrt #

VecSqrt(Double())

逐元素平方根

method VecSqrt overload 2 #

VecSqrt(Single())

逐元素平方根(Single)

method VecExp #

VecExp(Double())

逐元素自然指数

method VecExp overload 2 #

VecExp(Single())

逐元素自然指数(Single)

method VecLog overload 2 #

VecLog(Double())

逐元素自然对数

method VecLog overload 3 #

VecLog(Single())

逐元素自然对数(Single)

method VecLog #

VecLog(Double(), Double)

逐元素任意底对数

method VecSign #

VecSign(Double())

逐元素符号函数

method VecSign overload 2 #

VecSign(Single())

逐元素符号函数(Single)

method VecFloor #

VecFloor(Double())

逐元素向下取整

method VecFloor overload 2 #

VecFloor(Single())

逐元素向下取整(Single)

method VecCeiling #

VecCeiling(Double())

逐元素向上取整

method VecCeiling overload 2 #

VecCeiling(Single())

逐元素向上取整(Single)

method VecTruncate #

VecTruncate(Double())

逐元素截断取整

method VecTruncate overload 2 #

VecTruncate(Single())

逐元素截断取整(Single)

method VecReciprocal #

VecReciprocal(Double())

逐元素倒数: out(i) = 1 / v(i)

method VecReciprocal overload 2 #

VecReciprocal(Single())

逐元素倒数(Single)

method VecMap #

VecMap``2(``0(), Func(Of ``0, ``1))

任意一元函数的逐元素映射: out(i) = f(v(i))

Remarks

「逐元素数学函数」的通用兜底入口: 运行时没有专用内核的函数(三角函数、四舍五入、以及脚本自定义的数值函数)都通过本方法向量化。实现为标量循环 —— 委托调用本身无法被 SIMD 内核吸收。

method VecConvert #

VecConvert``2(``0())

逐元素元素类型转换。

Remarks

VB 对数组不存在逐元素转换(Short() 无法赋给 Integer() 形参), 因此当向量化运算两侧的元素类型不一致、或结果类型需要提升时, 改写器必须显式插入一次转换, 本方法即该用途。实现为标量循环, 每次只多一次遍历。

method VecSum #

VecSum(Double())

向量求和 SUM(v)(Double)

method VecSum overload 5 #

VecSum(Single())

向量求和 SUM(v)(Single)

method VecSum overload 3 #

VecSum(Int32())

向量求和 SUM(v)(Int32)

method VecSum overload 4 #

VecSum(Int64())

向量求和 SUM(v)(Int64)

method VecSum overload 2 #

VecSum(Int16())

向量求和 SUM(v)(Int16)

Remarks

LINQ 的数值归约把 Byte/Int16 一律拓宽到 Int32, 没有 Short 重载, 因此这里手写累加以保持「按元素类型累加」的语义。

method VecMean #

VecMean(Double())

向量均值(Double)

method VecMean overload 4 #

VecMean(Single())

向量均值(Single)

method VecMean overload 2 #

VecMean(Int32())

向量均值(Int32, 结果恒为 Double)

method VecMean overload 3 #

VecMean(Int64())

向量均值(Int64, 结果恒为 Double)

method VecMin #

VecMin(Double())

向量最小值

method VecMin overload 5 #

VecMin(Single())

向量最小值(Single)

method VecMin overload 3 #

VecMin(Int32())

向量最小值(Int32)

method VecMin overload 4 #

VecMin(Int64())

向量最小值(Int64)

method VecMin overload 2 #

VecMin(Int16())

向量最小值(Int16)

method VecMax #

VecMax(Double())

向量最大值

method VecMax overload 5 #

VecMax(Single())

向量最大值(Single)

method VecMax overload 3 #

VecMax(Int32())

向量最大值(Int32)

method VecMax overload 4 #

VecMax(Int64())

向量最大值(Int64)

method VecMax overload 2 #

VecMax(Int16())

向量最大值(Int16)

method VecProduct #

VecProduct(Double())

向量乘积 PRODUCT(v); 空向量返回乘法单位元 1

method VecProduct overload 5 #

VecProduct(Single())

向量乘积 PRODUCT(v)(Single)

method VecProduct overload 3 #

VecProduct(Int32())

向量乘积 PRODUCT(v)(Int32)

method VecProduct overload 4 #

VecProduct(Int64())

向量乘积 PRODUCT(v)(Int64)

method VecProduct overload 2 #

VecProduct(Int16())

向量乘积 PRODUCT(v)(Int16)

method VecCount #

VecCount``1(``0())

向量元素个数 COUNT(v)

Remarks

数组的 Length 访问是 O(1), 与 Enumerable.Count 的数组快速路径一致。

method VecAdd #

VecAdd(T(), T())

method VecSubtract #

VecSubtract(T(), T())

method VecMultiply #

VecMultiply(T(), T())

method VecAddScalar #

VecAddScalar(T(), T)

method VecSubtractScalar #

VecSubtractScalar(T(), T)

method VecScalarSubtract #

VecScalarSubtract(T, T())

method VecMultiplyScalar #

VecMultiplyScalar(T(), T)

method VecNegate #

VecNegate(T())

method VecAbs #

VecAbs(T())

method VecSquare #

VecSquare(T())

method VecMap #

VecMap(TIn(), Func(Of TIn, TOut))

method VecConvert #

VecConvert(TIn())

method VecCount #

VecCount(T())