在Lu中创建自定义数据类型，小矩阵乘效率测试，有胜出
本例中，我们将自定义矩阵（matrix）类型，基本类型和扩展类型均为matrix（标识矩阵）。基本要点：
（1）编写生成矩阵（matrix）的函数NewMatrix和销毁矩阵的函数DelMatrix。
（2）为自定义类型matrix编写运算符重载函数OpMatrix。
（3）用函数LockKey将重载函数OpMatrix注册到Lu，锁定的键的类型即为matrix，要注册为常量，以便于使用。
（4）为自定义类型matrix编写其他操作函数（本例未提供）。
（5）用函数LockKey解锁键matrix（本例中，程序退出时会自动解锁，故可以不用）。#include <windows.h>
#include <iostream>
#include <math.h>
#include "lu32.h"
#pragma comment( lib, "lu32.lib" )
using namespace std;
//自定义矩阵
class myMatrix
{
public:
double *Array; //数据缓冲区
luVOID ArrayLen; //数据缓冲区长度
luVOID Dim; //矩阵维数
myMatrix(){Array=NULL; ArrayLen=0; Dim=0; Dim=0;}
~myMatrix()
{
if(Array) delete[] Array;
}
};
luKEY Matrix=-1000; //标识矩阵类型，最终的Matrix由LockKey决定
void _stdcall LuMessage(wchar_t *pch)//输出动态库信息，该函数注册到Lu，由Lu二级函数调用
{
wcout<<pch;
}
void _stdcall DelMatrix(void *me) //用于LockKey函数及InsertKey函数，使Lu能自动销毁myMatrix对象
{
delete (myMatrix *)me;
}
myMatrix * _stdcall NewMatrix(luVOID m,luVOID n) //生成一个myMatrix对象
{
myMatrix *pMatrix;
luVOID k;
double *pa;
char keyname;
void *NowKey;
k=m*n;
pMatrix=(myMatrix *)GetBufObj(Matrix,keyname);//先尝试从缓冲区中获取一个矩阵对象
if(pMatrix)
{
if(pMatrix->ArrayLen!=k) //重置矩阵的大小
{
pa=new double;
if(!pa)
{
DeleteKey(keyname,sizeof(luVOID),Matrix,DelMatrix,1); //将矩阵对象放回缓冲区
return NULL;
}
delete[] pMatrix->Array;
pMatrix->Array=pa;
}
}
else
{
pMatrix=new myMatrix; //创建矩阵对象
if(!pMatrix) return NULL;
pMatrix->Array=new double;
if(!pMatrix->Array)
{
delete pMatrix;
return NULL;
}
if(InsertKey((char *)&pMatrix,-1,Matrix,pMatrix,DelMatrix,NULL,0,NowKey)) //将矩阵对象注册到Lu
{
delete pMatrix;
return NULL;
}
}
pMatrix->ArrayLen=k; pMatrix->Dim=m; pMatrix->Dim=n;
return pMatrix;
}
LuData _stdcall OpMatrix(luINT mm,LuData *xx,void *hFor,int theOperator) //运算符重载函数，用于LockKey函数
{
LuData a;
myMatrix *pMatrix1,*pMatrix2,*pMatrix3;
luVOID i,j,k,m,n,u,v;
double *pa,*pb,*pc;
luMessage pMessage;
wchar_t wchNum;
char chNum;
a.BType=luStaData_nil; a.VType=luStaData_nil; a.x=0;
switch(theOperator)
{
case 2: //重载运算符*
pMatrix1=(myMatrix *)SearchKey((char *)&(xx->x),sizeof(luVOID),Matrix);
pMatrix2=(myMatrix *)SearchKey((char *)&((xx+1)->x),sizeof(luVOID),Matrix);
if(!pMatrix1 || !pMatrix2) break; //对象句柄无效，不是矩阵
if(pMatrix1->Dim!=pMatrix2->Dim) break; //维数不匹配
pMatrix3=NewMatrix(pMatrix1->Dim,pMatrix2->Dim); //生成新矩阵
if(!pMatrix3) break;
pa=pMatrix1->Array; pb=pMatrix2->Array; pc=pMatrix3->Array;
m=pMatrix1->Dim; n=pMatrix1->Dim; k=pMatrix2->Dim;
for(i=0; i<m; i++) //矩阵乘
{
for(j=0; j<k; j++)
{
u=i*k+j; pc=0.0;
for (v=0; v<n; v++)
{
pc=pc+pa*pb;
}
}
}
FunReObj(hFor); //告诉Lu，返回一个动态对象
a.BType=Matrix; a.VType=Matrix; a.x=0; *(luVOID *)&(a.x)=(luVOID)pMatrix3;
break;
case 25: //重载运算符.*
pMatrix1=(myMatrix *)SearchKey((char *)&(xx->x),sizeof(luVOID),Matrix);
pMatrix2=(myMatrix *)SearchKey((char *)&((xx+1)->x),sizeof(luVOID),Matrix);
if(!pMatrix1 || !pMatrix2) break; //对象句柄无效，不是矩阵
if(pMatrix1->Dim!=pMatrix2->Dim || pMatrix1->Dim!=pMatrix2->Dim) break; //维数不相同
pMatrix3=NewMatrix(pMatrix1->Dim,pMatrix1->Dim); //生成新矩阵
if(!pMatrix3) break;
for(i=0;i<pMatrix1->ArrayLen;i++) pMatrix3->Array=pMatrix1->Array*pMatrix2->Array; //矩阵点乘
FunReObj(hFor); //告诉Lu，返回一个动态对象
a.BType=Matrix; a.VType=Matrix; a.x=0; *(luVOID *)&(a.x)=(luVOID)pMatrix3;
break;
case 46: //重载函数new
if(mm<2) break;
if((xx+1)->x<1 || (xx+2)->x<1 || (xx+1)->BType!=luStaData_int64 || (xx+2)->BType!=luStaData_int64) break;
pMatrix3=NewMatrix((luVOID)(xx+1)->x,(luVOID)(xx+2)->x);//生成新矩阵
if(!pMatrix3) break;
for(j=0,i=3;i<=mm;i++,j++) //赋初值
{
if(j>=pMatrix3->ArrayLen) break;
if((xx+i)->BType!=luStaData_double) break; //只接受实数参数
pMatrix3->Array=*(double *)&((xx+i)->x);
}
FunReObj(hFor); //告诉Lu，返回一个动态对象
a.BType=Matrix; a.VType=Matrix; a.x=0; *(luVOID *)&(a.x)=(luVOID)pMatrix3;
break;
case 49: //重载函数o
pMessage=(luMessage)SearchKey("\0\0\0\0",sizeof(luVOID),luPubKey_User);
if(!pMessage) break;
pMatrix1=(myMatrix *)SearchKey((char *)&(xx->x),sizeof(luVOID),Matrix);
if(!pMatrix1) break; //对象句柄无效，不是矩阵
pa=pMatrix1->Array;
m=pMatrix1->Dim; n=pMatrix1->Dim; k=0;
for(i=0; i<m; i++) //输出矩阵
{
pMessage(L"\r\n"); k+=2;
for(j=0; j<n; j++)
{
_gcvt_s(chNum,pa,16);
for(u=0;chNum;u++) {wchNum=chNum; k++;}
wchNum='\0';
pMessage(wchNum); pMessage(L""); k+=2;
}
}
pMessage(L"\r\n"); k+=2;
a.BType=luStaData_int64; a.VType=luStaData_int64; a.x=k; //按函数o的要求，返回输出的字符总数
break;
default:
break;
}
return a;
}
void main(void)
{
void *hFor; //表达式句柄
luINT nPara; //存放表达式的自变量个数
LuData *pPara; //存放输入自变量的数组指针
luINT ErrBegin,ErrEnd; //表达式编译出错的初始位置和结束位置
int ErrCode; //错误代码
void *v;
wchar_t ForStr[]=L"o{new*new}";//字符串表达式，矩阵乘
//wchar_t ForStr[]=L"o{new.*new}";//字符串表达式，矩阵点乘
LuData Val;
if(!InitLu()) return; //初始化Lu
while(LockKey(Matrix,DelMatrix,OpMatrix)){Matrix--;} //锁定一个键，用于存储矩阵扩展类型
Val.BType=luStaData_int64; Val.VType=luStaData_int64; Val.x=Matrix; //定义整数常量
SetConst(L"matrix",&Val); //设置整数常量
InsertKey("\0\0\0\0",4,luPubKey_User,LuMessage,NULL,NULL,1,v); //使Lu运行时可输出函数信息
wcout.imbue(locale("chs")); //设置输出的locale为中文
ErrCode=LuCom(ForStr,0,0,0,hFor,nPara,pPara,ErrBegin,ErrEnd); //编译表达式
if(ErrCode)
{
wcout<<L"表达式有错误！错误代码："<<ErrCode<<endl;
}
else
{
LuCal(hFor,pPara); //计算表达式的值
}
LockKey(Matrix,NULL,OpMatrix);//解锁键Matrix，本例中，该函数可以不用
FreeLu(); //释放Lu
}习题：
（1）自定义矩阵的加、减、左除、右除、点左除等运算，自编测试字符串代码，重新编译运行程序，观察计算结果。
（2）小矩阵乘效率测试。编译运行以下Lu字符串代码：main(:a,b,c,d,t,i)=
a=new,
b=new,
c=new,
t=clock(),
d=a*b, i=0, while{i<1000000, d=d*c*b, i++},
o{d, "time=",/1000.," seconds.\r\n"}C/C++中的字符串定义为：wchar_t ForStr[]=L"main(:a,b,c,d,t,i)= a=new, b=new, c=new, t=clock(), d=a*b, i=0, while{i<1000000, d=d*c*b, i++}, o{d, \"time=\",/1000.,\" seconds.\r\n\"}";//字符串表达式结果：4. 5.
5. 4.
time=0.797 seconds.
请按任意键继续. . .Matlab 2009a 代码：a=;
b=;
c=;
tic,
d=a*b;
for i=1:1000000
d=d*c*b;
end
d,
toc结果：d =
4 5
5 4
Elapsed time is 2.903034 seconds.本例矩阵乘效率测试，Lu的速度超过了Matlab，主要在于Lu有更高的动态对象管理效率。
与上例相比较可以知道，自定义数据类型和系统内置类型有近乎相同的效率。
页:
[1]