金字塔量化

# MFADD 向量元素相加

向量元素相加。

mfAdd(a,b,r,n)

参数
参数 说明
a 必需，向量
b 必需，向量
r 必需，向量(输出值)
n 必需，向量; a,b,r个数(n取值范围:0<n<=a,b,r的数组长度
示例
VARIABLE : a[5]=(1,2,3,4,5);
VARIABLE : b[5]=(1,2,3,4,5);
VARIABLE : r[5]=0;
If IsLastbar Then
Begin
    MFADD(a,b,r,5);
    for i = 1 to 5 do
        msgout(1,numtostr(r[i],0)); //结果将返回2，4，6，8，10
End
1
2
3
4
5
6
7
8
9

# MFAMAX 绝对值最大的元素的索引

查找绝对值最大的元素的索引。

mfamax(x,n)

  1. 向量运算为兼容pel架构，其向量计算均从右向左运算。
参数
参数 说明
x 必需，向量
n 必需，向量x个数 (n取值范围:0<n<=x的数组长度).

返回值：基于1索引的向量元素位置

示例
VARIABLE:x[5]=(0,1,2,3,4);
Rets:MFAMAX(x,5); //结果将返回5
1
2

# MFAMIN 绝对值最小的元素的索引

查找绝对值最小的元素的索引。

MFAMIN(x,n)

  1. 向量运算为兼容pel架构，其向量计算均从右向左运算。
参数
参数 说明
x 必需，向量
n 必需，向量x个数 (n取值范围:0<n<=x的数组长度).

返回值：基于1索引的向量元素位置

示例
VARIABLE:x[5]=(0,1,2,3,4);
Rets:MFAMIN(x,5); //结果将返回0
1
2

# MFDIV 向量元素相除

向量元素相除。

MFDIV(a,b,r,n)

  1. 向量运算为兼容pel架构，其向量计算均从右向左运算。
参数
参数 说明
a 必需，向量
b 必需，向量
r 必需，向量(输出值)
n 必需，向量; a,b,r个数(n取值范围:0<n<=a,b,r的数组长度
示例
VARIABLE : a[5]=(1,2,3,4,5);
VARIABLE : b[5]=(1,2,3,4,5);
VARIABLE : r[5]=0;
If IsLastbar Then
Begin
    MFDIV(a,b,r,5);
    for i = 1 to 5 do
        msgout(1,numtostr(r[i],0)); //结果将返回1，1，1，1，1
End
1
2
3
4
5
6
7
8
9

# MFDOT 向量元素点乘

计算两个向量元素的点积。算法：xy=x1y1+...+xn*yn。

MFDOT(x,y,n)

  1. 向量运算为兼容pel架构，其向量计算均从右向左运算。
参数
参数 说明
x 必需，向量
y 必需，向量
n 必需，向量; x,y数量(n取值范围:0<n<=x,y的数组长度)
示例
VARIABLE : x[5]=(0,1,2,3,4);
VARIABLE : y[5]=(1,2,3,4,5);
RETS:MFDOT(x,y,5);//结果将输出40
1
2
3

# MFFFT 快速傅立叶变换

矩阵与矩阵乘积。算法:C=alpha*op(A)op(B) + betaC,

MFFFT(X,Y,N,T)

参数
参数 说明
X 必需，输入源向量数组
Y 必需，输出向量数组,以复数方式返回(由2个数字组成)，因此数组申明大小必须为X的2倍
N 必需，X向量变换源数组大小
T 必需，0向前变换 1向后变换.
示例
n:=16; //16点信号变换
VARIABLE : x[n]=(15, 32, 9, 222, 118, 151, 5, 7, 56, 233, 56, 121, 235, 89, 98, 111);
VARIABLE : y[n*2]=0;  //以复数方式返回结果，因此需要2倍容量
If IsLastbar Then
Begin
        MFFFT(x,y,n,0);
        for i = 1 to n*2 do
        msgout(1,numtostr(y[i],3));
End
1
2
3
4
5
6
7
8
9

# MFGEMM 矩阵与矩阵乘积

矩阵与矩阵乘积。算法:C=alpha*op(A)op(B) + betaC,

MFGEMM(A,B,C,alpha,beta,m,n,k)

参数
参数 说明
A 必需，矩阵
B 必需，矩阵
C 必需，矩阵（输入和输出参数）
alpha 必需，标量
beta 必需，标量
m 必需，矩阵A和矩阵C的行数,
n 必需，矩阵B和矩阵C的列数
k 必需，矩阵A的列数和矩阵B的行数,

返回值：最终更新到矩阵C.

示例
m:=2;//矩阵A和矩阵C的行数
n:=3;//矩阵B和矩阵C的列数
k:=2;//矩阵A的列数和矩阵B的行数
alpha:=1;
betas:=1;
VARIABLE : a[m*n]=(1,2,3,  4,5,6); //矩阵维度 2*3
VARIABLE : b[n*k]=(1,1,  1,1,  1,1); //矩阵维度 3*2(计算时候转置)
VARIABLE : x[m*k]=(0,1,  2,3);      //矩阵维度 2*2
If IsLastbar Then
       Begin
       MFGEMM(a,b,x,alpha,betas,m,n,k);
       for i = 1 to m*k do
       msgout(1,numtostr(x[i],0));
End  
//结果将输出矩阵为
//6 7
//1718
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

# MFGEMV 矩阵与向量的乘积

矩阵与向量的乘积。

mfgemv(A,X,Y,T,M,N,alpha,beta)

参数
参数 说明
A 必需，m*n的矩阵
X 必需，向量
Y 必需，向量(输入和输出参数)
T 必需，计算方式。
 T=0时 Y:= alphaAX + betaY,
 T=1时 Y:= alphaA'X + betaY,
 T=2时 Y := alpha*conjg(A')X + betaY,
M 必需，矩阵A的行数
N 必需，矩阵A的列数（向量x维度）
alpha 必需，标量
beta 必需，标量

返回值:最终更新到向量y.

示例
m:=2;//矩阵行数
n:=5;//矩阵列数
alpha:=1;
mbeta:=1;
VARIABLE : a[m*n]=( 0,1,2,3,4,  5,6,7,8,9 ); //定义一个2行5列矩阵
VARIABLE : x[n]=(1,2,3,4,5); //向量数组
VARIABLE : y[m]=0;
If IsLastbar Then
      Begin
        //2*5的矩阵与5*1的向量相乘
        FGEMV(a,x,y,0,m,n,alpha,mbeta);
        for i = 1 to m do
            msgout(1,numtostr(y[i],0)); //结果将输出40, 115
End
1
2
3
4
5
6
7
8
9
10
11
12
13
14

# MFGER 矩阵的一阶更新

矩阵的一阶更新（矩阵-向量乘积）算法:A=alphaxy'+ A,

MFGER(X,Y,A,M,N,alpha)

参数
参数 说明
X 必需，向量(m行)
Y 必需，向量(n列)
A 必需，m×n 的矩阵(输入和输出参数)
M 必需，矩阵A的行数
N 必需，矩阵A的列数
alpha 必需，标量

返回值：最终更新到矩阵a.

示例
m:=2;//矩阵行数
n:=5;//矩阵列数
alpha:=1;
VARIABLE : x[m]=(1,2); 
VARIABLE : y[n]=(2,3,4,5,6);
VARIABLE : a[m*n]=( 1,1,1,1,1,  1,1,1,1,1 ); //定义一个2行5列矩阵

If IsLastbar Then
       Begin
            //5*1向量乘以1*5向量，加上5*5矩阵
       MFGER(x,y,a,m,n,alpha);
       for i = 1 to m*n do
       msgout(1,numtostr(a[i],0));
End
1
2
3
4
5
6
7
8
9
10
11
12
13
14

结果将输出矩阵为:
3 4 5 6 7
5 7 9 11 13

# MFMUL 向量元素相乘

向量元素相乘。

MFMUL(a,b,r,n);

  1. 向量运算为兼容pel架构，其向量计算均从右向左运算。
参数
参数 说明
a 必需，向量
b 必需，向量
r 必需，向量(输出值)
n 必需，向量; a,b,r个数(n取值范围:0<n<=a,b,r的数组长度
示例
VARIABLE : a[5]=(1,2,3,4,5);
VARIABLE : b[5]=(1,2,3,4,5);
VARIABLE : r[5]=0;
If IsLastbar Then
Begin
    MFMUL(a,b,r,5);
    for i = 1 to 5 do
        msgout(1,numtostr(r[i],0)); //结果将返回1，2，9，16，25
End
1
2
3
4
5
6
7
8
9

# MFNRM2 欧几里得范数

计算一个向量的欧几里得范数。算法：|x| = √( x[1]2 + x[2]2 + … + x[n]2 )。

MFMUL(a,b,r,n)

  1. 向量运算为兼容pel架构，其向量计算均从右向左运算。
参数
参数 说明
x 必需，向量
n 必需，向量x个数;(n取值范围:0<n<=x的数组长度).
示例
VARIABLE : x[5]=(1,2,3,4,5);
RETS:MFNRM2(x,5); //结果将输出 7.416
1
2

# MFSCAL 计算向量和标量的乘积

计算向量和标量的乘积。算法：x=a*x。

mfscal(x,a,n)

  1. 向量运算为兼容pel架构，其向量计算均从右向左运算。
参数
参数 说明
x 必需， 向量（输入/输出参数）
n 必需，标量a, n:向量x个数(n取值范围:0<n<=x的数组长度).
示例
VARIABLE : x[5]=(1,2,3,4,5);
a:=0.1;
If IsLastbar Then
Begin
        MFSCAL(x,a,5);
        for i = 1 to 5 do
        Msgout(1,numtostr(x[i],1));  //结果将输出 0.1,0.2,0.3,0.4,0.5
End
1
2
3
4
5
6
7
8

# MFSUB 向量元素相减

向量元素相减。

mfSub(a,b,r,n)

  1. 向量运算为兼容pel架构，其向量计算均从右向左运算。
参数
参数 说明
a 必需，向量
b 必需，向量
r 必需，向量(输出值)
n 必需，向量; a,b,r个数(n取值范围:0<n<=a,b,r的数组长度
示例
VARIABLE : a[5]=(1,2,3,4,5);
VARIABLE : b[5]=(1,2,3,4,5);
VARIABLE : r[5]=0;
If IsLastbar Then
Begin
    mfSub(a,b,r,5);
    for i = 1 to 5 do
        msgout(1,numtostr(r[i],0)); //结果将返回0，0，0，0，0
End
1
2
3
4
5
6
7
8
9

# MFSUM 向量元素之和

计算向量x的元素大小之和

MFSUM(X,N)

  1. 向量运算为兼容pel架构，其向量计算均从右向左运算。
参数
参数 说明
x 必需， X为向量(n*1)(矩阵也可以看做向量)
n 必需，N为向量数组数量,(N取值范围:0<N<=数组数量)。
示例
VARIABLE:x[]=0;
     x:=c;
     rets:Mfsum(x,5);
1
2
3

# MFSWAP 交换向量值

交换向量值, 完成向量x和y的交换。

mfswap(x,y,n)

  1. 向量运算为兼容pel架构，其向量计算均从右向左运算。
参数
参数 说明
X 必需，向量
Y 必需，向量
N 必需，向量; x,y数量(n取值范围:0<n<=x,y的数组长度).
示例
VARIABLE : x[5]=(0,1,2,3,4);
VARIABLE : y[5]=(1,2,3,4,5);
If IsLastbar Then
Begin
    Mfswap(x,y,5);
    for i = 1 to 5 do
    msgout(1,numtostr(y[i],0)); //输出交换后的y数组
End
1
2
3
4
5
6
7
8

# MFXPY 迭代求取向量标量乘积之和

计算向量-标量的积,并将结果迭代累加。算法如下: y:=alpha*x+y。

MFXPY(X,Y,alpha,N)

  1. 向量运算为兼容pel架构，其向量计算均从右向左运算。
参数
参数 说明
X 必需，向量
Y 必需，向量(输出参数,即存储结果)
alpha 必需，标量
N 必需，指定向量x,y的元素个数(n取值范围:0<n<=向量x,y的元素个数).

返回值：最终更新到向量y

示例
alpha:=1;
VARIABLE : x[5]=(0,1,2,3,4);
VARIABLE : y[5]=(1,2,3,4,5);
If IsLastbar Then
Begin
    MFXPY(x,y,ALPHA,5);
    for i = 1 to 5 do
    msgout(1,numtostr(y[i],0));//结果将输出 1,3,5,7,9
End
1
2
3
4
5
6
7
8
9

← 统计函数 →