数学建模社区-数学中国»论坛 › 【编程区】语言讨论 › Forcal程序设计 › 在Lu中创建自定义数据类型，小矩阵乘效率测试

查看: 8860|回复: 0

在Lu中创建自定义数据类型，小矩阵乘效率测试

[复制链接]

字体大小: 正常放大

forcal

45 主题	3 听众	282 积分

升级 91%

TA的每日心情

	难过 2012-8-27 18:22

签到天数: 1 天

[LV.1]初来乍到

电梯直达

1^#

发表于 2011-10-24 18:54 |只看该作者 |倒序浏览

|招呼Ta 关注Ta

本例中，我们将自定义矩阵（matrix）类型，基本类型和扩展类型均为matrix（标识矩阵）。

基本要点：

（1）编写生成矩阵（matrix）的函数NewMatrix和销毁矩阵的函数DelMatrix。

（2）为自定义类型matrix编写运算符重载函数OpMatrix。

（3）用函数LockKey将重载函数OpMatrix注册到Lu，锁定的键的类型即为matrix，要注册为常量，以便于使用。

（4）为自定义类型matrix编写其他操作函数（本例未提供）。

（5）用函数LockKey解锁键matrix（本例中，程序退出时会自动解锁，故可以不用）。

#include <windows.h>
, d; ?) @' J4 o\\" _' ]% V/ x( U# G
#include <iostream>
) @& `- _0 X% C1 a* U* o0 L8 J4 o
#include <math.h>
; O: d/ u# p5 `8 E\\" n2 U* l
#include "lu32.h"
I9 T0 o6 u+ K1 L* Y( r
#pragma comment( lib, "lu32.lib" )6 R& Z3 o: H% P/ d' L2 G
using namespace std;1 `( ]! U/ m0 n4 M3 C, S) h
//自定义矩阵
$ b( f+ g- I& j5 |$ Q8 p6 I1 L
class myMatrix
; @0 ~1 M/ B; } ?- i4 d w( ~
{
9 E! C& q# H! N
public:( v1 |0 i; A+ \! z& z2 E
double *Array; //数据缓冲区, L* r2 R$ R1 Q! l, T! @
luVOID ArrayLen; //数据缓冲区长度' n0 G% D% I5 h( Y% v
luVOID Dim[2]; //矩阵维数
4 j+ E! o) [ O2 W8 W2 W
myMatrix(){Array=NULL; ArrayLen=0; Dim[0]=0; Dim[1]=0;}+ W8 U8 [0 Z+ r O; g- _
~myMatrix()
0 p\\" f* G% b' [8 O/ T: U* f7 O7 \, c
{0 o! x. z& v2 i
if(Array) delete[] Array;! c6 j# P* E1 P+ O2 b6 E: A5 C
}4 W4 G& T\\" S$ n: @8 F
};
# ]+ _& A+ C' G7 J& T
luKEY Matrix=-1000; //标识矩阵类型，最终的Matrix由LockKey决定- Q3 _2 |5 d7 y2 c; }0 ~4 d
void _stdcall LuMessage(wchar_t *pch)//输出动态库信息，该函数注册到Lu，由Lu二级函数调用 ; }# M) ^- e+ U ~$ s1 n, K\\" a: q, q
{
# ?/ f! \6 P: B+ E6 r
wcout<<pch;( O: N/ ~! {7 T, H
}
* H5 ^5 P$ M( O; k# _ L
void _stdcall DelMatrix(void *me) //用于LockKey函数及InsertKey函数，使Lu能自动销毁myMatrix对象
& E, T7 P\\" X4 B) W( C
{
7 ^7 u. @$ j& b\\" x
delete (myMatrix *)me;
% i\\" P\\" m9 [( u; ~* v4 {% ^1 {3 y
}
& k\\" I& [! Q' E\\" a: h* ]' p
myMatrix * _stdcall NewMatrix(luVOID m,luVOID n) //生成一个myMatrix对象4 Z) i6 M1 |6 c. j- i
{
3 c9 e0 v* ^* d6 A ^
myMatrix *pMatrix;7 K* D: @. m2 r3 U+ w) c8 S
luVOID k;
3 p' h; O- ~1 r4 u: h' s/ W
double *pa;6 C4 p$ z8 {6 Y3 @* J0 Z
char keyname[sizeof(luVOID)];- M6 v8 f7 n0 N5 D
void *NowKey;& t2 k: \+ y. l, K7 {3 W0 P2 j
k=m*n;
# C& W+ A% Z: q2 X; a7 a
pMatrix=(myMatrix *)GetBufObj(Matrix,keyname);//先尝试从缓冲区中获取一个矩阵对象
( ?4 c0 H1 c' Q, d
if(pMatrix)9 o& b ?1 D\\" ?0 @6 a7 P
{
a' Q! C( |# B2 Q
if(pMatrix->ArrayLen!=k) //重置矩阵的大小0 f% W2 i: G\\" H, D* j( H$ n
{
; w3 a* u( c9 E
pa=new double[k];/ k B% t7 p6 k' n4 C
if(!pa)
; O1 G, T+ `$ g, H
{ h& p+ P% H) t% _# d' r1 P
DeleteKey(keyname,sizeof(luVOID),Matrix,DelMatrix,1); //将矩阵对象放回缓冲区
, D, n w# U, q
return NULL;3 ~( O& \( h1 K, r1 o
}
6 N6 N* U5 I P* K- i
delete[] pMatrix->Array;
2 }% b: Z: V. _7 @
pMatrix->Array=pa;
/ D, @$ b) \# ~& s
}
7 k0 J) |* B: @# I5 s
}* e0 l8 ]3 O8 K |2 r, X/ \
else4 H' p. q' u8 J/ Q3 y% w* b) k# b\\" X
{2 f8 c( S& ~. n( K+ T0 u. T4 o
pMatrix=new myMatrix; //创建矩阵对象
( Y$ }: _9 e% O, i
if(!pMatrix) return NULL;# T8 g, ?' @! x& H
pMatrix->Array=new double[k];
- w* t2 z0 T\\" ]5 |
if(!pMatrix->Array)9 U3 ?0 m8 u* x8 Z; S0 C# a
{7 _5 V) j/ I- J, \0 G- ]
delete pMatrix;
\\" m0 r3 y& F: |7 Z. K
return NULL;8 A( O+ t# l t- K, g
}, D) ^- f6 W\\" ?: R
if(InsertKey((char *)&pMatrix,-1,Matrix,pMatrix,DelMatrix,NULL,0,NowKey)) //将矩阵对象注册到Lu
# I+ h\\" E9 G- ~) z# }7 a4 n
{9 Q2 ~$ L5 |4 k1 ]3 e0 _3 ?( [, U& x
delete pMatrix;$ G. R* l, D5 F; L2 H% ~% Y
return NULL;! |$ {0 C\\" f& \* Z. c) E/ T1 |6 g
}% M& t: Y4 Z( y. |% \: @\\" O0 i
}
9 a6 {5 ~7 }9 Q* I: t7 D( s$ @\\" J
pMatrix->ArrayLen=k; pMatrix->Dim[0]=m; pMatrix->Dim[1]=n;
4 M a% t5 n& ?9 J; L. K
return pMatrix;
( d0 r7 a0 v% J5 S U
}
C\\" h\\" m% F- {
LuData _stdcall OpMatrix(luINT mm,LuData *xx,void *hFor,int theOperator) //运算符重载函数，用于LockKey函数% I0 K8 Y i; r l% r. V& k4 i, v
{. |! ~ H; ?4 |- A% L: U
LuData a;' M$ s+ f, e- V
myMatrix *pMatrix1,*pMatrix2,*pMatrix3;: b4 W) e6 e! ~! r9 N4 A: P1 }
luVOID i,j,k,m,n,u,v;
( j$ U5 O$ K7 I' {# ]
double *pa,*pb,*pc;* k; ^; n* K: ]3 _
luMessage pMessage;
! c C) o/ A; X8 r' S% o
wchar_t wchNum[32];0 l) Q5 _6 U. F2 A) G$ @
char chNum[32];
' M$ R! g' L8 U$ q) C. v! M
a.BType=luStaData_nil; a.VType=luStaData_nil; a.x=0;0 ~' s Y! ?. T+ W7 Y5 y3 J
switch(theOperator)
0 w' b8 h8 \6 d- I# C P' l
{
3 J0 o5 y! o V' S( M+ A
case 2: //重载运算符*& X0 E/ H; ?9 Q( |- {* p; G4 h% b
pMatrix1=(myMatrix *)SearchKey((char *)&(xx->x),sizeof(luVOID),Matrix);# K: e( M- `6 i1 `. h/ M
pMatrix2=(myMatrix *)SearchKey((char *)&((xx+1)->x),sizeof(luVOID),Matrix);
& l! d\\" `# G0 A5 T8 `# |, c& N
if(!pMatrix1 || !pMatrix2) break; //对象句柄无效，不是矩阵
2 @& s+ R6 s7 e; [; v; | O+ x
if(pMatrix1->Dim[1]!=pMatrix2->Dim[0]) break; //维数不匹配
3 U+ Y' h7 h/ X# p6 I/ J\\" D' y
pMatrix3=NewMatrix(pMatrix1->Dim[0],pMatrix2->Dim[1]); //生成新矩阵. D' ]/ ]9 D( I* k
if(!pMatrix3) break;
( u* H( v+ K/ Y7 `( U8 x
pa=pMatrix1->Array; pb=pMatrix2->Array; pc=pMatrix3->Array;
6 B- J$ Q! q: W. \! I/ q* t
m=pMatrix1->Dim[0]; n=pMatrix1->Dim[1]; k=pMatrix2->Dim[1];* K/ H$ q1 I! j0 o+ H' a# Z
for(i=0; i<m; i++) //矩阵乘 i* G3 H( D/ y0 Q& q3 ?\\" G
{
, p! {/ \3 z# q) J; g
for(j=0; j<k; j++)
# x\\" X# Z+ L/ G+ \: ?
{
0 P1 H\\" C; n/ O) v+ D: m! X8 k
u=i*k+j; pc[u]=0.0;
& s% z& }/ @$ a. A7 w* x
for (v=0; v<n; v++)
7 }& k4 F6 x* L. y/ {: G
{, z4 V' T- t5 t h. H: e
pc[u]=pc[u]+pa[i*n+v]*pb[v*k+j];
1 I) Y% ~2 @7 i0 k/ Q+ }, n
}5 I2 [$ i% c! x8 Q8 _3 I/ x* O6 e
}
5 X2 W5 O4 E! Y0 I
}6 S) @\\" t1 T0 m7 \' \
FunReObj(hFor); //告诉Lu，返回一个动态对象
. @: Z% i. A% T% F! ]- ~+ u
a.BType=Matrix; a.VType=Matrix; a.x=0; *(luVOID *)&(a.x)=(luVOID)pMatrix3;: q/ p- m% h- s. N/ I
break;
3 I\\" ]. h& s p% }! |
case 25: //重载运算符.*
# y* t\\" g# ?( D; | V
pMatrix1=(myMatrix *)SearchKey((char *)&(xx->x),sizeof(luVOID),Matrix);+ l, t\\" `7 Z0 Y3 H
pMatrix2=(myMatrix *)SearchKey((char *)&((xx+1)->x),sizeof(luVOID),Matrix);
: P& F2 v3 N+ z8 ]) K0 `1 F
if(!pMatrix1 || !pMatrix2) break; //对象句柄无效，不是矩阵$ `1 L% A( L8 I. ^7 B/ [# J
if(pMatrix1->Dim[0]!=pMatrix2->Dim[0] || pMatrix1->Dim[1]!=pMatrix2->Dim[1]) break; //维数不相同: | y+ K) w4 s
pMatrix3=NewMatrix(pMatrix1->Dim[0],pMatrix1->Dim[1]); //生成新矩阵: m$ v+ `4 t/ K* L
if(!pMatrix3) break;; }+ }& s. u& H- P; G
for(i=0;i<pMatrix1->ArrayLen;i++) pMatrix3->Array[i]=pMatrix1->Array[i]*pMatrix2->Array[i]; //矩阵点乘
% J0 F6 l8 H! S3 u5 a9 J7 P
FunReObj(hFor); //告诉Lu，返回一个动态对象
% L7 Z7 @8 a% I# ? s' C& n$ v2 K
a.BType=Matrix; a.VType=Matrix; a.x=0; *(luVOID *)&(a.x)=(luVOID)pMatrix3;- U& B0 p4 Q! B' I
break;. N; N! m8 U5 t- h* l( W' o8 S
case 46: //重载函数new+ k6 e' c' F6 ~3 v8 R
if(mm<2) break;/ @4 d: O# L/ Q! p/ B9 s. w
if((xx+1)->x<1 || (xx+2)->x<1 || (xx+1)->BType!=luStaData_int64 || (xx+2)->BType!=luStaData_int64) break;9 a$ K9 R1 i7 M9 v5 m
pMatrix3=NewMatrix((luVOID)(xx+1)->x,(luVOID)(xx+2)->x);//生成新矩阵
3 Z5 k% O# q! o2 {/ d
if(!pMatrix3) break;
b% w5 L. \3 |
for(j=0,i=3;i<=mm;i++,j++) //赋初值
\\" g5 ?$ t. f3 z3 e3 o/ l( B
{
+ _* b. n. W# y4 Z- s
if(j>=pMatrix3->ArrayLen) break;
) }\\" ~/ H9 L& v. w4 ~& e
if((xx+i)->BType!=luStaData_double) break; //只接受实数参数
6 d( x! J- k% \2 ^' x
pMatrix3->Array[j]=*(double *)&((xx+i)->x);
1 z9 G& k: u4 l! I }5 P. l
}
v! ^. r/ c& [ j+ U
FunReObj(hFor); //告诉Lu，返回一个动态对象
2 e% {2 \\\" N7 Q7 H7 W5 K, o& |! m; L
a.BType=Matrix; a.VType=Matrix; a.x=0; *(luVOID *)&(a.x)=(luVOID)pMatrix3;
; V. B7 O1 `& C5 x# w
break;, I! B- p: O\\" s q1 I7 ~
case 49: //重载函数o5 |6 J ~. f4 D5 l/ w' _9 a
pMessage=(luMessage)SearchKey("\0\0\0\0",sizeof(luVOID),luPubKey_User);
2 u+ K) p9 G5 Q( R
if(!pMessage) break;5 O% K/ O; J+ K# b; K. I$ G
pMatrix1=(myMatrix *)SearchKey((char *)&(xx->x),sizeof(luVOID),Matrix);
7 | D$ } M! @9 y0 o3 T\\" W5 X) P
if(!pMatrix1) break; //对象句柄无效，不是矩阵$ R% F i\\" K' f: ^9 t3 x/ Z
pa=pMatrix1->Array;; N$ t& M4 d: s* E5 u& Q& z4 j( ?
m=pMatrix1->Dim[0]; n=pMatrix1->Dim[1]; k=0;
1 p. s\\" B9 C3 W. [2 ^
for(i=0; i<m; i++) //输出矩阵
7 {\\" Y' Y$ L9 X/ ~
{
) X1 L& v% c }
pMessage(L"\r\n"); k+=2;: e8 z F. O/ {4 h! y3 @% F# k* K
for(j=0; j<n; j++)
& p* s: w( E% t- E7 R$ \9 `1 |
{4 p3 V8 ]3 j% f* _' L# `: P4 i% N
_gcvt_s(chNum,pa[i*n+j],16);- t5 T+ l4 `7 Y: H, L! a0 B- z, T4 j
for(u=0;chNum[u];u++) {wchNum[u]=chNum[u]; k++;}
: t; ]5 Q: `9 [/ w, Q
wchNum[u]='\0';
% C& c! ]6 e3 {! q6 J+ [$ Y
pMessage(wchNum); pMessage(L" "); k+=2;! C( h: a F3 q: F: l
}
$ {( [8 N0 w6 a( h
}! u) e' U7 `( a) V: a
pMessage(L"\r\n"); k+=2;, g9 }2 {1 j, A8 @
a.BType=luStaData_int64; a.VType=luStaData_int64; a.x=k; //按函数o的要求，返回输出的字符总数
: j% `, h- {; L% T( d' r
break;
* C\\" P; v, S' }\\" ` ^6 F( R4 U
default:
0 M$ p: `2 B& m$ w
break;
* \9 w- X9 Q% M% p& N' W% B m- c
}) v8 N! V3 i; N7 z) H
return a;$ S& [- J( U0 e5 b* r
}% q5 k9 o2 h% B+ m# l* N8 }# V
void main(void)
1 y* P8 U0 |0 ^
{, U0 A& f9 ]; W+ L/ s5 g5 h
void *hFor; //表达式句柄4 B\\" j. P& L. M\\" b$ Z, y; X
luINT nPara; //存放表达式的自变量个数\\" }; K; d% }+ K) ^* u1 D' J
LuData *pPara; //存放输入自变量的数组指针
9 v$ H. ^4 Q; Q! b6 D* a6 f! @
luINT ErrBegin,ErrEnd; //表达式编译出错的初始位置和结束位置7 S4 A1 |* E1 j- ~
int ErrCode; //错误代码4 O) O; r8 s+ [, U8 H9 a' u+ X
void *v;
7 c6 \5 H8 S8 a- z; x, g4 g
wchar_t ForStr[]=L"o{new[matrix,2,3: 0.,1.,2.;3.,4.,5.]*new[matrix,3,2: 1.,2.;3.,4.;5.,6.]}";//字符串表达式，矩阵乘
4 H. o! }; M5 l: w
//wchar_t ForStr[]=L"o{new[matrix,2,3: 0.,1.,2.;3.,4.,5.].*new[matrix,2,3: 1.,2.,3.;4.,5.,6.]}";//字符串表达式，矩阵点乘4 K' j* @, b) i1 Z) i+ a
LuData Val;
r, R/ O4 u8 {: Q
if(!InitLu()) return; //初始化Lu. h7 ^) U, Z- z% Y/ _* R. `7 X
while(LockKey(Matrix,DelMatrix,OpMatrix)){Matrix--;} //锁定一个键，用于存储矩阵扩展类型
' L- \7 G) j) f& A\\" S% G# [
( J8 R ~7 b$ y3 L$ g, O/ j! P
Val.BType=luStaData_int64; Val.VType=luStaData_int64; Val.x=Matrix; //定义整数常量( i2 J2 i! q4 R# I& y* O* t3 B% t0 y
SetConst(L"matrix",&Val); //设置整数常量7 i! g9 m* f9 l5 g1 p5 T9 G& z
InsertKey("\0\0\0\0",4,luPubKey_User,LuMessage,NULL,NULL,1,v); //使Lu运行时可输出函数信息
& {& N3 Z& }7 G& z0 k t! M- ^6 a
wcout.imbue(locale("chs")); //设置输出的locale为中文
. T( X+ H& f- v; O* T2 U/ p. d8 b
! U) m. M8 n, P3 X! e
ErrCode=LuCom(ForStr,0,0,0,hFor,nPara,pPara,ErrBegin,ErrEnd); //编译表达式
: G, Q: H* u& t2 g% \/ V6 ]) P7 O
if(ErrCode)1 ]- U0 ], o' L1 [+ N
{
$ q |4 ^2 m, x# @0 c2 U+ u u
wcout<<L"表达式有错误！错误代码："<<ErrCode<<endl;5 k) K, e1 D; d1 X5 f2 _
}
9 h& d3 F$ p9 k- Y& t
else. w* u3 g! q* V8 x\\" }' {! z
{
& r U1 T* e4 I/ Z, u; e( s8 _
LuCal(hFor,pPara); //计算表达式的值
2 p: v! O$ Q3 T\\" u# z7 v0 u2 O
}
1 D- ~5 b* l% Q* ?
LockKey(Matrix,NULL,OpMatrix);//解锁键Matrix，本例中，该函数可以不用
0 M3 Z0 P A3 O& o8 Y3 I7 z
FreeLu(); //释放Lu. T8 i1 r6 g\\" b0 a# o! H6 T j
}

#include <windows.h> 
, d; ?) @' J4 o\\" _' ]% V/ x( U# G
#include <iostream> 
) @& `- _0 X% C1 a* U* o0 L8 J4 o
#include <math.h> 
; O: d/ u# p5 `8 E\\" n2 U* l
#include "lu32.h" 
  I9 T0 o6 u+ K1 L* Y( r
#pragma comment( lib, "lu32.lib" )6 R& Z3 o: H% P/ d' L2 G

using namespace std;1 `( ]! U/ m0 n4 M3 C, S) h

//自定义矩阵 
$ b( f+ g- I& j5 |$ Q8 p6 I1 L
class myMatrix 
; @0 ~1 M/ B; }  ?- i4 d  w( ~
{ 
9 E! C& q# H! N
public:( v1 |0 i; A+ \! z& z2 E

double *Array;        //数据缓冲区, L* r2 R$ R1 Q! l, T! @

luVOID ArrayLen;        //数据缓冲区长度' n0 G% D% I5 h( Y% v

luVOID Dim[2];        //矩阵维数 
4 j+ E! o) [  O2 W8 W2 W
        myMatrix(){Array=NULL; ArrayLen=0; Dim[0]=0; Dim[1]=0;}+ W8 U8 [0 Z+ r  O; g- _

~myMatrix() 
0 p\\" f* G% b' [8 O/ T: U* f7 O7 \, c
        {0 o! x. z& v2 i

if(Array) delete[] Array;! c6 j# P* E1 P+ O2 b6 E: A5 C

}4 W4 G& T\\" S$ n: @8 F

}; 
# ]+ _& A+ C' G7 J& T
luKEY Matrix=-1000;        //标识矩阵类型，最终的Matrix由LockKey决定- Q3 _2 |5 d7 y2 c; }0 ~4 d

void _stdcall LuMessage(wchar_t *pch)//输出动态库信息，该函数注册到Lu，由Lu二级函数调用 ; }# M) ^- e+ U  ~$ s1 n, K\\" a: q, q

{ 
# ?/ f! \6 P: B+ E6 r
        wcout<<pch;( O: N/ ~! {7 T, H

} 
* H5 ^5 P$ M( O; k# _  L
void _stdcall DelMatrix(void *me)        //用于LockKey函数及InsertKey函数，使Lu能自动销毁myMatrix对象 
& E, T7 P\\" X4 B) W( C
{ 
7 ^7 u. @$ j& b\\" x
        delete (myMatrix *)me; 
% i\\" P\\" m9 [( u; ~* v4 {% ^1 {3 y
} 
& k\\" I& [! Q' E\\" a: h* ]' p
myMatrix * _stdcall NewMatrix(luVOID m,luVOID n)        //生成一个myMatrix对象4 Z) i6 M1 |6 c. j- i

{ 
3 c9 e0 v* ^* d6 A  ^
        myMatrix *pMatrix;7 K* D: @. m2 r3 U+ w) c8 S

luVOID k; 
3 p' h; O- ~1 r4 u: h' s/ W
        double *pa;6 C4 p$ z8 {6 Y3 @* J0 Z

char keyname[sizeof(luVOID)];- M6 v8 f7 n0 N5 D

void *NowKey;& t2 k: \+ y. l, K7 {3 W0 P2 j

k=m*n; 
# C& W+ A% Z: q2 X; a7 a
        pMatrix=(myMatrix *)GetBufObj(Matrix,keyname);//先尝试从缓冲区中获取一个矩阵对象 
( ?4 c0 H1 c' Q, d
        if(pMatrix)9 o& b  ?1 D\\" ?0 @6 a7 P

{ 
  a' Q! C( |# B2 Q
                if(pMatrix->ArrayLen!=k)        //重置矩阵的大小0 f% W2 i: G\\" H, D* j( H$ n

{ 
; w3 a* u( c9 E
                        pa=new double[k];/ k  B% t7 p6 k' n4 C

if(!pa) 
; O1 G, T+ `$ g, H
                        {  h& p+ P% H) t% _# d' r1 P

DeleteKey(keyname,sizeof(luVOID),Matrix,DelMatrix,1);        //将矩阵对象放回缓冲区 
, D, n  w# U, q
                                return NULL;3 ~( O& \( h1 K, r1 o

} 
6 N6 N* U5 I  P* K- i
                        delete[] pMatrix->Array; 
2 }% b: Z: V. _7 @
                        pMatrix->Array=pa; 
/ D, @$ b) \# ~& s
                } 
7 k0 J) |* B: @# I5 s
        }* e0 l8 ]3 O8 K  |2 r, X/ \

else4 H' p. q' u8 J/ Q3 y% w* b) k# b\\" X

{2 f8 c( S& ~. n( K+ T0 u. T4 o

pMatrix=new myMatrix;        //创建矩阵对象 
( Y$ }: _9 e% O, i
                if(!pMatrix) return NULL;# T8 g, ?' @! x& H

pMatrix->Array=new double[k]; 
- w* t2 z0 T\\" ]5 |
                if(!pMatrix->Array)9 U3 ?0 m8 u* x8 Z; S0 C# a

{7 _5 V) j/ I- J, \0 G- ]

delete pMatrix; 
\\" m0 r3 y& F: |7 Z. K
                        return NULL;8 A( O+ t# l  t- K, g

}, D) ^- f6 W\\" ?: R

if(InsertKey((char *)&pMatrix,-1,Matrix,pMatrix,DelMatrix,NULL,0,NowKey))        //将矩阵对象注册到Lu 
# I+ h\\" E9 G- ~) z# }7 a4 n
                {9 Q2 ~$ L5 |4 k1 ]3 e0 _3 ?( [, U& x

delete pMatrix;$ G. R* l, D5 F; L2 H% ~% Y

return NULL;! |$ {0 C\\" f& \* Z. c) E/ T1 |6 g

}% M& t: Y4 Z( y. |% \: @\\" O0 i

} 
9 a6 {5 ~7 }9 Q* I: t7 D( s$ @\\" J
        pMatrix->ArrayLen=k; pMatrix->Dim[0]=m; pMatrix->Dim[1]=n; 
4 M  a% t5 n& ?9 J; L. K
        return pMatrix; 
( d0 r7 a0 v% J5 S  U
} 
  C\\" h\\" m% F- {
LuData _stdcall OpMatrix(luINT mm,LuData *xx,void *hFor,int theOperator)        //运算符重载函数，用于LockKey函数% I0 K8 Y  i; r  l% r. V& k4 i, v

{. |! ~  H; ?4 |- A% L: U

LuData a;' M$ s+ f, e- V

myMatrix *pMatrix1,*pMatrix2,*pMatrix3;: b4 W) e6 e! ~! r9 N4 A: P1 }

luVOID i,j,k,m,n,u,v; 
( j$ U5 O$ K7 I' {# ]
        double *pa,*pb,*pc;* k; ^; n* K: ]3 _

luMessage pMessage; 
! c  C) o/ A; X8 r' S% o
        wchar_t wchNum[32];0 l) Q5 _6 U. F2 A) G$ @

char chNum[32]; 
' M$ R! g' L8 U$ q) C. v! M
        a.BType=luStaData_nil; a.VType=luStaData_nil; a.x=0;0 ~' s  Y! ?. T+ W7 Y5 y3 J

switch(theOperator) 
0 w' b8 h8 \6 d- I# C  P' l
        { 
3 J0 o5 y! o  V' S( M+ A
        case 2:        //重载运算符*& X0 E/ H; ?9 Q( |- {* p; G4 h% b

pMatrix1=(myMatrix *)SearchKey((char *)&(xx->x),sizeof(luVOID),Matrix);# K: e( M- `6 i1 `. h/ M

pMatrix2=(myMatrix *)SearchKey((char *)&((xx+1)->x),sizeof(luVOID),Matrix); 
& l! d\\" `# G0 A5 T8 `# |, c& N
                if(!pMatrix1 || !pMatrix2) break;        //对象句柄无效，不是矩阵 
2 @& s+ R6 s7 e; [; v; |  O+ x
                if(pMatrix1->Dim[1]!=pMatrix2->Dim[0]) break;        //维数不匹配 
3 U+ Y' h7 h/ X# p6 I/ J\\" D' y
                pMatrix3=NewMatrix(pMatrix1->Dim[0],pMatrix2->Dim[1]);        //生成新矩阵. D' ]/ ]9 D( I* k

if(!pMatrix3) break; 
( u* H( v+ K/ Y7 `( U8 x
                pa=pMatrix1->Array; pb=pMatrix2->Array; pc=pMatrix3->Array; 
6 B- J$ Q! q: W. \! I/ q* t
                m=pMatrix1->Dim[0]; n=pMatrix1->Dim[1]; k=pMatrix2->Dim[1];* K/ H$ q1 I! j0 o+ H' a# Z

for(i=0; i<m; i++)        //矩阵乘  i* G3 H( D/ y0 Q& q3 ?\\" G

{ 
, p! {/ \3 z# q) J; g
                        for(j=0; j<k; j++) 
# x\\" X# Z+ L/ G+ \: ?
                        { 
0 P1 H\\" C; n/ O) v+ D: m! X8 k
                                u=i*k+j; pc[u]=0.0; 
& s% z& }/ @$ a. A7 w* x
                                for (v=0; v<n; v++) 
7 }& k4 F6 x* L. y/ {: G
                                {, z4 V' T- t5 t  h. H: e

pc[u]=pc[u]+pa[i*n+v]*pb[v*k+j]; 
1 I) Y% ~2 @7 i0 k/ Q+ }, n
                                }5 I2 [$ i% c! x8 Q8 _3 I/ x* O6 e

} 
5 X2 W5 O4 E! Y0 I
                }6 S) @\\" t1 T0 m7 \' \

FunReObj(hFor);        //告诉Lu，返回一个动态对象 
. @: Z% i. A% T% F! ]- ~+ u
                a.BType=Matrix; a.VType=Matrix; a.x=0; *(luVOID *)&(a.x)=(luVOID)pMatrix3;: q/ p- m% h- s. N/ I

break; 
3 I\\" ]. h& s  p% }! |
        case 25:        //重载运算符.* 
# y* t\\" g# ?( D; |  V
                pMatrix1=(myMatrix *)SearchKey((char *)&(xx->x),sizeof(luVOID),Matrix);+ l, t\\" `7 Z0 Y3 H

pMatrix2=(myMatrix *)SearchKey((char *)&((xx+1)->x),sizeof(luVOID),Matrix); 
: P& F2 v3 N+ z8 ]) K0 `1 F
                if(!pMatrix1 || !pMatrix2) break;        //对象句柄无效，不是矩阵$ `1 L% A( L8 I. ^7 B/ [# J

if(pMatrix1->Dim[0]!=pMatrix2->Dim[0] || pMatrix1->Dim[1]!=pMatrix2->Dim[1]) break;        //维数不相同: |  y+ K) w4 s

pMatrix3=NewMatrix(pMatrix1->Dim[0],pMatrix1->Dim[1]);        //生成新矩阵: m$ v+ `4 t/ K* L

if(!pMatrix3) break;; }+ }& s. u& H- P; G

for(i=0;i<pMatrix1->ArrayLen;i++) pMatrix3->Array[i]=pMatrix1->Array[i]*pMatrix2->Array[i];        //矩阵点乘 
% J0 F6 l8 H! S3 u5 a9 J7 P
                FunReObj(hFor);        //告诉Lu，返回一个动态对象 
% L7 Z7 @8 a% I# ?  s' C& n$ v2 K
                a.BType=Matrix; a.VType=Matrix; a.x=0; *(luVOID *)&(a.x)=(luVOID)pMatrix3;- U& B0 p4 Q! B' I

break;. N; N! m8 U5 t- h* l( W' o8 S

case 46:        //重载函数new+ k6 e' c' F6 ~3 v8 R

if(mm<2) break;/ @4 d: O# L/ Q! p/ B9 s. w

if((xx+1)->x<1 || (xx+2)->x<1 || (xx+1)->BType!=luStaData_int64 || (xx+2)->BType!=luStaData_int64) break;9 a$ K9 R1 i7 M9 v5 m

pMatrix3=NewMatrix((luVOID)(xx+1)->x,(luVOID)(xx+2)->x);//生成新矩阵 
3 Z5 k% O# q! o2 {/ d
                if(!pMatrix3) break; 
  b% w5 L. \3 |
                for(j=0,i=3;i<=mm;i++,j++)        //赋初值 
\\" g5 ?$ t. f3 z3 e3 o/ l( B
                { 
+ _* b. n. W# y4 Z- s
                        if(j>=pMatrix3->ArrayLen) break; 
) }\\" ~/ H9 L& v. w4 ~& e
                        if((xx+i)->BType!=luStaData_double) break;        //只接受实数参数 
6 d( x! J- k% \2 ^' x
                        pMatrix3->Array[j]=*(double *)&((xx+i)->x); 
1 z9 G& k: u4 l! I  }5 P. l
                } 
  v! ^. r/ c& [  j+ U
                FunReObj(hFor);        //告诉Lu，返回一个动态对象 
2 e% {2 \\\" N7 Q7 H7 W5 K, o& |! m; L
                a.BType=Matrix; a.VType=Matrix; a.x=0; *(luVOID *)&(a.x)=(luVOID)pMatrix3; 
; V. B7 O1 `& C5 x# w
                break;, I! B- p: O\\" s  q1 I7 ~

case 49:        //重载函数o5 |6 J  ~. f4 D5 l/ w' _9 a

pMessage=(luMessage)SearchKey("\0\0\0\0",sizeof(luVOID),luPubKey_User); 
2 u+ K) p9 G5 Q( R
                if(!pMessage) break;5 O% K/ O; J+ K# b; K. I$ G

pMatrix1=(myMatrix *)SearchKey((char *)&(xx->x),sizeof(luVOID),Matrix); 
7 |  D$ }  M! @9 y0 o3 T\\" W5 X) P
                if(!pMatrix1) break;        //对象句柄无效，不是矩阵$ R% F  i\\" K' f: ^9 t3 x/ Z

pa=pMatrix1->Array;; N$ t& M4 d: s* E5 u& Q& z4 j( ?

m=pMatrix1->Dim[0]; n=pMatrix1->Dim[1]; k=0; 
1 p. s\\" B9 C3 W. [2 ^
                for(i=0; i<m; i++)        //输出矩阵 
7 {\\" Y' Y$ L9 X/ ~
                { 
) X1 L& v% c  }
                        pMessage(L"\r\n"); k+=2;: e8 z  F. O/ {4 h! y3 @% F# k* K

for(j=0; j<n; j++) 
& p* s: w( E% t- E7 R$ \9 `1 |
                        {4 p3 V8 ]3 j% f* _' L# `: P4 i% N

_gcvt_s(chNum,pa[i*n+j],16);- t5 T+ l4 `7 Y: H, L! a0 B- z, T4 j

for(u=0;chNum[u];u++) {wchNum[u]=chNum[u]; k++;} 
: t; ]5 Q: `9 [/ w, Q
                                wchNum[u]='\0'; 
% C& c! ]6 e3 {! q6 J+ [$ Y
                                pMessage(wchNum); pMessage(L"  "); k+=2;! C( h: a  F3 q: F: l

} 
$ {( [8 N0 w6 a( h
                }! u) e' U7 `( a) V: a

pMessage(L"\r\n"); k+=2;, g9 }2 {1 j, A8 @

a.BType=luStaData_int64; a.VType=luStaData_int64; a.x=k;        //按函数o的要求，返回输出的字符总数 
: j% `, h- {; L% T( d' r
                break; 
* C\\" P; v, S' }\\" `  ^6 F( R4 U
        default: 
0 M$ p: `2 B& m$ w
                break; 
* \9 w- X9 Q% M% p& N' W% B  m- c
        }) v8 N! V3 i; N7 z) H

return a;$ S& [- J( U0 e5 b* r

}% q5 k9 o2 h% B+ m# l* N8 }# V

void main(void) 
1 y* P8 U0 |0 ^
{, U0 A& f9 ]; W+ L/ s5 g5 h

void *hFor;                //表达式句柄4 B\\" j. P& L. M\\" b$ Z, y; X

luINT nPara;                //存放表达式的自变量个数\\" }; K; d% }+ K) ^* u1 D' J

LuData *pPara;                //存放输入自变量的数组指针 
9 v$ H. ^4 Q; Q! b6 D* a6 f! @
        luINT ErrBegin,ErrEnd;        //表达式编译出错的初始位置和结束位置7 S4 A1 |* E1 j- ~

int ErrCode;                //错误代码4 O) O; r8 s+ [, U8 H9 a' u+ X

void *v; 
7 c6 \5 H8 S8 a- z; x, g4 g
        wchar_t ForStr[]=L"o{new[matrix,2,3: 0.,1.,2.;3.,4.,5.]*new[matrix,3,2: 1.,2.;3.,4.;5.,6.]}";//字符串表达式，矩阵乘 
4 H. o! }; M5 l: w
        //wchar_t ForStr[]=L"o{new[matrix,2,3: 0.,1.,2.;3.,4.,5.].*new[matrix,2,3: 1.,2.,3.;4.,5.,6.]}";//字符串表达式，矩阵点乘4 K' j* @, b) i1 Z) i+ a

LuData Val; 
  r, R/ O4 u8 {: Q
        if(!InitLu()) return;        //初始化Lu. h7 ^) U, Z- z% Y/ _* R. `7 X

while(LockKey(Matrix,DelMatrix,OpMatrix)){Matrix--;}        //锁定一个键，用于存储矩阵扩展类型 
' L- \7 G) j) f& A\\" S% G# [
( J8 R  ~7 b$ y3 L$ g, O/ j! P

Val.BType=luStaData_int64; Val.VType=luStaData_int64; Val.x=Matrix;        //定义整数常量( i2 J2 i! q4 R# I& y* O* t3 B% t0 y

SetConst(L"matrix",&Val);        //设置整数常量7 i! g9 m* f9 l5 g1 p5 T9 G& z

InsertKey("\0\0\0\0",4,luPubKey_User,LuMessage,NULL,NULL,1,v); //使Lu运行时可输出函数信息 
& {& N3 Z& }7 G& z0 k  t! M- ^6 a
        wcout.imbue(locale("chs"));        //设置输出的locale为中文 
. T( X+ H& f- v; O* T2 U/ p. d8 b
   
! U) m. M8 n, P3 X! e
        ErrCode=LuCom(ForStr,0,0,0,hFor,nPara,pPara,ErrBegin,ErrEnd); //编译表达式 
: G, Q: H* u& t2 g% \/ V6 ]) P7 O
        if(ErrCode)1 ]- U0 ], o' L1 [+ N

{ 
$ q  |4 ^2 m, x# @0 c2 U+ u  u
                wcout<<L"表达式有错误！错误代码："<<ErrCode<<endl;5 k) K, e1 D; d1 X5 f2 _

} 
9 h& d3 F$ p9 k- Y& t
        else. w* u3 g! q* V8 x\\" }' {! z

{ 
& r  U1 T* e4 I/ Z, u; e( s8 _
                LuCal(hFor,pPara);        //计算表达式的值 
2 p: v! O$ Q3 T\\" u# z7 v0 u2 O
        } 
1 D- ~5 b* l% Q* ?
        LockKey(Matrix,NULL,OpMatrix);//解锁键Matrix，本例中，该函数可以不用 
0 M3 Z0 P  A3 O& o8 Y3 I7 z
        FreeLu();                        //释放Lu. T8 i1 r6 g\\" b0 a# o! H6 T  j

}

习题：

（1）自定义矩阵的加、减、左除、右除、点左除等运算，自编测试字符串代码，重新编译运行程序，观察计算结果。

（2）小矩阵乘效率测试。编译运行以下Lu字符串代码：

main(:a,b,c,d,t,i)=# u% H3 P8 ~ n6 F; q/ r\" V
a=new[matrix,2,2: 1.,2.,2.,1.],
\" Y1 z2 l2 Q, ]8 j% V9 m
b=new[matrix,2,2: 2.,1.,1.,2.],: u4 x% y& {# h\" K6 i\" |' \
c=new[matrix,2,2: 2/3.,-1/3.,-1/3.,2/3.],
8 }3 C, q+ x6 a
t=clock(),\" _* D4 X4 a% r2 u
d=a*b, i=0, while{i<1000000, d=d*c*b, i++},' b) z, Z, m, E\" q( Q/ U
o{d, "time=",[clock()-t]/1000.," seconds.\r\n"}

复制代码

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

wchar_t ForStr[]=L"main(:a,b,c,d,t,i)= a=new[matrix,2,2: 1.,2.,2.,1.], b=new[matrix,2,2: 2.,1.,1.,2.], c=new[matrix,2,2: 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\"}";//字符串表达式

复制代码

结果：