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

查看: 9062|回复: 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>
# k5 R* |& g% P. T& I+ x0 c
#include <iostream>
# ], G9 w1 D. ^# k# L
#include <math.h>
, q- l0 H* Q# q. m/ H5 w
#include "lu32.h"
2 E |3 H, _# G- |# ]\\" H; [. Z
#pragma comment( lib, "lu32.lib" )
. `# r, A$ Z3 H% }\\" @1 H! R5 D
using namespace std;
4 g, J: I& I8 l\\" n
//自定义矩阵/ Y' E9 e0 h; s+ Y1 U1 ^1 I
class myMatrix
% E; e! Q+ M* e3 [% T6 E, R
{! _; @7 Y/ z+ e4 A% r) F
public:
- r) l4 Q+ R8 M
double *Array; //数据缓冲区9 N9 n4 F! O% p6 G$ ^$ z
luVOID ArrayLen; //数据缓冲区长度4 s\\" I$ K; r: r1 Q\\" ?& G X% b
luVOID Dim[2]; //矩阵维数
( _- ~' s' D2 D! a# A, G- Q) I) w, F( ?
myMatrix(){Array=NULL; ArrayLen=0; Dim[0]=0; Dim[1]=0;}9 ]$ x8 u0 D/ I1 {: H1 ?7 b
~myMatrix()6 @% O. b3 K. e! i9 y
{( u1 q. I: H) H8 v& ]$ t4 Z
if(Array) delete[] Array;
6 R3 h$ w3 X\\" W& C3 }; f+ H
}
3 g1 N% G\\" d2 b% C% s: e: q0 v6 B
};( f; ^: E) W- W/ Y
luKEY Matrix=-1000; //标识矩阵类型，最终的Matrix由LockKey决定
% O) M5 |\\" Z\\" ^, o) h* r7 B8 d
void _stdcall LuMessage(wchar_t *pch)//输出动态库信息，该函数注册到Lu，由Lu二级函数调用 $ T6 Q9 y* r, d5 d
{
* L( e6 \' y2 \1 i\\" p; a ]
wcout<<pch;- T+ B$ ]: B! z' N/ O' A
}
* l# {' y1 s% z% N5 f+ }7 _
void _stdcall DelMatrix(void *me) //用于LockKey函数及InsertKey函数，使Lu能自动销毁myMatrix对象1 W% ^5 }2 I% [. b\\" s8 r6 m3 K\\" p
{9 _: R% z: q* M* b, a/ Z0 y
delete (myMatrix *)me;& X. m, n\\" d! C8 l
}
+ M7 U ]& l) a8 B
myMatrix * _stdcall NewMatrix(luVOID m,luVOID n) //生成一个myMatrix对象. | Z- H2 Q! M) I7 Q* u
{
7 T' t' @; C; o. H
myMatrix *pMatrix;\\" X L, v2 P9 x% R9 D7 r$ p
luVOID k;6 y& U- L) R8 ^4 ~
double *pa;1 |# R( c2 @ O6 U3 \% k2 a5 O( B
char keyname[sizeof(luVOID)];
- {) ^\\" I* F2 P1 q0 q; G
void *NowKey;
, r' R\\" J% P' K9 f* E. l
k=m*n;
5 t* i' b c+ C* D0 t+ U
pMatrix=(myMatrix *)GetBufObj(Matrix,keyname);//先尝试从缓冲区中获取一个矩阵对象
. o$ y% `2 P6 h0 \: ]8 |& c
if(pMatrix)
' ]$ i( e3 q# W/ m5 c! r
{
\\" M5 Q- |\\" a% S7 s+ h X6 p% ]
if(pMatrix->ArrayLen!=k) //重置矩阵的大小
7 R( j% [: p' R1 ~* _5 w
{
/ i- n1 P' ^! |
pa=new double[k];
1 w, w5 h2 d- L- r. X! A
if(!pa)
1 j6 l7 y; R; k/ N1 j E
{0 P+ c5 G P, l/ y# T$ {4 F6 L
DeleteKey(keyname,sizeof(luVOID),Matrix,DelMatrix,1); //将矩阵对象放回缓冲区, y0 d& X$ h: ]\\" b( q7 r\\" Y
return NULL;
% s' @0 I. e5 R, G6 Y d* x/ v
} ]' c% `- V\\" ^\\" D# A; ]7 ^\\" N1 e
delete[] pMatrix->Array;5 P2 P: I. y; s' y3 M\\" Z
pMatrix->Array=pa;
( X. o% N0 u! B: l+ N# E
}) t( k5 v$ D! X5 L
}0 S0 f2 M% a* K3 u7 T( J. b* u0 Z
else
! `: z( f, P- y) l5 }- D% z
{7 C f0 ], `8 r2 E9 q, c8 W
pMatrix=new myMatrix; //创建矩阵对象
( u) M/ d7 \1 t$ I3 j& q5 u2 v
if(!pMatrix) return NULL;
0 E& ]8 M9 ]- i8 ~
pMatrix->Array=new double[k];( M1 f3 K( h: v1 J+ u\\" B
if(!pMatrix->Array)
\\" \+ ^ l4 z4 r( |2 B
{! t# w# }5 d o4 a7 K* b4 I
delete pMatrix;3 f. w& H5 p6 d0 H4 E' j
return NULL;3 ?# ]6 V$ C% t9 Q7 @3 V
}+ H% z* ?5 |/ F* `1 M
if(InsertKey((char *)&pMatrix,-1,Matrix,pMatrix,DelMatrix,NULL,0,NowKey)) //将矩阵对象注册到Lu
5 l; K) t& c- N' ~1 \$ y
{2 D) f0 p8 X) h0 R6 V
delete pMatrix;# c! V( ~ B+ S5 e
return NULL;' ~6 b) w. P9 B3 m
}- V8 |( e5 |/ w
}
% ^& D2 I1 H9 S! Z4 ^7 B
pMatrix->ArrayLen=k; pMatrix->Dim[0]=m; pMatrix->Dim[1]=n;. H4 l5 ]) a K0 n3 E
return pMatrix;. \# j5 j% x) f; p: K* m5 P6 }
}
) k9 _2 H3 i, L4 Y3 [
LuData _stdcall OpMatrix(luINT mm,LuData *xx,void *hFor,int theOperator) //运算符重载函数，用于LockKey函数 Y& k. E- q\\" E- G
{
. b, |) k\\" {8 S5 k
LuData a;
; O2 l1 v! r! E m) O
myMatrix *pMatrix1,*pMatrix2,*pMatrix3;
; B# m1 j/ C/ b6 {* \! s; T+ l# k
luVOID i,j,k,m,n,u,v;
8 h1 o+ B6 z% m |+ o/ o9 X5 v
double *pa,*pb,*pc;
* ?! l& b' P\\" y
luMessage pMessage;
( f+ O. O) o5 R3 e2 i$ b
wchar_t wchNum[32];. C& E* s$ b* P( R5 {6 c: K4 u% f& A
char chNum[32];! @\\" D$ |/ Y2 h. ^+ z4 b
a.BType=luStaData_nil; a.VType=luStaData_nil; a.x=0;
& V$ |- K2 x' j\\" d! h# m
switch(theOperator)
0 N) s5 {' \# W0 q, ^6 t
{
& f; l\\" l; ^( Z2 J$ m
case 2: //重载运算符*4 R( e4 L. D& t% q( A/ N
pMatrix1=(myMatrix *)SearchKey((char *)&(xx->x),sizeof(luVOID),Matrix);
0 u8 T5 }9 n: W; Y4 m( P* b v
pMatrix2=(myMatrix *)SearchKey((char *)&((xx+1)->x),sizeof(luVOID),Matrix);
1 i; g( ?7 t5 n& M1 J8 A! \
if(!pMatrix1 || !pMatrix2) break; //对象句柄无效，不是矩阵- g0 E6 @9 ]9 r0 \4 l; P\\" x
if(pMatrix1->Dim[1]!=pMatrix2->Dim[0]) break; //维数不匹配
! j0 |) u/ ], M4 G; K% w
pMatrix3=NewMatrix(pMatrix1->Dim[0],pMatrix2->Dim[1]); //生成新矩阵
, P! |7 ^7 T' ^, f
if(!pMatrix3) break;
- ?: u/ W( p6 y% J$ W\\" [0 K
pa=pMatrix1->Array; pb=pMatrix2->Array; pc=pMatrix3->Array;
% W, b C\\" X+ I\\" v7 W7 t
m=pMatrix1->Dim[0]; n=pMatrix1->Dim[1]; k=pMatrix2->Dim[1];8 I4 Z* \( f' G( ~ |
for(i=0; i<m; i++) //矩阵乘( S9 j9 m+ O( P U4 V) j6 |
{
8 r- [7 n- v, c. c7 F
for(j=0; j<k; j++)0 w9 e9 E# }7 H1 ]& _
{
9 z1 F! d- G8 Q; V# w; \3 P7 ?
u=i*k+j; pc[u]=0.0;
5 R9 h* ^2 y2 {. m1 g- M
for (v=0; v<n; v++)- |, o- G9 a: @# B! u
{4 n1 y! B5 N3 o- V
pc[u]=pc[u]+pa[i*n+v]*pb[v*k+j];- Q) a! V5 T' R4 i2 h
}9 X. |/ G W0 q1 h1 O
}
. }9 k+ `% `+ s( M( u3 e
}
$ M5 J3 b! O. p, l, E3 i2 a; c
FunReObj(hFor); //告诉Lu，返回一个动态对象. s3 m8 R9 `8 e# F\\" x+ V+ ~5 i3 `
a.BType=Matrix; a.VType=Matrix; a.x=0; *(luVOID *)&(a.x)=(luVOID)pMatrix3;& g# w! Y, F* ]; B/ V, Q) l) t
break;/ L( Z8 ~0 b! ?) A; o
case 25: //重载运算符.*
6 G d4 p1 K0 s\\" l: w. G
pMatrix1=(myMatrix *)SearchKey((char *)&(xx->x),sizeof(luVOID),Matrix);
9 ~8 `4 x* w7 z+ l$ i# a
pMatrix2=(myMatrix *)SearchKey((char *)&((xx+1)->x),sizeof(luVOID),Matrix);% D$ r- K* p8 w1 M4 i\\" R1 |
if(!pMatrix1 || !pMatrix2) break; //对象句柄无效，不是矩阵
1 L0 S1 z0 J( }# |
if(pMatrix1->Dim[0]!=pMatrix2->Dim[0] || pMatrix1->Dim[1]!=pMatrix2->Dim[1]) break; //维数不相同
0 B2 z- N- N3 Q$ V
pMatrix3=NewMatrix(pMatrix1->Dim[0],pMatrix1->Dim[1]); //生成新矩阵3 L3 S\\" J- `1 j& z9 I
if(!pMatrix3) break;
! T\\" @$ g! G1 l0 [! m3 `
for(i=0;i<pMatrix1->ArrayLen;i++) pMatrix3->Array[i]=pMatrix1->Array[i]*pMatrix2->Array[i]; //矩阵点乘\\" l; q& t\\" v7 }( o
FunReObj(hFor); //告诉Lu，返回一个动态对象 ?\\" ]# k2 D8 R8 {0 k s3 _$ q
a.BType=Matrix; a.VType=Matrix; a.x=0; *(luVOID *)&(a.x)=(luVOID)pMatrix3;
9 Y( \5 l7 W$ O4 d7 T( m; a
break;9 W6 ]\\" w1 k3 l+ h, t7 {
case 46: //重载函数new
3 q7 F8 d7 y; @* y
if(mm<2) break;
' }* T _. e/ R
if((xx+1)->x<1 || (xx+2)->x<1 || (xx+1)->BType!=luStaData_int64 || (xx+2)->BType!=luStaData_int64) break;
: ?: E' H1 n5 ?) P! S\\" K- Q e
pMatrix3=NewMatrix((luVOID)(xx+1)->x,(luVOID)(xx+2)->x);//生成新矩阵
\\" e; x* W/ f. R9 [% o% b2 U
if(!pMatrix3) break;
* a7 d% S- F& W9 ]5 S: T( V
for(j=0,i=3;i<=mm;i++,j++) //赋初值
8 o: P6 ? B8 q8 P5 C7 E
{
2 i2 M4 v2 ]2 |5 ~2 t+ `
if(j>=pMatrix3->ArrayLen) break;
3 ^* }( Q- W$ E. R' c' ~4 \
if((xx+i)->BType!=luStaData_double) break; //只接受实数参数
Y ~( o' E0 e& U6 G8 N$ s
pMatrix3->Array[j]=*(double *)&((xx+i)->x);2 o& ~& `\\" P5 M6 F9 n
}
! l\\" l4 k' B# D m `
FunReObj(hFor); //告诉Lu，返回一个动态对象
3 i2 Y: c$ M# t1 t7 b+ v9 [
a.BType=Matrix; a.VType=Matrix; a.x=0; *(luVOID *)&(a.x)=(luVOID)pMatrix3;
3 y& ?4 M4 D3 W e
break;
, R$ M0 {9 \. E4 i8 r8 t H
case 49: //重载函数o
, G9 d8 I0 ?& y: K; D
pMessage=(luMessage)SearchKey("\0\0\0\0",sizeof(luVOID),luPubKey_User);6 ^9 e2 \( E2 O: F
if(!pMessage) break;
' H0 g5 M- \) g9 h# v/ a
pMatrix1=(myMatrix *)SearchKey((char *)&(xx->x),sizeof(luVOID),Matrix);
7 w8 @. Y3 ^8 S1 g4 M. ?2 w
if(!pMatrix1) break; //对象句柄无效，不是矩阵/ f4 ?6 i: O& q) Y+ w, H# X7 a! N: F
pa=pMatrix1->Array;* n- _8 W R8 f, S5 g) ]
m=pMatrix1->Dim[0]; n=pMatrix1->Dim[1]; k=0;
& l6 h, Z6 K# n! q- \' g6 G
for(i=0; i<m; i++) //输出矩阵% O$ n* \* l$ x9 B; \6 g' ~
{
. u8 a. o# }' n3 g4 H. E
pMessage(L"\r\n"); k+=2;
\\" F( q6 d! Q0 F+ d# W
for(j=0; j<n; j++)
2 T\\" ]: ?8 y- I6 `
{( A+ [5 a# A- c& u: E/ [3 u$ M
_gcvt_s(chNum,pa[i*n+j],16);1 P8 [* e( @% v( V0 t\\" e4 M9 \
for(u=0;chNum[u];u++) {wchNum[u]=chNum[u]; k++;}, Q0 W, S' |0 x9 V) v1 f
wchNum[u]='\0';
: P$ e0 P% m& O a; Y3 e
pMessage(wchNum); pMessage(L" "); k+=2;
) f( E# p3 y/ z9 D+ y% C% b# d' B% y
}% c\\" J3 _. }+ R
}* M1 ?/ L* t8 j\\" h\\" ]& L T3 i
pMessage(L"\r\n"); k+=2;& { Z+ L1 j2 v9 R _5 W$ M
a.BType=luStaData_int64; a.VType=luStaData_int64; a.x=k; //按函数o的要求，返回输出的字符总数
2 @7 p6 |/ O l. w% f2 W
break;
2 @- O. [8 b- t\\" X3 X: @( Z2 ]2 k
default:
- B, b, |* {7 Z7 h1 j
break;3 v' z2 r' ^# ^9 ?. S6 J- X
}\\" B1 b* P2 t% q# J# T
return a;% E\\" K4 x. Q0 h0 F! _
}/ z% H5 v/ O& C: l
void main(void); r n6 @! N. e' p h/ f
{/ y\\" {. m\\" W, z9 s/ P
void *hFor; //表达式句柄# l! ?+ m\\" r1 L9 U/ o. A
luINT nPara; //存放表达式的自变量个数# K: [! L) p, e: k0 F
LuData *pPara; //存放输入自变量的数组指针. y2 [9 N# A; r0 @: F: u2 s
luINT ErrBegin,ErrEnd; //表达式编译出错的初始位置和结束位置
2 g7 r/ Y9 V U+ C' n
int ErrCode; //错误代码
% w, C! T- Q8 `% ~
void *v; ~. S( |! h$ T& u
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.]}";//字符串表达式，矩阵乘# {% N+ z! k2 A! [. i8 S
//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.]}";//字符串表达式，矩阵点乘
/ @3 Z0 w5 P) i7 N9 D
LuData Val;
( j5 j7 S9 d) s; g; V, @
if(!InitLu()) return; //初始化Lu j4 D( q. ]( T
while(LockKey(Matrix,DelMatrix,OpMatrix)){Matrix--;} //锁定一个键，用于存储矩阵扩展类型
4 }- G! J) U! R
) q) x8 ]& ~& l9 E5 o: E
Val.BType=luStaData_int64; Val.VType=luStaData_int64; Val.x=Matrix; //定义整数常量
, g0 X8 M4 I4 m\\" X8 Y$ e9 t
SetConst(L"matrix",&Val); //设置整数常量
\\" \. Q9 G' z+ U7 U' ?
InsertKey("\0\0\0\0",4,luPubKey_User,LuMessage,NULL,NULL,1,v); //使Lu运行时可输出函数信息 t) R Y0 H. i. s0 K
wcout.imbue(locale("chs")); //设置输出的locale为中文
3 F# W' p% U0 @\\" T- a7 w) f
% h3 V3 L. K) r: Z( @& R
ErrCode=LuCom(ForStr,0,0,0,hFor,nPara,pPara,ErrBegin,ErrEnd); //编译表达式
- n0 g! v, c4 ?
if(ErrCode)) `7 Q6 i8 k3 B/ D
{1 x! ~) u9 J. a% ]7 q) }
wcout<<L"表达式有错误！错误代码："<<ErrCode<<endl;6 ]6 r; \! z9 m* D6 D/ ?: O
}' J1 a. j( J: b\\" `: D
else/ n) @& ]; z6 @ A
{
' @ ]$ E. J: ?
LuCal(hFor,pPara); //计算表达式的值
, z/ B! _1 _& N% `
}: c3 n, A3 ^1 C- M$ W
LockKey(Matrix,NULL,OpMatrix);//解锁键Matrix，本例中，该函数可以不用
) g2 w0 X5 o: Y2 i K
FreeLu(); //释放Lu7 J0 B\\" ?/ L3 K2 @! J; c& ]& K
}

#include <windows.h> 
# k5 R* |& g% P. T& I+ x0 c
#include <iostream> 
# ], G9 w1 D. ^# k# L
#include <math.h> 
, q- l0 H* Q# q. m/ H5 w
#include "lu32.h" 
2 E  |3 H, _# G- |# ]\\" H; [. Z
#pragma comment( lib, "lu32.lib" ) 
. `# r, A$ Z3 H% }\\" @1 H! R5 D
using namespace std; 
4 g, J: I& I8 l\\" n
//自定义矩阵/ Y' E9 e0 h; s+ Y1 U1 ^1 I

class myMatrix 
% E; e! Q+ M* e3 [% T6 E, R
{! _; @7 Y/ z+ e4 A% r) F

public: 
- r) l4 Q+ R8 M
        double *Array;        //数据缓冲区9 N9 n4 F! O% p6 G$ ^$ z

luVOID ArrayLen;        //数据缓冲区长度4 s\\" I$ K; r: r1 Q\\" ?& G  X% b

luVOID Dim[2];        //矩阵维数 
( _- ~' s' D2 D! a# A, G- Q) I) w, F( ?
        myMatrix(){Array=NULL; ArrayLen=0; Dim[0]=0; Dim[1]=0;}9 ]$ x8 u0 D/ I1 {: H1 ?7 b

~myMatrix()6 @% O. b3 K. e! i9 y

{( u1 q. I: H) H8 v& ]$ t4 Z

if(Array) delete[] Array; 
6 R3 h$ w3 X\\" W& C3 }; f+ H
        } 
3 g1 N% G\\" d2 b% C% s: e: q0 v6 B
};( f; ^: E) W- W/ Y

luKEY Matrix=-1000;        //标识矩阵类型，最终的Matrix由LockKey决定 
% O) M5 |\\" Z\\" ^, o) h* r7 B8 d
void _stdcall LuMessage(wchar_t *pch)//输出动态库信息，该函数注册到Lu，由Lu二级函数调用 $ T6 Q9 y* r, d5 d

{ 
* L( e6 \' y2 \1 i\\" p; a  ]
        wcout<<pch;- T+ B$ ]: B! z' N/ O' A

} 
* l# {' y1 s% z% N5 f+ }7 _
void _stdcall DelMatrix(void *me)        //用于LockKey函数及InsertKey函数，使Lu能自动销毁myMatrix对象1 W% ^5 }2 I% [. b\\" s8 r6 m3 K\\" p

{9 _: R% z: q* M* b, a/ Z0 y

delete (myMatrix *)me;& X. m, n\\" d! C8 l

} 
+ M7 U  ]& l) a8 B
myMatrix * _stdcall NewMatrix(luVOID m,luVOID n)        //生成一个myMatrix对象. |  Z- H2 Q! M) I7 Q* u

{ 
7 T' t' @; C; o. H
        myMatrix *pMatrix;\\" X  L, v2 P9 x% R9 D7 r$ p

luVOID k;6 y& U- L) R8 ^4 ~

double *pa;1 |# R( c2 @  O6 U3 \% k2 a5 O( B

char keyname[sizeof(luVOID)]; 
- {) ^\\" I* F2 P1 q0 q; G
        void *NowKey; 
, r' R\\" J% P' K9 f* E. l
        k=m*n; 
5 t* i' b  c+ C* D0 t+ U
        pMatrix=(myMatrix *)GetBufObj(Matrix,keyname);//先尝试从缓冲区中获取一个矩阵对象 
. o$ y% `2 P6 h0 \: ]8 |& c
        if(pMatrix) 
' ]$ i( e3 q# W/ m5 c! r
        { 
\\" M5 Q- |\\" a% S7 s+ h  X6 p% ]
                if(pMatrix->ArrayLen!=k)        //重置矩阵的大小 
7 R( j% [: p' R1 ~* _5 w
                { 
/ i- n1 P' ^! |
                        pa=new double[k]; 
1 w, w5 h2 d- L- r. X! A
                        if(!pa) 
1 j6 l7 y; R; k/ N1 j  E
                        {0 P+ c5 G  P, l/ y# T$ {4 F6 L

DeleteKey(keyname,sizeof(luVOID),Matrix,DelMatrix,1);        //将矩阵对象放回缓冲区, y0 d& X$ h: ]\\" b( q7 r\\" Y

return NULL; 
% s' @0 I. e5 R, G6 Y  d* x/ v
                        }  ]' c% `- V\\" ^\\" D# A; ]7 ^\\" N1 e

delete[] pMatrix->Array;5 P2 P: I. y; s' y3 M\\" Z

pMatrix->Array=pa; 
( X. o% N0 u! B: l+ N# E
                }) t( k5 v$ D! X5 L

}0 S0 f2 M% a* K3 u7 T( J. b* u0 Z

else 
! `: z( f, P- y) l5 }- D% z
        {7 C  f0 ], `8 r2 E9 q, c8 W

pMatrix=new myMatrix;        //创建矩阵对象 
( u) M/ d7 \1 t$ I3 j& q5 u2 v
                if(!pMatrix) return NULL; 
0 E& ]8 M9 ]- i8 ~
                pMatrix->Array=new double[k];( M1 f3 K( h: v1 J+ u\\" B

if(!pMatrix->Array) 
\\" \+ ^  l4 z4 r( |2 B
                {! t# w# }5 d  o4 a7 K* b4 I

delete pMatrix;3 f. w& H5 p6 d0 H4 E' j

return NULL;3 ?# ]6 V$ C% t9 Q7 @3 V

}+ H% z* ?5 |/ F* `1 M

if(InsertKey((char *)&pMatrix,-1,Matrix,pMatrix,DelMatrix,NULL,0,NowKey))        //将矩阵对象注册到Lu 
5 l; K) t& c- N' ~1 \$ y
                {2 D) f0 p8 X) h0 R6 V

delete pMatrix;# c! V( ~  B+ S5 e

return NULL;' ~6 b) w. P9 B3 m

}- V8 |( e5 |/ w

} 
% ^& D2 I1 H9 S! Z4 ^7 B
        pMatrix->ArrayLen=k; pMatrix->Dim[0]=m; pMatrix->Dim[1]=n;. H4 l5 ]) a  K0 n3 E

return pMatrix;. \# j5 j% x) f; p: K* m5 P6 }

} 
) k9 _2 H3 i, L4 Y3 [
LuData _stdcall OpMatrix(luINT mm,LuData *xx,void *hFor,int theOperator)        //运算符重载函数，用于LockKey函数  Y& k. E- q\\" E- G

{ 
. b, |) k\\" {8 S5 k
        LuData a; 
; O2 l1 v! r! E  m) O
        myMatrix *pMatrix1,*pMatrix2,*pMatrix3; 
; B# m1 j/ C/ b6 {* \! s; T+ l# k
        luVOID i,j,k,m,n,u,v; 
8 h1 o+ B6 z% m  |+ o/ o9 X5 v
        double *pa,*pb,*pc; 
* ?! l& b' P\\" y
        luMessage pMessage; 
( f+ O. O) o5 R3 e2 i$ b
        wchar_t wchNum[32];. C& E* s$ b* P( R5 {6 c: K4 u% f& A

char chNum[32];! @\\" D$ |/ Y2 h. ^+ z4 b

a.BType=luStaData_nil; a.VType=luStaData_nil; a.x=0; 
& V$ |- K2 x' j\\" d! h# m
        switch(theOperator) 
0 N) s5 {' \# W0 q, ^6 t
        { 
& f; l\\" l; ^( Z2 J$ m
        case 2:        //重载运算符*4 R( e4 L. D& t% q( A/ N

pMatrix1=(myMatrix *)SearchKey((char *)&(xx->x),sizeof(luVOID),Matrix); 
0 u8 T5 }9 n: W; Y4 m( P* b  v
                pMatrix2=(myMatrix *)SearchKey((char *)&((xx+1)->x),sizeof(luVOID),Matrix); 
1 i; g( ?7 t5 n& M1 J8 A! \
                if(!pMatrix1 || !pMatrix2) break;        //对象句柄无效，不是矩阵- g0 E6 @9 ]9 r0 \4 l; P\\" x

if(pMatrix1->Dim[1]!=pMatrix2->Dim[0]) break;        //维数不匹配 
! j0 |) u/ ], M4 G; K% w
                pMatrix3=NewMatrix(pMatrix1->Dim[0],pMatrix2->Dim[1]);        //生成新矩阵 
, P! |7 ^7 T' ^, f
                if(!pMatrix3) break; 
- ?: u/ W( p6 y% J$ W\\" [0 K
                pa=pMatrix1->Array; pb=pMatrix2->Array; pc=pMatrix3->Array; 
% W, b  C\\" X+ I\\" v7 W7 t
                m=pMatrix1->Dim[0]; n=pMatrix1->Dim[1]; k=pMatrix2->Dim[1];8 I4 Z* \( f' G( ~  |

for(i=0; i<m; i++)        //矩阵乘( S9 j9 m+ O( P  U4 V) j6 |

{ 
8 r- [7 n- v, c. c7 F
                        for(j=0; j<k; j++)0 w9 e9 E# }7 H1 ]& _

{ 
9 z1 F! d- G8 Q; V# w; \3 P7 ?
                                u=i*k+j; pc[u]=0.0; 
5 R9 h* ^2 y2 {. m1 g- M
                                for (v=0; v<n; v++)- |, o- G9 a: @# B! u

{4 n1 y! B5 N3 o- V

pc[u]=pc[u]+pa[i*n+v]*pb[v*k+j];- Q) a! V5 T' R4 i2 h

}9 X. |/ G  W0 q1 h1 O

} 
. }9 k+ `% `+ s( M( u3 e
                } 
$ M5 J3 b! O. p, l, E3 i2 a; c
                FunReObj(hFor);        //告诉Lu，返回一个动态对象. s3 m8 R9 `8 e# F\\" x+ V+ ~5 i3 `

a.BType=Matrix; a.VType=Matrix; a.x=0; *(luVOID *)&(a.x)=(luVOID)pMatrix3;& g# w! Y, F* ]; B/ V, Q) l) t

break;/ L( Z8 ~0 b! ?) A; o

case 25:        //重载运算符.* 
6 G  d4 p1 K0 s\\" l: w. G
                pMatrix1=(myMatrix *)SearchKey((char *)&(xx->x),sizeof(luVOID),Matrix); 
9 ~8 `4 x* w7 z+ l$ i# a
                pMatrix2=(myMatrix *)SearchKey((char *)&((xx+1)->x),sizeof(luVOID),Matrix);% D$ r- K* p8 w1 M4 i\\" R1 |

if(!pMatrix1 || !pMatrix2) break;        //对象句柄无效，不是矩阵 
1 L0 S1 z0 J( }# |
                if(pMatrix1->Dim[0]!=pMatrix2->Dim[0] || pMatrix1->Dim[1]!=pMatrix2->Dim[1]) break;        //维数不相同 
0 B2 z- N- N3 Q$ V
                pMatrix3=NewMatrix(pMatrix1->Dim[0],pMatrix1->Dim[1]);        //生成新矩阵3 L3 S\\" J- `1 j& z9 I

if(!pMatrix3) break; 
! T\\" @$ g! G1 l0 [! m3 `
                for(i=0;i<pMatrix1->ArrayLen;i++) pMatrix3->Array[i]=pMatrix1->Array[i]*pMatrix2->Array[i];        //矩阵点乘\\" l; q& t\\" v7 }( o

FunReObj(hFor);        //告诉Lu，返回一个动态对象  ?\\" ]# k2 D8 R8 {0 k  s3 _$ q

a.BType=Matrix; a.VType=Matrix; a.x=0; *(luVOID *)&(a.x)=(luVOID)pMatrix3; 
9 Y( \5 l7 W$ O4 d7 T( m; a
                break;9 W6 ]\\" w1 k3 l+ h, t7 {

case 46:        //重载函数new 
3 q7 F8 d7 y; @* y
                if(mm<2) break; 
' }* T  _. e/ R
                if((xx+1)->x<1 || (xx+2)->x<1 || (xx+1)->BType!=luStaData_int64 || (xx+2)->BType!=luStaData_int64) break; 
: ?: E' H1 n5 ?) P! S\\" K- Q  e
                pMatrix3=NewMatrix((luVOID)(xx+1)->x,(luVOID)(xx+2)->x);//生成新矩阵 
\\" e; x* W/ f. R9 [% o% b2 U
                if(!pMatrix3) break; 
* a7 d% S- F& W9 ]5 S: T( V
                for(j=0,i=3;i<=mm;i++,j++)        //赋初值 
8 o: P6 ?  B8 q8 P5 C7 E
                { 
2 i2 M4 v2 ]2 |5 ~2 t+ `
                        if(j>=pMatrix3->ArrayLen) break; 
3 ^* }( Q- W$ E. R' c' ~4 \
                        if((xx+i)->BType!=luStaData_double) break;        //只接受实数参数 
  Y  ~( o' E0 e& U6 G8 N$ s
                        pMatrix3->Array[j]=*(double *)&((xx+i)->x);2 o& ~& `\\" P5 M6 F9 n

} 
! l\\" l4 k' B# D  m  `
                FunReObj(hFor);        //告诉Lu，返回一个动态对象 
3 i2 Y: c$ M# t1 t7 b+ v9 [
                a.BType=Matrix; a.VType=Matrix; a.x=0; *(luVOID *)&(a.x)=(luVOID)pMatrix3; 
3 y& ?4 M4 D3 W  e
                break; 
, R$ M0 {9 \. E4 i8 r8 t  H
        case 49:        //重载函数o 
, G9 d8 I0 ?& y: K; D
                pMessage=(luMessage)SearchKey("\0\0\0\0",sizeof(luVOID),luPubKey_User);6 ^9 e2 \( E2 O: F

if(!pMessage) break; 
' H0 g5 M- \) g9 h# v/ a
                pMatrix1=(myMatrix *)SearchKey((char *)&(xx->x),sizeof(luVOID),Matrix); 
7 w8 @. Y3 ^8 S1 g4 M. ?2 w
                if(!pMatrix1) break;        //对象句柄无效，不是矩阵/ f4 ?6 i: O& q) Y+ w, H# X7 a! N: F

pa=pMatrix1->Array;* n- _8 W  R8 f, S5 g) ]

m=pMatrix1->Dim[0]; n=pMatrix1->Dim[1]; k=0; 
& l6 h, Z6 K# n! q- \' g6 G
                for(i=0; i<m; i++)        //输出矩阵% O$ n* \* l$ x9 B; \6 g' ~

{ 
. u8 a. o# }' n3 g4 H. E
                        pMessage(L"\r\n"); k+=2; 
\\" F( q6 d! Q0 F+ d# W
                        for(j=0; j<n; j++) 
2 T\\" ]: ?8 y- I6 `
                        {( A+ [5 a# A- c& u: E/ [3 u$ M

_gcvt_s(chNum,pa[i*n+j],16);1 P8 [* e( @% v( V0 t\\" e4 M9 \

for(u=0;chNum[u];u++) {wchNum[u]=chNum[u]; k++;}, Q0 W, S' |0 x9 V) v1 f

wchNum[u]='\0'; 
: P$ e0 P% m& O  a; Y3 e
                                pMessage(wchNum); pMessage(L"  "); k+=2; 
) f( E# p3 y/ z9 D+ y% C% b# d' B% y
                        }% c\\" J3 _. }+ R

}* M1 ?/ L* t8 j\\" h\\" ]& L  T3 i

pMessage(L"\r\n"); k+=2;& {  Z+ L1 j2 v9 R  _5 W$ M

a.BType=luStaData_int64; a.VType=luStaData_int64; a.x=k;        //按函数o的要求，返回输出的字符总数 
2 @7 p6 |/ O  l. w% f2 W
                break; 
2 @- O. [8 b- t\\" X3 X: @( Z2 ]2 k
        default: 
- B, b, |* {7 Z7 h1 j
                break;3 v' z2 r' ^# ^9 ?. S6 J- X

}\\" B1 b* P2 t% q# J# T

return a;% E\\" K4 x. Q0 h0 F! _

}/ z% H5 v/ O& C: l

void main(void); r  n6 @! N. e' p  h/ f

{/ y\\" {. m\\" W, z9 s/ P

void *hFor;                //表达式句柄# l! ?+ m\\" r1 L9 U/ o. A

luINT nPara;                //存放表达式的自变量个数# K: [! L) p, e: k0 F

LuData *pPara;                //存放输入自变量的数组指针. y2 [9 N# A; r0 @: F: u2 s

luINT ErrBegin,ErrEnd;        //表达式编译出错的初始位置和结束位置 
2 g7 r/ Y9 V  U+ C' n
        int ErrCode;                //错误代码 
% w, C! T- Q8 `% ~
        void *v;  ~. S( |! h$ T& u

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.]}";//字符串表达式，矩阵乘# {% N+ z! k2 A! [. i8 S

//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.]}";//字符串表达式，矩阵点乘 
/ @3 Z0 w5 P) i7 N9 D
        LuData Val; 
( j5 j7 S9 d) s; g; V, @
        if(!InitLu()) return;        //初始化Lu  j4 D( q. ]( T

while(LockKey(Matrix,DelMatrix,OpMatrix)){Matrix--;}        //锁定一个键，用于存储矩阵扩展类型 
4 }- G! J) U! R
) q) x8 ]& ~& l9 E5 o: E

Val.BType=luStaData_int64; Val.VType=luStaData_int64; Val.x=Matrix;        //定义整数常量 
, g0 X8 M4 I4 m\\" X8 Y$ e9 t
        SetConst(L"matrix",&Val);        //设置整数常量 
\\" \. Q9 G' z+ U7 U' ?
        InsertKey("\0\0\0\0",4,luPubKey_User,LuMessage,NULL,NULL,1,v); //使Lu运行时可输出函数信息  t) R  Y0 H. i. s0 K

wcout.imbue(locale("chs"));        //设置输出的locale为中文 
3 F# W' p% U0 @\\" T- a7 w) f
  % h3 V3 L. K) r: Z( @& R

ErrCode=LuCom(ForStr,0,0,0,hFor,nPara,pPara,ErrBegin,ErrEnd); //编译表达式 
- n0 g! v, c4 ?
        if(ErrCode)) `7 Q6 i8 k3 B/ D

{1 x! ~) u9 J. a% ]7 q) }

wcout<<L"表达式有错误！错误代码："<<ErrCode<<endl;6 ]6 r; \! z9 m* D6 D/ ?: O

}' J1 a. j( J: b\\" `: D

else/ n) @& ]; z6 @  A

{ 
' @  ]$ E. J: ?
                LuCal(hFor,pPara);        //计算表达式的值 
, z/ B! _1 _& N% `
        }: c3 n, A3 ^1 C- M$ W

LockKey(Matrix,NULL,OpMatrix);//解锁键Matrix，本例中，该函数可以不用 
) g2 w0 X5 o: Y2 i  K
        FreeLu();                        //释放Lu7 J0 B\\" ?/ L3 K2 @! J; c& ]& K

}

习题：

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

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

main(:a,b,c,d,t,i)=2 ^, R& i4 | _/ c3 O: a% C
a=new[matrix,2,2: 1.,2.,2.,1.],
) ^7 k9 W2 E6 ?6 o- v( S; \' s6 f: \
b=new[matrix,2,2: 2.,1.,1.,2.],+ A2 w- O$ a1 Z2 x
c=new[matrix,2,2: 2/3.,-1/3.,-1/3.,2/3.],' ?2 m; t\" j* ^* Z% {\" l
t=clock(),9 T: h. E8 N: s% R
d=a*b, i=0, while{i<1000000, d=d*c*b, i++},
* N) g( M$ s4 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\"}";//字符串表达式

复制代码

结果：