Lu基于系统内置对象创建扩展数据类型，小矩阵乘效率测试，有胜出

forcal

Lu基于系统内置对象创建扩展数据类型，小矩阵乘效率测试，有胜出

本例中，我们将基于系统内置实数数组创建矩阵（matrix）类型，即：基本类型为luDynData_realarray（标识实数数组），扩展类型为matrix（标识矩阵）。为了简单，我们仅处理二维实数数组即矩阵类型。 基本要点： （1）为扩展类型matrix编写运算符重载函数OpMatrix。 （2）用函数LockKey将重载函数OpMatrix注册到Lu，锁定的键的类型即为matrix，要注册为常量，以便于使用。 （3）为扩展类型matrix编写其他操作函数（本例未提供）。 （4）用函数LockKey解锁键matrix（本例中，程序退出时会自动解锁，故可以不用）。 仅需要以下支持文件： 1）头文件lu32.h。 2）导入库lu32.lib。 3）核心库lu32.dll。

1. #include <windows.h>
2. #include <iostream>
3. #include <math.h>
4. #include "lu32.h"
5. #pragma comment( lib, "lu32.lib" )
6. using namespace std;
7. luKEY Matrix=-1000; //标识矩阵类型，最终的Matrix由LockKey决定
8. void _stdcall LuMessage(wchar_t *pch)//输出动态库信息，该函数注册到Lu，由Lu二级函数调用
9. {
10. wcout<<pch;
11. }
12. void _stdcall DelMatrix(void *me) //用于LockKey函数，因为是基于系统内置实数数组创建矩阵，故该函数什么也不做
13. {
14. }
15. LuData _stdcall OpMatrix(luINT mm,LuData *xx,void *hFor,int theOperator) //运算符重载函数，用于LockKey函数
16. {
17. LuData a;
18. luRealArray *pRealArray1,*pRealArray2,*pRealArray3;
19. luVOID i,j,k,m,n,u,v;
20. double *pa,*pb,*pc;
21. luMessage pMessage;
22. wchar_t wchNum[32];
23. char chNum[32];
24. a.BType=luStaData_nil; a.VType=luStaData_nil; a.x=0;
25. switch(theOperator)
26. {
27. case 2: //重载运算符*
28. pRealArray1=(luRealArray *)SearchKey((char *)&(xx->x),sizeof(luVOID),luDynData_realarray);
29. pRealArray2=(luRealArray *)SearchKey((char *)&((xx+1)->x),sizeof(luVOID),luDynData_realarray);
30. if(!pRealArray1 || !pRealArray2) break; //对象句柄无效，不是实数数组
31. if(pRealArray1->DimLen!=2 || pRealArray2->DimLen!=2) break; //不是二维实数数组（矩阵）
32. if(pRealArray1->Dim[1]!=pRealArray2->Dim[0]) break; //维数不匹配
33. pRealArray3=(luRealArray *)NewSysObj(luDynData_realarray,pRealArray1->Dim[0]*pRealArray2->Dim[1],2); //创建矩阵对象
34. if(!pRealArray3) break;
35. pRealArray3->Dim[0]=pRealArray1->Dim[0]; pRealArray3->Dim[1]=pRealArray2->Dim[1]; //设置矩阵维数大小
36. pa=pRealArray1->Array; pb=pRealArray2->Array; pc=pRealArray3->Array;
37. m=pRealArray1->Dim[0]; n=pRealArray1->Dim[1]; k=pRealArray2->Dim[1];
38. for(i=0; i<m; i++) //矩阵乘
39. {
40. for(j=0; j<k; j++)
41. {
42. u=i*k+j; pc[u]=0.0;
43. for (v=0; v<n; v++)
44. {
45. pc[u]=pc[u]+pa[i*n+v]*pb[v*k+j];
46. }
47. }
48. }
49. FunReObj(hFor); //告诉Lu，返回一个动态对象
50. a.BType=luDynData_realarray; a.VType=Matrix; a.x=0; *(luVOID *)&(a.x)=(luVOID)pRealArray3;
51. break;
52. case 25: //重载运算符.*
53. pRealArray1=(luRealArray *)SearchKey((char *)&(xx->x),sizeof(luVOID),luDynData_realarray);
54. pRealArray2=(luRealArray *)SearchKey((char *)&((xx+1)->x),sizeof(luVOID),luDynData_realarray);
55. if(!pRealArray1 || !pRealArray2) break; //对象句柄无效，不是实数数组
56. if(pRealArray1->DimLen!=2 || pRealArray2->DimLen!=2) break; //不是二维实数数组（矩阵）
57. if(pRealArray1->Dim[0]!=pRealArray2->Dim[0] || pRealArray1->Dim[1]!=pRealArray2->Dim[1]) break; //维数不相同
58. pRealArray3=(luRealArray *)NewSysObj(luDynData_realarray,pRealArray1->ArrayLen,2); //创建矩阵对象
59. if(!pRealArray3) break;
60. pRealArray3->Dim[0]=pRealArray1->Dim[0]; pRealArray3->Dim[1]=pRealArray1->Dim[1]; //设置矩阵维数大小
61. for(i=0;i<pRealArray1->ArrayLen;i++) pRealArray3->Array[i]=pRealArray1->Array[i]*pRealArray2->Array[i];//矩阵点乘
62. FunReObj(hFor); //告诉Lu，返回一个动态对象
63. a.BType=luDynData_realarray; a.VType=Matrix; a.x=0; *(luVOID *)&(a.x)=(luVOID)pRealArray3;
64. break;
65. case 46: //重载函数new
66. a=ExeOperator(mm,xx,hFor,theOperator,luDynData_realarray); //直接调用基本类型luDynData_realarray的new函数
67. if(a.VType==luDynData_realarray) a.VType=Matrix; //设置扩展类型为自定义的Matrix类型
68. break;
69. case 49: //重载函数o
70. pMessage=(luMessage)SearchKey("\0\0\0\0",sizeof(luVOID),luPubKey_User);
71. if(!pMessage) break;
72. pRealArray1=(luRealArray *)SearchKey((char *)&(xx->x),sizeof(luVOID),luDynData_realarray);
73. if(!pRealArray1) break; //对象句柄无效，不是实数数组
74. if(pRealArray1->DimLen!=2) break; //不是二维实数数组（矩阵）
75. pa=pRealArray1->Array;
76. m=pRealArray1->Dim[0]; n=pRealArray1->Dim[1]; k=0;
77. for(i=0; i<m; i++) //输出矩阵
78. {
79. pMessage(L"\r\n"); k+=2;
80. for(j=0; j<n; j++)
81. {
82. _gcvt_s(chNum,pa[i*n+j],16);
83. for(u=0;chNum[u];u++) {wchNum[u]=chNum[u]; k++;}
84. wchNum[u]='\0';
85. pMessage(wchNum); pMessage(L" "); k+=2;
86. }
87. }
88. pMessage(L"\r\n"); k+=2;
89. a.BType=luStaData_int64; a.VType=luStaData_int64; a.x=k; //按函数o的要求，返回输出的字符总数
90. break;
91. default:
92. break;
93. }
94. return a;
95. }
96. void main(void)
97. {
98. void *hFor; //表达式句柄
99. luINT nPara; //存放表达式的自变量个数
100. LuData *pPara; //存放输入自变量的数组指针
101. luINT ErrBegin,ErrEnd; //表达式编译出错的初始位置和结束位置
102. int ErrCode; //错误代码
103. void *v;
104. wchar_t ForStr[]=L"o{new[matrix,2,3,data: 0.,1.,2.;3.,4.,5.]*new[matrix,3,2,data: 1.,2.;3.,4.;5.,6.]}";//字符串表达式，矩阵乘
105. //wchar_t ForStr[]=L"o{new[matrix,2,3,data: 0.,1.,2.;3.,4.,5.].*new[matrix,2,3,data: 1.,2.,3.;4.,5.,6.]}";//字符串表达式，矩阵点乘
106. LuData Val;
107. if(!InitLu()) return; //初始化Lu
108. while(LockKey(Matrix,DelMatrix,OpMatrix)){Matrix++;} //锁定一个键，用于存储矩阵扩展类型
110. Val.BType=luStaData_int64; Val.VType=luStaData_int64; Val.x=Matrix; //定义整数常量
111. SetConst(L"matrix",&Val); //设置整数常量
112. InsertKey("\0\0\0\0",4,luPubKey_User,LuMessage,NULL,NULL,1,v); //使Lu运行时可输出函数信息
113. wcout.imbue(locale("chs")); //设置输出的locale为中文
115. ErrCode=LuCom(ForStr,0,0,0,hFor,nPara,pPara,ErrBegin,ErrEnd); //编译表达式
116. if(ErrCode)
117. {
118. wcout<<L"表达式有错误！错误代码："<<ErrCode<<endl;
119. }
120. else
121. {
122. LuCal(hFor,pPara); //计算表达式的值
123. }
124. LockKey(Matrix,NULL,OpMatrix);//解锁键Matrix，本例中，该函数可以不用
125. FreeLu(); //释放Lu
126. }

复制代码

习题： （1）自定义矩阵的加、减、左除、右除、点左除等运算，自编测试字符串代码，重新编译运行程序，观察计算结果。 （2）小矩阵乘效率测试。编译运行以下Lu字符串代码：

1. main(:a,b,c,d,t,i)=
2. a=new[matrix,2,2,data:1.,2.,2.,1.],
3. b=new[matrix,2,2,data:2.,1.,1.,2.],
4. c=new[matrix,2,2,data:2/3.,-1/3.,-1/3.,2/3.],
5. t=clock(),
6. d=a*b, i=0, while{i<1000000, d=d*c*b, i++},
7. o{d, "time=",[clock()-t]/1000.," seconds.\r\n"}

复制代码

C/C++中的字符串定义为：

1. wchar_t ForStr[]=L"main(:a,b,c,d,t,i)= a=new[matrix,2,2,data:1.1,2.,2.,1.], b=new[matrix,2,2,data:2.,1.,1.,2.], c=new[matrix,2,2,data:2/3.,-1/3.,-1/3.,2/3.], t=clock(), d=a*b, i=0, while{i<1000000, d=d*c*b, i++}, o{d, "time=",[clock()-t]/1000.," seconds.\r\n"}";//字符串表达式

复制代码

结果：

1. 4. 5.
2. 5. 4.
3. time=0.875 seconds.
4. 请按任意键继续. . .

复制代码

Matlab 2009a 代码：

1. a=[1.,2.;2.,1.];
2. b=[2.,1.;1.,2.];
3. c=[2/3.,-1/3.;-1/3.,2/3.];
4. tic,
5. d=a*b;
6. for i=1:1000000
7. d=d*c*b;
8. end
9. d,
10. toc

复制代码

结果：

1. d =
2. 4 5
3. 5 4
4. Elapsed time is 2.903034 seconds.

复制代码

本例矩阵乘效率测试，Lu的速度超过了Matlab，主要在于Lu有更高的动态对象管理效率。