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

forcal

    本例中，我们将基于系统内置实数数组创建矩阵（matrix）类型，即：基本类型为luDynData_realarray（标识实数数组），扩展类型为matrix（标识矩阵）。为了简单，我们仅处理二维实数数组即矩阵类型。
2 D6 Q3 ^. o* z# e8 h
    基本要点：
( I* B" ]5 e$ ]/ N
5 e4 \8 i; S+ N1 q: Q" W    （1）为扩展类型matrix编写运算符重载函数OpMatrix。
* ?, Z4 t% h  R* @2 b
, C1 L4 Q+ h# N3 X1 D) h5 ?1 m    （2）用函数LockKey将重载函数OpMatrix注册到Lu，锁定的键的类型即为matrix，要注册为常量，以便于使用。

$ H# ]- P( e. e9 x9 j    （3）为扩展类型matrix编写其他操作函数（本例未提供）。

5 [+ }* u7 n- J% e    （4）用函数LockKey解锁键matrix（本例中，程序退出时会自动解锁，故可以不用）。

2. #include <windows.h>/ x4 r# A) T; X% y
   
4. #include <iostream>6 @0 N4 I1 D! a6 \- c- X
   
6. #include <math.h>
   
7. 1 F& @1 J. @! j, A
8. #include "lu32.h"; T. v( Z3 s1 M1 o+ w
   
10. , a  c  P) A3 d+ M: p
    
12. #pragma comment( lib, "lu32.lib" )7 x, a6 i; g7 q( x+ y' g5 w: K% u! X
    
14. 
    
15. ; B% b6 H* @' B
16. using namespace std;: V: c& s8 c% L( }7 C& m3 `6 r3 q
    
18. 3 E\\" `: {, t% I
    
20. luKEY Matrix=-1000;        //标识矩阵类型，最终的Matrix由LockKey决定
    
21. , U# p' j2 ~- Q4 X' r
22. 
    
23. ) W  o6 h. a, e\\" H
24. void _stdcall LuMessage(wchar_t *pch)//输出动态库信息，该函数注册到Lu，由Lu二级函数调用 4 ?9 a7 O% v) i1 I5 [
    
26. {- N( G3 c- i5 m, A. B+ t
    
28.         wcout<<pch;
    
29. * K7 Y2 W1 w; F1 e; C
30. }
    
31. # L/ T4 h3 n% K8 F
32. void _stdcall DelMatrix(void *me)        //用于LockKey函数，因为是基于系统内置实数数组创建矩阵，故该函数什么也不做4 g4 t( n8 m) D1 ]
    
34. {
    
35. 1 q' c& I/ `4 K! a. y
36. }
    
37. 7 t& {# V, m+ G4 W
38. LuData _stdcall OpMatrix(luINT mm,LuData *xx,void *hFor,int theOperator)        //运算符重载函数，用于LockKey函数
    
39. & c( h\\" U  _6 u: C: q; s
40. {
    
41. \\" ?2 t* D# D  Y
42.         LuData a;
    
43. / P! H* A6 [8 I6 h( n0 {; b4 ~
44.         luRealArray *pRealArray1,*pRealArray2,*pRealArray3;
    
45. ; \  D# r; Y+ c8 _0 H3 ^: N! O
46.         luVOID i,j,k,m,n,u,v;
    
47. ! k* U+ @- J9 S. \9 V, n6 D
48.         double *pa,*pb,*pc;! i2 E; h; J$ I8 P, J
    
50.         luMessage pMessage;3 J$ Y2 o9 d; ?  v( J$ g
    
52.         wchar_t wchNum[32];
    
53. ( P( |% x9 p4 ^5 c8 Q
54.         char chNum[32];! l# O5 Z- T2 Z\\" ]# q8 A
    
56.         a.BType=luStaData_nil; a.VType=luStaData_nil; a.x=0;
    
57. 9 [$ c$ y# d  X: f4 Z
58.         switch(theOperator)7 I6 M6 L: C/ z9 N) s
    
60.         {  U2 h9 _6 f4 O  U4 S
    
62.         case 2:        //重载运算符*( E8 u5 e( Y! w
    
64.                 pRealArray1=(luRealArray *)SearchKey((char *)&(xx->x),sizeof(luVOID),luDynData_realarray);$ G$ Y! R+ c\\" d9 z; Q6 n5 t
    
66.                 pRealArray2=(luRealArray *)SearchKey((char *)&((xx+1)->x),sizeof(luVOID),luDynData_realarray);
    
67. + o$ y7 `) W; ~& O* ~/ w3 R
68.                 if(!pRealArray1 || !pRealArray2) break;        //对象句柄无效，不是实数数组+ G& K: |2 O% M$ F0 g
    
70.                 if(pRealArray1->DimLen!=2 || pRealArray2->DimLen!=2) break;        //不是二维实数数组（矩阵）
    
71.   Q9 E  J. N! L) ^) v* e
72.                 if(pRealArray1->Dim[1]!=pRealArray2->Dim[0]) break;        //维数不匹配$ k( J0 i7 J3 K% U0 l  A
    
74.                 pRealArray3=(luRealArray *)NewSysObj(luDynData_realarray,pRealArray1->Dim[0]*pRealArray2->Dim[1],2);        //创建矩阵对象! U4 t0 x# z$ g/ |# _. n- e
    
76.                 if(!pRealArray3) break;
    
77. 0 H9 G# g: o+ P; u* {* q* Y
78.                 pRealArray3->Dim[0]=pRealArray1->Dim[0]; pRealArray3->Dim[1]=pRealArray2->Dim[1];        //设置矩阵维数大小
    
79. . R( L1 b$ Y% W+ g
80.                 pa=pRealArray1->Array; pb=pRealArray2->Array; pc=pRealArray3->Array;# r/ o4 |/ w% x: s4 T9 z! l9 X
    
82.                 m=pRealArray1->Dim[0]; n=pRealArray1->Dim[1]; k=pRealArray2->Dim[1];
    
83. 3 P& N8 x( A8 G7 a+ f
84.                 for(i=0; i<m; i++)        //矩阵乘4 e- c0 C# G6 h$ l7 h
    
86.                 {
    
87. 6 h8 V4 ]+ t( K8 ]5 W# _3 M
88.                         for(j=0; j<k; j++)* q2 y; c3 f7 X) Z\\" c1 Y) s
    
90.                         {
    
91. \\" I/ [$ z6 L8 B* W3 ^3 {  k) R2 o5 M
92.                                 u=i*k+j; pc[u]=0.0;
    
93. 5 J  K4 m  `. A7 y1 z; ]
94.                                 for (v=0; v<n; v++); G6 y' e$ t0 m6 ~
    
96.                                 {\\" q1 x# _7 e7 T- v- S
    
98.                                         pc[u]=pc[u]+pa[i*n+v]*pb[v*k+j];
    
99. ; ?+ ?& v( B, X& b: y  M
100.                                 }6 p/ w/ M: d* Z  s
     
102.                         }
     
103. $ T. b! ?0 m- c+ W. N; {
104.                 }
     
105. $ H2 y: L5 \! _( j% I
106.                 FunReObj(hFor);        //告诉Lu，返回一个动态对象
     
107. ' \! ~9 w0 }  t2 A$ R' y! o
108.                 a.BType=luDynData_realarray; a.VType=Matrix; a.x=0; *(luVOID *)&(a.x)=(luVOID)pRealArray3;
     
109. , g9 }1 v; m2 L2 R\\" N' S2 q) J\\" G
110.                 break;! `: k) `4 j5 F( e  ]9 N8 R
     
112.         case 25:        //重载运算符.*( R& }% U  c& b2 C
     
114.                 pRealArray1=(luRealArray *)SearchKey((char *)&(xx->x),sizeof(luVOID),luDynData_realarray);
     
115. ) S4 N+ w4 Y, E6 W% B# C6 h
116.                 pRealArray2=(luRealArray *)SearchKey((char *)&((xx+1)->x),sizeof(luVOID),luDynData_realarray);8 ]0 V0 v) z8 U5 U3 d
     
118.                 if(!pRealArray1 || !pRealArray2) break;        //对象句柄无效，不是实数数组& K6 m8 [' I* Q! L
     
120.                 if(pRealArray1->DimLen!=2 || pRealArray2->DimLen!=2) break;        //不是二维实数数组（矩阵）
     
121. 1 I  a% W6 y# ?
122.                 if(pRealArray1->Dim[0]!=pRealArray2->Dim[0] || pRealArray1->Dim[1]!=pRealArray2->Dim[1]) break;        //维数不相同
     
123. 7 Q7 n8 K! O/ h! R\\" j: ~
124.                 pRealArray3=(luRealArray *)NewSysObj(luDynData_realarray,pRealArray1->ArrayLen,2);        //创建矩阵对象
     
125. % S+ @- q/ Z, g6 t- P+ v: f, N
126.                 if(!pRealArray3) break;- A$ Z0 B' v4 R2 C- y\\" S: o
     
128.                 pRealArray3->Dim[0]=pRealArray1->Dim[0]; pRealArray3->Dim[1]=pRealArray1->Dim[1];        //设置矩阵维数大小
     
129. % N- d9 O) ]' H5 @6 n5 R+ {# d
130.                 for(i=0;i<pRealArray1->ArrayLen;i++) pRealArray3->Array[i]=pRealArray1->Array[i]*pRealArray2->Array[i];//矩阵点乘
     
131. 7 D\\" T& F6 v- x& O\\" A4 D, Z# a
132.                 FunReObj(hFor);        //告诉Lu，返回一个动态对象. {8 u+ W1 D* R0 u+ H% K- x( `
     
134.                 a.BType=luDynData_realarray; a.VType=Matrix; a.x=0; *(luVOID *)&(a.x)=(luVOID)pRealArray3;2 Q1 I& q/ d5 v: I& u
     
136.                 break;# q6 x2 Q5 @* K  f$ k) R
     
138.         case 46:        //重载函数new
     
139. 5 j5 A. \4 _( R2 e# P, w
140.                 a=ExeOperator(mm,xx,hFor,theOperator,luDynData_realarray);        //直接调用基本类型luDynData_realarray的new函数
     
141. ) v- [( |( y, m\\" I
142.                 if(a.VType==luDynData_realarray) a.VType=Matrix;        //设置扩展类型为自定义的Matrix类型) ^, \& e& h' |3 s
     
144.                 break;% j9 d, m: q5 {8 m# ?
     
146.         case 49:        //重载函数o; a' C% Q! Y8 V7 ~
     
148.                 pMessage=(luMessage)SearchKey("\0\0\0\0",sizeof(luVOID),luPubKey_User);
     
149. / Z, H* I8 R, {2 f% G5 [
150.                 if(!pMessage) break;1 Z2 D! R2 g! S# |, \: l. W
     
152.                 pRealArray1=(luRealArray *)SearchKey((char *)&(xx->x),sizeof(luVOID),luDynData_realarray);2 D: r3 N- v9 @  {0 I
     
154.                 if(!pRealArray1) break;        //对象句柄无效，不是实数数组
     
155. 8 V  D\\" _( @7 \, Q
156.                 if(pRealArray1->DimLen!=2) break;        //不是二维实数数组（矩阵）
     
157. 9 N# B- t, Z: }- q
158.                 pa=pRealArray1->Array;
     
159. 7 p; N+ O, E% T
160.                 m=pRealArray1->Dim[0]; n=pRealArray1->Dim[1]; k=0;
     
161. ! ]0 y5 I  |) @- ~
162.                 for(i=0; i<m; i++)        //输出矩阵; F\\" W1 U+ H  Q( u\\" G, l) h- Z8 Q9 i- L# ?
     
164.                 {; |4 I3 l: c3 Z! r- p* x
     
166.                         pMessage(L"\r\n"); k+=2;- g# w* u& F2 X
     
168.                         for(j=0; j<n; j++)
     
169. 5 J+ L- V5 E. Z# ]4 F
170.                         {
     
171. 9 g: y- c/ k2 ~0 x8 x\\" Y+ b
172.                                 _gcvt_s(chNum,pa[i*n+j],16);: t/ y6 Z: g1 r1 ]
     
174.                                 for(u=0;chNum[u];u++) {wchNum[u]=chNum[u]; k++;}
     
175. # k0 I) t7 e4 P: e! M8 C
176.                                 wchNum[u]='\0';
     
177. 9 k7 L6 S, \4 B/ W- ?: u! ]
178.                                 pMessage(wchNum); pMessage(L"  "); k+=2;
     
179. % D\\" i& l- _# e) U) l. d0 q
180.                         }
     
181. 2 w$ Y6 t1 V* o: Z0 ]/ E/ O* w
182.                 }/ q( b# ]( p! P* i% d& O
     
184.                 pMessage(L"\r\n"); k+=2;1 W, I& Y\\" [, G
     
186.                 a.BType=luStaData_int64; a.VType=luStaData_int64; a.x=k;        //按函数o的要求，返回输出的字符总数0 N4 L; a# _, T3 c; z! s% I
     
188.                 break;
     
189. 4 u9 @& M! q2 h! Q; ?' ]7 _
190.         default:
     
191. 7 e9 c; T0 T\\" E
192.                 break;
     
193. 8 Z5 M& v4 e2 N\\" D* |! ~0 D
194.         }
     
195. # P+ q) ]; z, h4 A) B! |
196.         return a;
     
197. 4 b5 p' A; }/ o
198. }
     
199. ; p/ j, h3 ~/ v- C2 Q8 B
200. void main(void)) b1 {: ^\\" D6 @+ c# _* ~1 r5 ~( q
     
202. {
     
203. . G' H\\" ~# }1 w
204.         void *hFor;                //表达式句柄
     
205. ) a4 l6 ^5 D% {\\" D: Y& u- O
206.         luINT nPara;                //存放表达式的自变量个数$ f) {, t2 `6 I+ Z9 B. V
     
208.         LuData *pPara;                //存放输入自变量的数组指针
     
209. # ]+ a3 Q  N( H4 z7 K
210.         luINT ErrBegin,ErrEnd;        //表达式编译出错的初始位置和结束位置
     
211. + Z\\" m6 }7 @9 M9 _
212.         int ErrCode;                //错误代码
     
213. # Y  b* d7 ^2 p+ z0 }6 }6 J
214.         void *v;
     
215. ! y1 W) F/ V3 P& H, \% b5 X) M
216.         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.]}";//字符串表达式，矩阵乘6 z! o7 z& X- ?
     
218.         //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.]}";//字符串表达式，矩阵点乘& ~$ {  a9 s$ F5 v
     
220.         LuData Val;: g) z\\" U9 n0 Z% L
     
222.         if(!InitLu()) return;        //初始化Lu; E! x0 v( C( `9 V7 y3 i9 i
     
224.         while(LockKey(Matrix,DelMatrix,OpMatrix)){Matrix++;}        //锁定一个键，用于存储矩阵扩展类型( n# J- p* M- ]% j1 I
     
226. 
     
227. # z# A( F+ h/ V) ?, Y\\" D3 @
228.         Val.BType=luStaData_int64; Val.VType=luStaData_int64; Val.x=Matrix;        //定义整数常量
     
229. 0 [# |$ a\\" [4 w\\" \; N+ d$ e. ~
230.         SetConst(L"matrix",&Val);        //设置整数常量
     
231. / m  t$ `) o3 u4 _% O
232.         InsertKey("\0\0\0\0",4,luPubKey_User,LuMessage,NULL,NULL,1,v); //使Lu运行时可输出函数信息
     
233. / M5 B* ?- Q' {( P
234.         wcout.imbue(locale("chs"));        //设置输出的locale为中文
     
235. + `; p- h0 e; y1 Y
236.   . K# X) m7 `  n* [6 g; \+ O5 g
     
238.         ErrCode=LuCom(ForStr,0,0,0,hFor,nPara,pPara,ErrBegin,ErrEnd); //编译表达式+ F3 @  H3 G5 I9 P! b! i8 O
     
240.         if(ErrCode), @6 ], B0 _/ A3 e3 x
     
242.         {5 _& g$ S! x. q- e
     
244.                 wcout<<L"表达式有错误！错误代码："<<ErrCode<<endl;
     
245. 6 @- @6 o* U: \8 Y. O1 ]9 L1 ]
246.         }
     
247. 5 _# Y, _# B) g
248.         else) U$ f) A' K$ ], g$ e4 B- L# v
     
250.         {
     
251. - q5 c, M/ B: W+ [+ F+ k* H/ v
252.                 LuCal(hFor,pPara);        //计算表达式的值5 _2 {( k, X9 u1 e9 ?' T
     
254.         }
     
255. ' W; U: i+ l) r
256.         LockKey(Matrix,NULL,OpMatrix);//解锁键Matrix，本例中，该函数可以不用6 P. t! o' G( c8 A* s% v
     
258.         FreeLu();                        //释放Lu' T! M* o- {- ~
     
260. }

#include <windows.h><font class=\\"jammer\\">/ x4 r# A) T; X% y</font><br /> #include <iostream><font class=\\"jammer\\">6 @0 N4 I1 D! a6 \- c- X</font><br /> #include <math.h><br /> <span style=\\"display:none\\">1 F& @1 J. @! j, A</span> #include "lu32.h"<font class=\\"jammer\\">; T. v( Z3 s1 M1 o+ w</font><br /> <font class=\\"jammer\\">, a  c  P) A3 d+ M: p</font><br /> #pragma comment( lib, "lu32.lib" )<font class=\\"jammer\\">7 x, a6 i; g7 q( x+ y' g5 w: K% u! X</font><br /> <br /> <span style=\\"display:none\\">; B% b6 H* @' B</span> using namespace std;<font class=\\"jammer\\">: V: c& s8 c% L( }7 C& m3 `6 r3 q</font><br /> <font class=\\"jammer\\">3 E\\" `: {, t% I</font><br /> luKEY Matrix=-1000;        //标识矩阵类型，最终的Matrix由LockKey决定<br /> <span style=\\"display:none\\">, U# p' j2 ~- Q4 X' r</span> <br /> <span style=\\"display:none\\">) W  o6 h. a, e\\" H</span> void _stdcall LuMessage(wchar_t *pch)//输出动态库信息，该函数注册到Lu，由Lu二级函数调用 <font class=\\"jammer\\">4 ?9 a7 O% v) i1 I5 [</font><br /> {<font class=\\"jammer\\">- N( G3 c- i5 m, A. B+ t</font><br />         wcout<<pch;<br /> <span style=\\"display:none\\">* K7 Y2 W1 w; F1 e; C</span> }<br /> <span style=\\"display:none\\"># L/ T4 h3 n% K8 F</span> void _stdcall DelMatrix(void *me)        //用于LockKey函数，因为是基于系统内置实数数组创建矩阵，故该函数什么也不做<font class=\\"jammer\\">4 g4 t( n8 m) D1 ]</font><br /> {<br /> <span style=\\"display:none\\">1 q' c& I/ `4 K! a. y</span> }<br /> <span style=\\"display:none\\">7 t& {# V, m+ G4 W</span> LuData _stdcall OpMatrix(luINT mm,LuData *xx,void *hFor,int theOperator)        //运算符重载函数，用于LockKey函数<br /> <span style=\\"display:none\\">& c( h\\" U  _6 u: C: q; s</span> {<br /> <span style=\\"display:none\\">\\" ?2 t* D# D  Y</span>         LuData a;<br /> <span style=\\"display:none\\">/ P! H* A6 [8 I6 h( n0 {; b4 ~</span>         luRealArray *pRealArray1,*pRealArray2,*pRealArray3;<br /> <span style=\\"display:none\\">; \  D# r; Y+ c8 _0 H3 ^: N! O</span>         luVOID i,j,k,m,n,u,v;<br /> <span style=\\"display:none\\">! k* U+ @- J9 S. \9 V, n6 D</span>         double *pa,*pb,*pc;<font class=\\"jammer\\">! i2 E; h; J$ I8 P, J</font><br />         luMessage pMessage;<font class=\\"jammer\\">3 J$ Y2 o9 d; ?  v( J$ g</font><br />         wchar_t wchNum[32];<br /> <span style=\\"display:none\\">( P( |% x9 p4 ^5 c8 Q</span>         char chNum[32];<font class=\\"jammer\\">! l# O5 Z- T2 Z\\" ]# q8 A</font><br />         a.BType=luStaData_nil; a.VType=luStaData_nil; a.x=0;<br /> <span style=\\"display:none\\">9 [$ c$ y# d  X: f4 Z</span>         switch(theOperator)<font class=\\"jammer\\">7 I6 M6 L: C/ z9 N) s</font><br />         {<font class=\\"jammer\\">  U2 h9 _6 f4 O  U4 S</font><br />         case 2:        //重载运算符*<font class=\\"jammer\\">( E8 u5 e( Y! w</font><br />                 pRealArray1=(luRealArray *)SearchKey((char *)&(xx->x),sizeof(luVOID),luDynData_realarray);<font class=\\"jammer\\">$ G$ Y! R+ c\\" d9 z; Q6 n5 t</font><br />                 pRealArray2=(luRealArray *)SearchKey((char *)&((xx+1)->x),sizeof(luVOID),luDynData_realarray);<br /> <span style=\\"display:none\\">+ o$ y7 `) W; ~& O* ~/ w3 R</span>                 if(!pRealArray1 || !pRealArray2) break;        //对象句柄无效，不是实数数组<font class=\\"jammer\\">+ G& K: |2 O% M$ F0 g</font><br />                 if(pRealArray1->DimLen!=2 || pRealArray2->DimLen!=2) break;        //不是二维实数数组（矩阵）<br /> <span style=\\"display:none\\">  Q9 E  J. N! L) ^) v* e</span>                 if(pRealArray1->Dim[1]!=pRealArray2->Dim[0]) break;        //维数不匹配<font class=\\"jammer\\">$ k( J0 i7 J3 K% U0 l  A</font><br />                 pRealArray3=(luRealArray *)NewSysObj(luDynData_realarray,pRealArray1->Dim[0]*pRealArray2->Dim[1],2);        //创建矩阵对象<font class=\\"jammer\\">! U4 t0 x# z$ g/ |# _. n- e</font><br />                 if(!pRealArray3) break;<br /> <span style=\\"display:none\\">0 H9 G# g: o+ P; u* {* q* Y</span>                 pRealArray3->Dim[0]=pRealArray1->Dim[0]; pRealArray3->Dim[1]=pRealArray2->Dim[1];        //设置矩阵维数大小<br /> <span style=\\"display:none\\">. R( L1 b$ Y% W+ g</span>                 pa=pRealArray1->Array; pb=pRealArray2->Array; pc=pRealArray3->Array;<font class=\\"jammer\\"># r/ o4 |/ w% x: s4 T9 z! l9 X</font><br />                 m=pRealArray1->Dim[0]; n=pRealArray1->Dim[1]; k=pRealArray2->Dim[1];<br /> <span style=\\"display:none\\">3 P& N8 x( A8 G7 a+ f</span>                 for(i=0; i<m; i++)        //矩阵乘<font class=\\"jammer\\">4 e- c0 C# G6 h$ l7 h</font><br />                 {<br /> <span style=\\"display:none\\">6 h8 V4 ]+ t( K8 ]5 W# _3 M</span>                         for(j=0; j<k; j++)<font class=\\"jammer\\">* q2 y; c3 f7 X) Z\\" c1 Y) s</font><br />                         {<br /> <span style=\\"display:none\\">\\" I/ [$ z6 L8 B* W3 ^3 {  k) R2 o5 M</span>                                 u=i*k+j; pc[u]=0.0;<br /> <span style=\\"display:none\\">5 J  K4 m  `. A7 y1 z; ]</span>                                 for (v=0; v<n; v++)<font class=\\"jammer\\">; G6 y' e$ t0 m6 ~</font><br />                                 {<font class=\\"jammer\\">\\" q1 x# _7 e7 T- v- S</font><br />                                         pc[u]=pc[u]+pa[i*n+v]*pb[v*k+j];<br /> <span style=\\"display:none\\">; ?+ ?& v( B, X& b: y  M</span>                                 }<font class=\\"jammer\\">6 p/ w/ M: d* Z  s</font><br />                         }<br /> <span style=\\"display:none\\">$ T. b! ?0 m- c+ W. N; {</span>                 }<br /> <span style=\\"display:none\\">$ H2 y: L5 \! _( j% I</span>                 FunReObj(hFor);        //告诉Lu，返回一个动态对象<br /> <span style=\\"display:none\\">' \! ~9 w0 }  t2 A$ R' y! o</span>                 a.BType=luDynData_realarray; a.VType=Matrix; a.x=0; *(luVOID *)&(a.x)=(luVOID)pRealArray3;<br /> <span style=\\"display:none\\">, g9 }1 v; m2 L2 R\\" N' S2 q) J\\" G</span>                 break;<font class=\\"jammer\\">! `: k) `4 j5 F( e  ]9 N8 R</font><br />         case 25:        //重载运算符.*<font class=\\"jammer\\">( R& }% U  c& b2 C</font><br />                 pRealArray1=(luRealArray *)SearchKey((char *)&(xx->x),sizeof(luVOID),luDynData_realarray);<br /> <span style=\\"display:none\\">) S4 N+ w4 Y, E6 W% B# C6 h</span>                 pRealArray2=(luRealArray *)SearchKey((char *)&((xx+1)->x),sizeof(luVOID),luDynData_realarray);<font class=\\"jammer\\">8 ]0 V0 v) z8 U5 U3 d</font><br />                 if(!pRealArray1 || !pRealArray2) break;        //对象句柄无效，不是实数数组<font class=\\"jammer\\">& K6 m8 [' I* Q! L</font><br />                 if(pRealArray1->DimLen!=2 || pRealArray2->DimLen!=2) break;        //不是二维实数数组（矩阵）<br /> <span style=\\"display:none\\">1 I  a% W6 y# ?</span>                 if(pRealArray1->Dim[0]!=pRealArray2->Dim[0] || pRealArray1->Dim[1]!=pRealArray2->Dim[1]) break;        //维数不相同<br /> <span style=\\"display:none\\">7 Q7 n8 K! O/ h! R\\" j: ~</span>                 pRealArray3=(luRealArray *)NewSysObj(luDynData_realarray,pRealArray1->ArrayLen,2);        //创建矩阵对象<br /> <span style=\\"display:none\\">% S+ @- q/ Z, g6 t- P+ v: f, N</span>                 if(!pRealArray3) break;<font class=\\"jammer\\">- A$ Z0 B' v4 R2 C- y\\" S: o</font><br />                 pRealArray3->Dim[0]=pRealArray1->Dim[0]; pRealArray3->Dim[1]=pRealArray1->Dim[1];        //设置矩阵维数大小<br /> <span style=\\"display:none\\">% N- d9 O) ]' H5 @6 n5 R+ {# d</span>                 for(i=0;i<pRealArray1->ArrayLen;i++) pRealArray3->Array[i]=pRealArray1->Array[i]*pRealArray2->Array[i];//矩阵点乘<br /> <span style=\\"display:none\\">7 D\\" T& F6 v- x& O\\" A4 D, Z# a</span>                 FunReObj(hFor);        //告诉Lu，返回一个动态对象<font class=\\"jammer\\">. {8 u+ W1 D* R0 u+ H% K- x( `</font><br />                 a.BType=luDynData_realarray; a.VType=Matrix; a.x=0; *(luVOID *)&(a.x)=(luVOID)pRealArray3;<font class=\\"jammer\\">2 Q1 I& q/ d5 v: I& u</font><br />                 break;<font class=\\"jammer\\"># q6 x2 Q5 @* K  f$ k) R</font><br />         case 46:        //重载函数new<br /> <span style=\\"display:none\\">5 j5 A. \4 _( R2 e# P, w</span>                 a=ExeOperator(mm,xx,hFor,theOperator,luDynData_realarray);        //直接调用基本类型luDynData_realarray的new函数<br /> <span style=\\"display:none\\">) v- [( |( y, m\\" I</span>                 if(a.VType==luDynData_realarray) a.VType=Matrix;        //设置扩展类型为自定义的Matrix类型<font class=\\"jammer\\">) ^, \& e& h' |3 s</font><br />                 break;<font class=\\"jammer\\">% j9 d, m: q5 {8 m# ?</font><br />         case 49:        //重载函数o<font class=\\"jammer\\">; a' C% Q! Y8 V7 ~</font><br />                 pMessage=(luMessage)SearchKey("\0\0\0\0",sizeof(luVOID),luPubKey_User);<br /> <span style=\\"display:none\\">/ Z, H* I8 R, {2 f% G5 [</span>                 if(!pMessage) break;<font class=\\"jammer\\">1 Z2 D! R2 g! S# |, \: l. W</font><br />                 pRealArray1=(luRealArray *)SearchKey((char *)&(xx->x),sizeof(luVOID),luDynData_realarray);<font class=\\"jammer\\">2 D: r3 N- v9 @  {0 I</font><br />                 if(!pRealArray1) break;        //对象句柄无效，不是实数数组<br /> <span style=\\"display:none\\">8 V  D\\" _( @7 \, Q</span>                 if(pRealArray1->DimLen!=2) break;        //不是二维实数数组（矩阵）<br /> <span style=\\"display:none\\">9 N# B- t, Z: }- q</span>                 pa=pRealArray1->Array;<br /> <span style=\\"display:none\\">7 p; N+ O, E% T</span>                 m=pRealArray1->Dim[0]; n=pRealArray1->Dim[1]; k=0;<br /> <span style=\\"display:none\\">! ]0 y5 I  |) @- ~</span>                 for(i=0; i<m; i++)        //输出矩阵<font class=\\"jammer\\">; F\\" W1 U+ H  Q( u\\" G, l) h- Z8 Q9 i- L# ?</font><br />                 {<font class=\\"jammer\\">; |4 I3 l: c3 Z! r- p* x</font><br />                         pMessage(L"\r\n"); k+=2;<font class=\\"jammer\\">- g# w* u& F2 X</font><br />                         for(j=0; j<n; j++)<br /> <span style=\\"display:none\\">5 J+ L- V5 E. Z# ]4 F</span>                         {<br /> <span style=\\"display:none\\">9 g: y- c/ k2 ~0 x8 x\\" Y+ b</span>                                 _gcvt_s(chNum,pa[i*n+j],16);<font class=\\"jammer\\">: t/ y6 Z: g1 r1 ]</font><br />                                 for(u=0;chNum[u];u++) {wchNum[u]=chNum[u]; k++;}<br /> <span style=\\"display:none\\"># k0 I) t7 e4 P: e! M8 C</span>                                 wchNum[u]='\0';<br /> <span style=\\"display:none\\">9 k7 L6 S, \4 B/ W- ?: u! ]</span>                                 pMessage(wchNum); pMessage(L"  "); k+=2;<br /> <span style=\\"display:none\\">% D\\" i& l- _# e) U) l. d0 q</span>                         }<br /> <span style=\\"display:none\\">2 w$ Y6 t1 V* o: Z0 ]/ E/ O* w</span>                 }<font class=\\"jammer\\">/ q( b# ]( p! P* i% d& O</font><br />                 pMessage(L"\r\n"); k+=2;<font class=\\"jammer\\">1 W, I& Y\\" [, G</font><br />                 a.BType=luStaData_int64; a.VType=luStaData_int64; a.x=k;        //按函数o的要求，返回输出的字符总数<font class=\\"jammer\\">0 N4 L; a# _, T3 c; z! s% I</font><br />                 break;<br /> <span style=\\"display:none\\">4 u9 @& M! q2 h! Q; ?' ]7 _</span>         default:<br /> <span style=\\"display:none\\">7 e9 c; T0 T\\" E</span>                 break;<br /> <span style=\\"display:none\\">8 Z5 M& v4 e2 N\\" D* |! ~0 D</span>         }<br /> <span style=\\"display:none\\"># P+ q) ]; z, h4 A) B! |</span>         return a;<br /> <span style=\\"display:none\\">4 b5 p' A; }/ o</span> }<br /> <span style=\\"display:none\\">; p/ j, h3 ~/ v- C2 Q8 B</span> void main(void)<font class=\\"jammer\\">) b1 {: ^\\" D6 @+ c# _* ~1 r5 ~( q</font><br /> {<br /> <span style=\\"display:none\\">. G' H\\" ~# }1 w</span>         void *hFor;                //表达式句柄<br /> <span style=\\"display:none\\">) a4 l6 ^5 D% {\\" D: Y& u- O</span>         luINT nPara;                //存放表达式的自变量个数<font class=\\"jammer\\">$ f) {, t2 `6 I+ Z9 B. V</font><br />         LuData *pPara;                //存放输入自变量的数组指针<br /> <span style=\\"display:none\\"># ]+ a3 Q  N( H4 z7 K</span>         luINT ErrBegin,ErrEnd;        //表达式编译出错的初始位置和结束位置<br /> <span style=\\"display:none\\">+ Z\\" m6 }7 @9 M9 _</span>         int ErrCode;                //错误代码<br /> <span style=\\"display:none\\"># Y  b* d7 ^2 p+ z0 }6 }6 J</span>         void *v;<br /> <span style=\\"display:none\\">! y1 W) F/ V3 P& H, \% b5 X) M</span>         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.]}";//字符串表达式，矩阵乘<font class=\\"jammer\\">6 z! o7 z& X- ?</font><br />         //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.]}";//字符串表达式，矩阵点乘<font class=\\"jammer\\">& ~$ {  a9 s$ F5 v</font><br />         LuData Val;<font class=\\"jammer\\">: g) z\\" U9 n0 Z% L</font><br />         if(!InitLu()) return;        //初始化Lu<font class=\\"jammer\\">; E! x0 v( C( `9 V7 y3 i9 i</font><br />         while(LockKey(Matrix,DelMatrix,OpMatrix)){Matrix++;}        //锁定一个键，用于存储矩阵扩展类型<font class=\\"jammer\\">( n# J- p* M- ]% j1 I</font><br /> <br /> <span style=\\"display:none\\"># z# A( F+ h/ V) ?, Y\\" D3 @</span>         Val.BType=luStaData_int64; Val.VType=luStaData_int64; Val.x=Matrix;        //定义整数常量<br /> <span style=\\"display:none\\">0 [# |$ a\\" [4 w\\" \; N+ d$ e. ~</span>         SetConst(L"matrix",&Val);        //设置整数常量<br /> <span style=\\"display:none\\">/ m  t$ `) o3 u4 _% O</span>         InsertKey("\0\0\0\0",4,luPubKey_User,LuMessage,NULL,NULL,1,v); //使Lu运行时可输出函数信息<br /> <span style=\\"display:none\\">/ M5 B* ?- Q' {( P</span>         wcout.imbue(locale("chs"));        //设置输出的locale为中文<br /> <span style=\\"display:none\\">+ `; p- h0 e; y1 Y</span>   <font class=\\"jammer\\">. K# X) m7 `  n* [6 g; \+ O5 g</font><br />         ErrCode=LuCom(ForStr,0,0,0,hFor,nPara,pPara,ErrBegin,ErrEnd); //编译表达式<font class=\\"jammer\\">+ F3 @  H3 G5 I9 P! b! i8 O</font><br />         if(ErrCode)<font class=\\"jammer\\">, @6 ], B0 _/ A3 e3 x</font><br />         {<font class=\\"jammer\\">5 _& g$ S! x. q- e</font><br />                 wcout<<L"表达式有错误！错误代码："<<ErrCode<<endl;<br /> <span style=\\"display:none\\">6 @- @6 o* U: \8 Y. O1 ]9 L1 ]</span>         }<br /> <span style=\\"display:none\\">5 _# Y, _# B) g</span>         else<font class=\\"jammer\\">) U$ f) A' K$ ], g$ e4 B- L# v</font><br />         {<br /> <span style=\\"display:none\\">- q5 c, M/ B: W+ [+ F+ k* H/ v</span>                 LuCal(hFor,pPara);        //计算表达式的值<font class=\\"jammer\\">5 _2 {( k, X9 u1 e9 ?' T</font><br />         }<br /> <span style=\\"display:none\\">' W; U: i+ l) r</span>         LockKey(Matrix,NULL,OpMatrix);//解锁键Matrix，本例中，该函数可以不用<font class=\\"jammer\\">6 P. t! o' G( c8 A* s% v</font><br />         FreeLu();                        //释放Lu<font class=\\"jammer\\">' T! M* o- {- ~</font><br /> }

习题：

* r' Z# X6 @# f" V9 h: S    （1）自定义矩阵的加、减、左除、右除、点左除等运算，自编测试字符串代码，重新编译运行程序，观察计算结果。
- @" E. O3 M5 d! h2 [( S/ p
    （2）小矩阵乘效率测试。编译运行以下Lu字符串代码：

1. main(:a,b,c,d,t,i)=3 o& f8 m: h$ k* S1 L, s+ e
   
2.     a=new[matrix,2,2,data:1.,2.,2.,1.],
   2 w6 C0 L\" i' P: u  o7 l5 {; c) D
3.     b=new[matrix,2,2,data:2.,1.,1.,2.],
     l( {* e4 J  n7 ]# E; G) K
4.     c=new[matrix,2,2,data:2/3.,-1/3.,-1/3.,2/3.],4 Q! u+ y6 r' E/ ^! E+ }8 ^
   
5.     t=clock(),' g: J, Y7 y$ y+ b7 e5 g% J
   
6.     d=a*b, i=0, while{i<1000000, d=d*c*b, i++},- F9 s3 M4 I, b. n\" ]+ x5 `, H
   
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 D6 I) V' x: k9 F- y5 W5 y, p& f
2. 5. 4.
   9 g. _( |$ s: E6 k5 ]7 i
3. time=0.875 seconds.
   5 }9 ^  W6 z+ Q% z- O' l! M
4. 请按任意键继续. . .

复制代码

Matlab 2009a 代码：

1. a=[1.,2.;2.,1.];2 e8 p3 r, X, P) C
   
2. b=[2.,1.;1.,2.];
   , Z# J# W% c/ }0 R9 F
3. c=[2/3.,-1/3.;-1/3.,2/3.];. ]! o# c$ J  S6 K
   
4. tic,# C5 A% W9 O6 n5 ~- _4 N+ V
   
5. d=a*b;
   7 s4 @5 S3 z3 k
6. for i=1:1000000
   7 }5 c$ E% l& P- }& y4 P& `/ L
7.     d=d*c*b;
   , _- ?2 C3 A! ]
8. end7 S: y# g6 d: h! P
   
9. d,
   3 p$ u% \$ j/ i  I( s
10. toc

复制代码

结果：

1. d =# u4 u% f4 s: h3 l8 N\" X
   
2.      4     5
   + q0 S\" U4 d! o9 n
3.      5     4
   ! N8 I: D) H0 e# i
4. Elapsed time is 2.903034 seconds.

复制代码

本例矩阵乘效率测试，Lu的速度超过了Matlab，主要在于Lu有更高的动态对象管理效率。
4 j, q( A) k0 ~9 c3 d' \