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

查看: 7672|回复: 0

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

[复制链接]

字体大小: 正常放大

forcal

45 主题	3 听众	282 积分

升级 91%

TA的每日心情

	难过 2012-8-27 18:22

签到天数: 1 天

[LV.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>
* U' b* y& P* ~( ~% o0 o7 p
#include <iostream>% r7 Y, m+ W. H
#include <math.h>5 j6 s4 Y( N3 J9 a! |+ E) d
#include "lu32.h"
: V) n; o, H& W1 L( _6 F
#pragma comment( lib, "lu32.lib" )0 i0 ~: Z; r8 v) o
using namespace std;
1 C9 p9 a/ i- N7 P$ Q
//自定义矩阵# |' M+ w2 M, Z\\" H9 k
class myMatrix5 K8 w: _# | M, \\\" l% c0 N4 B
{, h. o7 I; h; f( W
public: K: R' Q. [- J0 F3 T+ q7 P; b
double *Array; //数据缓冲区
: t/ _ s, I' R* z
luVOID ArrayLen; //数据缓冲区长度
$ r! s& O2 I' @! B) `5 q0 U
luVOID Dim[2]; //矩阵维数
% q; f- W( T; Z; b% ?$ \
myMatrix(){Array=NULL; ArrayLen=0; Dim[0]=0; Dim[1]=0;}
0 D- D# o2 L9 [8 U5 r4 N
~myMatrix()
$ M5 i( t6 a: R! S4 K- z8 W
{9 x0 {' E+ v4 I c
if(Array) delete[] Array;7 k) q) q: A. O
}
/ e6 D( r% `& k/ D* Y' d
};
' B8 k$ S\\" \5 R! P3 N) p& ^
luKEY Matrix=-1000; //标识矩阵类型，最终的Matrix由LockKey决定 T* F\\" `: _5 c* S5 G- V( A8 N
void _stdcall LuMessage(wchar_t *pch)//输出动态库信息，该函数注册到Lu，由Lu二级函数调用 3 A2 D7 l$ E$ w7 D
{1 d( q3 N7 Z3 ^1 T; x! r2 z
wcout<<pch;
# x1 E4 U$ h! m\\" T$ ~
}) ^$ S6 O q7 t8 o; N
void _stdcall DelMatrix(void *me) //用于LockKey函数及InsertKey函数，使Lu能自动销毁myMatrix对象8 d, [2 i, D\\" P6 C; o8 w! ?5 K* K8 L
{2 y( }- N- D5 I
delete (myMatrix *)me;
9 d! Z% p& K( r2 k! \, W+ _
}
! U4 D4 u5 @% L9 O
myMatrix * _stdcall NewMatrix(luVOID m,luVOID n) //生成一个myMatrix对象
/ r0 \# K3 ~+ q! Z\\" u
{ _- G( Z7 G3 U' q2 W\\" K! u
myMatrix *pMatrix;
! ^! u2 [& o! d/ n- p% h8 H
luVOID k;7 H6 V/ e' I\\" P1 w3 ~1 _! h t. e& b
double *pa;
4 W9 J; D3 ?! g& l$ I6 c
char keyname[sizeof(luVOID)];2 p1 Z/ l1 _; ^
void *NowKey;
N( q+ G ?8 e+ \7 v5 w
k=m*n;
2 ^+ _4 L; o7 T' R
pMatrix=(myMatrix *)GetBufObj(Matrix,keyname);//先尝试从缓冲区中获取一个矩阵对象- ^8 E. L/ m0 N; r; z
if(pMatrix)
$ F% R\\" D! P6 ~7 D6 \
{$ K' F\\" z) J t/ Q/ u\\" @\\" M+ R
if(pMatrix->ArrayLen!=k) //重置矩阵的大小9 y7 G! ?- V V7 a8 K
{4 X9 w! {) |' f& h
pa=new double[k]; w6 u; ~( ]( z! S7 K
if(!pa); H2 \2 w8 X8 l( K+ M5 L
{3 [8 {\\" \* n% z\\" \4 P
DeleteKey(keyname,sizeof(luVOID),Matrix,DelMatrix,1); //将矩阵对象放回缓冲区
9 q* ~ Y8 E; ]0 E& V0 `
return NULL;
# n! [) T1 y: C0 ?
}* E5 m+ f\\" Z+ z) n9 T2 [
delete[] pMatrix->Array;- [4 [) i, @+ ]6 P\\" N
pMatrix->Array=pa;
( k# |4 n7 Y7 U& ~\\" l
}1 C5 A4 N! I+ r7 k2 h$ U3 r$ I
}5 O% s' ]+ H1 X; K9 R! i
else7 I: Q) ]# a; Z, x0 Y4 J
{2 o( E7 e* L' k3 ^5 K( O
pMatrix=new myMatrix; //创建矩阵对象
9 }& Z; x1 z1 { J
if(!pMatrix) return NULL;, h: y/ i( s& `- P8 w6 Y
pMatrix->Array=new double[k];# H- L3 E* `5 ?4 K7 ~
if(!pMatrix->Array)
{
! @- S. O1 z7 w( }\\" x5 J! d
delete pMatrix;
: D\\" l/ Z3 ?! R2 v$ G
return NULL;9 b\\" v0 F% R- G: {& V
}0 S$ s' ~: H1 G3 A. j) }' i0 [& C
if(InsertKey((char *)&pMatrix,-1,Matrix,pMatrix,DelMatrix,NULL,0,NowKey)) //将矩阵对象注册到Lu
# T! ^8 n4 D; _( s) L
{
0 |4 N: H5 b! t! @/ g
delete pMatrix;0 d- {( ?. L- ~1 ?
return NULL;6 J2 I8 |7 Y' z+ X0 Z% P) }
}
; d2 a! }: @' h: i6 o/ a, {9 S. H# Z0 N
}+ d4 S8 {$ e& ^) D, s
pMatrix->ArrayLen=k; pMatrix->Dim[0]=m; pMatrix->Dim[1]=n;
, `9 o( Q) @$ k- P2 {
return pMatrix;
% y7 V# n7 I, y- B1 A, s' d1 A
}5 H# j% m* |% s\\" y v. f
LuData _stdcall OpMatrix(luINT mm,LuData *xx,void *hFor,int theOperator) //运算符重载函数，用于LockKey函数8 p0 Z, c0 c8 t7 U+ c G
{\\" L- C. [: b8 L4 a; J# e3 {
LuData a;* L+ N# d$ @: G: A- f& L& ?& O
myMatrix *pMatrix1,*pMatrix2,*pMatrix3;
% D- ]; e3 Z6 X# W' C- V3 k7 i
luVOID i,j,k,m,n,u,v;
! i5 y6 s( W N# U
double *pa,*pb,*pc;7 q3 S9 z5 n8 i: G% J( A
luMessage pMessage;
( n, ?' p2 M+ B5 `, \
wchar_t wchNum[32];+ d: b8 \5 L4 `
char chNum[32];
) d: w& V& {8 U! ^2 O/ b3 E: X
a.BType=luStaData_nil; a.VType=luStaData_nil; a.x=0;\\" F7 D7 i6 n) B
switch(theOperator): f1 s' u0 g& |. ^; [2 H+ s1 N
{; v3 p) T' H0 e2 D3 `4 N7 ?
case 2: //重载运算符*
' R5 x: X9 l1 `% H
pMatrix1=(myMatrix *)SearchKey((char *)&(xx->x),sizeof(luVOID),Matrix);4 g1 r: h* s) n! f4 H
pMatrix2=(myMatrix *)SearchKey((char *)&((xx+1)->x),sizeof(luVOID),Matrix);6 e; A/ w\\" _4 T& t
if(!pMatrix1 || !pMatrix2) break; //对象句柄无效，不是矩阵
, C\\" [- V. ]# B* X& x' W
if(pMatrix1->Dim[1]!=pMatrix2->Dim[0]) break; //维数不匹配% g4 I- s' z& Q. W1 Y* K
pMatrix3=NewMatrix(pMatrix1->Dim[0],pMatrix2->Dim[1]); //生成新矩阵
\\" r( I* E9 N9 I% j! u) b
if(!pMatrix3) break;
! O& w6 N, u* d* x8 T
pa=pMatrix1->Array; pb=pMatrix2->Array; pc=pMatrix3->Array;( M5 W( Y* @2 w% ?( i6 G# W- g
m=pMatrix1->Dim[0]; n=pMatrix1->Dim[1]; k=pMatrix2->Dim[1]; }& M2 m( S$ ^
for(i=0; i<m; i++) //矩阵乘1 T1 o( g6 [$ U a! h8 |( _
{* o) p5 A6 m, |& O U/ o3 k- x$ s
for(j=0; j<k; j++)
/ {- |4 G, E/ J5 ?3 O
{3 }\\" f* S; B1 ^4 ?$ [
u=i*k+j; pc[u]=0.0;\\" K8 T/ i/ z: C\\" k
for (v=0; v<n; v++)\\" i$ n\\" f' Z5 v; M9 U1 [
{5 J ^! C/ X) B3 n
pc[u]=pc[u]+pa[i*n+v]*pb[v*k+j];/ w8 K% j6 |2 v4 @- r
}$ n% u/ ~9 n# @0 j
}2 p& K\\" J$ |0 {( y+ U6 c8 m
}
, n4 Z. k6 [& J# [$ _ l
FunReObj(hFor); //告诉Lu，返回一个动态对象
8 G* f2 G+ P G7 O7 z& l
a.BType=Matrix; a.VType=Matrix; a.x=0; *(luVOID *)&(a.x)=(luVOID)pMatrix3;9 t' J) u$ X) a( q- }9 E3 O& S
break;
$ @8 C R9 w+ {2 O* ]; y0 p, _# }
case 25: //重载运算符.** s4 N. |! h8 r2 B2 Z2 ^
pMatrix1=(myMatrix *)SearchKey((char *)&(xx->x),sizeof(luVOID),Matrix);
) s6 z7 Y- V6 W! k# b) L
pMatrix2=(myMatrix *)SearchKey((char *)&((xx+1)->x),sizeof(luVOID),Matrix);7 T2 x. T; I! [& }4 z0 U; |# q5 `# d
if(!pMatrix1 || !pMatrix2) break; //对象句柄无效，不是矩阵
* m) X4 j$ g) v# {3 d: P; r8 K# R
if(pMatrix1->Dim[0]!=pMatrix2->Dim[0] || pMatrix1->Dim[1]!=pMatrix2->Dim[1]) break; //维数不相同5 a I: \% X2 _) r6 Y
pMatrix3=NewMatrix(pMatrix1->Dim[0],pMatrix1->Dim[1]); //生成新矩阵' h% \' g) k9 r( i- u E
if(!pMatrix3) break;
; |6 a- E5 S9 \ U
for(i=0;i<pMatrix1->ArrayLen;i++) pMatrix3->Array[i]=pMatrix1->Array[i]*pMatrix2->Array[i]; //矩阵点乘
5 {8 c& b: g5 J2 g D
FunReObj(hFor); //告诉Lu，返回一个动态对象
: J( a2 [7 b; l, n
a.BType=Matrix; a.VType=Matrix; a.x=0; *(luVOID *)&(a.x)=(luVOID)pMatrix3;\\" Z7 m) J* p7 Q9 Y' }6 g, H
break;
( c4 L- `) G0 c- l) d* r- O
case 46: //重载函数new
2 Z7 n y$ @9 e* J1 ]- R
if(mm<2) break;
% A' i; s2 m, z, e
if((xx+1)->x<1 || (xx+2)->x<1 || (xx+1)->BType!=luStaData_int64 || (xx+2)->BType!=luStaData_int64) break;, A% W ^7 n/ m( R4 _: {1 m$ v
pMatrix3=NewMatrix((luVOID)(xx+1)->x,(luVOID)(xx+2)->x);//生成新矩阵
\\" j/ X r7 u) F9 X: z* x8 X
if(!pMatrix3) break;2 n. w% b4 g' u' b8 H. |' k9 U
for(j=0,i=3;i<=mm;i++,j++) //赋初值4 Z6 C3 W6 c1 {: x2 D$ L- N
{) A3 X. c+ m( F\\" ?( F0 n
if(j>=pMatrix3->ArrayLen) break;
( l1 [\\" F, D/ }7 G$ O2 r: o
if((xx+i)->BType!=luStaData_double) break; //只接受实数参数
' W* ]+ |, C2 K9 q& w\\" e+ L3 S* N6 |
pMatrix3->Array[j]=*(double *)&((xx+i)->x);
7 H1 ]/ Q0 b3 T7 T
}5 i3 _# \6 m1 ~
FunReObj(hFor); //告诉Lu，返回一个动态对象4 r2 j6 u: \8 ?& I
a.BType=Matrix; a.VType=Matrix; a.x=0; *(luVOID *)&(a.x)=(luVOID)pMatrix3;9 L2 z, j u5 m5 ^9 |( D
break;+ a1 \ I& o7 N- v
case 49: //重载函数o
! n0 w: ?) |5 K( u B, z* \5 d. _8 I
pMessage=(luMessage)SearchKey("\0\0\0\0",sizeof(luVOID),luPubKey_User);
0 @0 c9 {1 H. F2 v p
if(!pMessage) break;
. y5 N* O0 x1 }& e W/ r. x' c
pMatrix1=(myMatrix *)SearchKey((char *)&(xx->x),sizeof(luVOID),Matrix);5 O7 u* J5 N\\" a8 j3 R9 _& B# p
if(!pMatrix1) break; //对象句柄无效，不是矩阵
' c) C) D/ I! C3 \2 R
pa=pMatrix1->Array;$ b- x' X4 o& o2 A |
m=pMatrix1->Dim[0]; n=pMatrix1->Dim[1]; k=0;
. _+ n7 a. ?6 w' i5 X7 c; p
for(i=0; i<m; i++) //输出矩阵
7 {: c' H( e$ ?9 W' M d3 _
{# p+ s4 U8 K$ N8 r) I
pMessage(L"\r\n"); k+=2;
for(j=0; j<n; j++)
0 e6 K# }' }. O2 N/ e6 R, k! R\\" g
{
/ x5 y% q' {& l1 s0 n4 R
_gcvt_s(chNum,pa[i*n+j],16);
! m# Z; I( ^9 n- i\\" a
for(u=0;chNum[u];u++) {wchNum[u]=chNum[u]; k++;}
{$ s5 V! `3 l
wchNum[u]='\0';
+ }0 |; l ^( J* {; D5 M( y
pMessage(wchNum); pMessage(L" "); k+=2;
: d6 L0 V) v j
}
; C r5 ^3 F5 _2 D8 F+ X
}
3 y' x) K g5 m+ [1 p& ]5 @
pMessage(L"\r\n"); k+=2;& c) j2 J3 S7 S- A/ g2 R
a.BType=luStaData_int64; a.VType=luStaData_int64; a.x=k; //按函数o的要求，返回输出的字符总数
- W0 `) `\\" }$ F! ~+ Q8 _
break;& h* l' h2 U f6 Y$ J; ]
default:+ p2 F1 b: m1 @ W
break;0 v% h6 c, Z1 s* B' Y\\" U) j7 r
} E2 D' ^7 _% u, T6 n
return a;4 n% `7 i& g. Z/ z
}
! l. Z. I% W, h2 h
void main(void)
6 _) _# M7 J& g8 |5 |\\" ]$ }
{
* h' i# ~% C8 o
void *hFor; //表达式句柄8 k1 ]5 v* ~0 q9 @
luINT nPara; //存放表达式的自变量个数
0 f& O1 J\\" ~) l: n. o9 A! }2 x; f
LuData *pPara; //存放输入自变量的数组指针) H9 e# V2 n/ e. p1 j% {9 L' i
luINT ErrBegin,ErrEnd; //表达式编译出错的初始位置和结束位置1 F. `9 E/ j' }6 ~: [6 V
int ErrCode; //错误代码0 v9 x3 C$ ?2 r
void *v; m$ w. c7 p; ]8 W$ r
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.]}";//字符串表达式，矩阵乘& z1 U# E7 c- Y: _
//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.]}";//字符串表达式，矩阵点乘# J9 Z8 p* Z; ^% N2 I\\" [3 Y! c4 C
LuData Val;
2 Z# ]# O, K1 r1 ?* n: h
if(!InitLu()) return; //初始化Lu
1 J* L# X. m, k8 r\\" h* E
while(LockKey(Matrix,DelMatrix,OpMatrix)){Matrix--;} //锁定一个键，用于存储矩阵扩展类型+ d | o4 ]3 j b) b3 x
( c$ Y9 }* v0 L4 e. y/ W
Val.BType=luStaData_int64; Val.VType=luStaData_int64; Val.x=Matrix; //定义整数常量% @, J0 f9 {# x9 q; I% w
SetConst(L"matrix",&Val); //设置整数常量& d+ | V: U; `6 D( o
InsertKey("\0\0\0\0",4,luPubKey_User,LuMessage,NULL,NULL,1,v); //使Lu运行时可输出函数信息
) M9 Q+ K5 b* c
wcout.imbue(locale("chs")); //设置输出的locale为中文
9 K) Y; E& z. Z+ ?
( q+ g- Z. P. p8 _) D( [\\" a9 W
ErrCode=LuCom(ForStr,0,0,0,hFor,nPara,pPara,ErrBegin,ErrEnd); //编译表达式# h/ K/ j7 _2 t1 h0 ]# E3 ?
if(ErrCode)' G+ K$ ?2 R\\" z- e `9 `8 ]\\" X
{4 C1 s1 M% S9 o* j2 V m( z, Q, L
wcout<<L"表达式有错误！错误代码："<<ErrCode<<endl;
% B/ D; d: V& `2 u3 m) r& y
}
; ^8 Z J6 L% N. m
else
. V7 w7 N p) y3 O$ D5 _
{
& {$ f7 \7 r1 `, H! u6 c3 O
LuCal(hFor,pPara); //计算表达式的值
( s0 S- `, s2 ]3 F) t$ _3 N8 F; u
}- Y0 F5 l X) ^: ^ G\\" w: e6 u% d
LockKey(Matrix,NULL,OpMatrix);//解锁键Matrix，本例中，该函数可以不用
' L! X8 n, B7 |! x; L
FreeLu(); //释放Lu
9 { O ?* P% u
}

#include <windows.h> 
* U' b* y& P* ~( ~% o0 o7 p
#include <iostream>% r7 Y, m+ W. H

#include <math.h>5 j6 s4 Y( N3 J9 a! |+ E) d

#include "lu32.h" 
: V) n; o, H& W1 L( _6 F
#pragma comment( lib, "lu32.lib" )0 i0 ~: Z; r8 v) o

using namespace std; 
1 C9 p9 a/ i- N7 P$ Q
//自定义矩阵# |' M+ w2 M, Z\\" H9 k

class myMatrix5 K8 w: _# |  M, \\\" l% c0 N4 B

{, h. o7 I; h; f( W

public:  K: R' Q. [- J0 F3 T+ q7 P; b

double *Array;        //数据缓冲区 
: t/ _  s, I' R* z
        luVOID ArrayLen;        //数据缓冲区长度 
$ r! s& O2 I' @! B) `5 q0 U
        luVOID Dim[2];        //矩阵维数 
% q; f- W( T; Z; b% ?$ \
        myMatrix(){Array=NULL; ArrayLen=0; Dim[0]=0; Dim[1]=0;} 
0 D- D# o2 L9 [8 U5 r4 N
        ~myMatrix() 
$ M5 i( t6 a: R! S4 K- z8 W
        {9 x0 {' E+ v4 I  c

if(Array) delete[] Array;7 k) q) q: A. O

} 
/ e6 D( r% `& k/ D* Y' d
}; 
' B8 k$ S\\" \5 R! P3 N) p& ^
luKEY Matrix=-1000;        //标识矩阵类型，最终的Matrix由LockKey决定  T* F\\" `: _5 c* S5 G- V( A8 N

void _stdcall LuMessage(wchar_t *pch)//输出动态库信息，该函数注册到Lu，由Lu二级函数调用 3 A2 D7 l$ E$ w7 D

{1 d( q3 N7 Z3 ^1 T; x! r2 z

wcout<<pch; 
# x1 E4 U$ h! m\\" T$ ~
}) ^$ S6 O  q7 t8 o; N

void _stdcall DelMatrix(void *me)        //用于LockKey函数及InsertKey函数，使Lu能自动销毁myMatrix对象8 d, [2 i, D\\" P6 C; o8 w! ?5 K* K8 L

{2 y( }- N- D5 I

delete (myMatrix *)me; 
9 d! Z% p& K( r2 k! \, W+ _
} 
! U4 D4 u5 @% L9 O
myMatrix * _stdcall NewMatrix(luVOID m,luVOID n)        //生成一个myMatrix对象 
/ r0 \# K3 ~+ q! Z\\" u
{  _- G( Z7 G3 U' q2 W\\" K! u

myMatrix *pMatrix; 
! ^! u2 [& o! d/ n- p% h8 H
        luVOID k;7 H6 V/ e' I\\" P1 w3 ~1 _! h  t. e& b

double *pa; 
4 W9 J; D3 ?! g& l$ I6 c
        char keyname[sizeof(luVOID)];2 p1 Z/ l1 _; ^

void *NowKey; 
  N( q+ G  ?8 e+ \7 v5 w
        k=m*n; 
2 ^+ _4 L; o7 T' R
        pMatrix=(myMatrix *)GetBufObj(Matrix,keyname);//先尝试从缓冲区中获取一个矩阵对象- ^8 E. L/ m0 N; r; z

if(pMatrix) 
$ F% R\\" D! P6 ~7 D6 \
        {$ K' F\\" z) J  t/ Q/ u\\" @\\" M+ R

if(pMatrix->ArrayLen!=k)        //重置矩阵的大小9 y7 G! ?- V  V7 a8 K

{4 X9 w! {) |' f& h

pa=new double[k];  w6 u; ~( ]( z! S7 K

if(!pa); H2 \2 w8 X8 l( K+ M5 L

{3 [8 {\\" \* n% z\\" \4 P

DeleteKey(keyname,sizeof(luVOID),Matrix,DelMatrix,1);        //将矩阵对象放回缓冲区 
9 q* ~  Y8 E; ]0 E& V0 `
                                return NULL; 
# n! [) T1 y: C0 ?
                        }* E5 m+ f\\" Z+ z) n9 T2 [

delete[] pMatrix->Array;- [4 [) i, @+ ]6 P\\" N

pMatrix->Array=pa; 
( k# |4 n7 Y7 U& ~\\" l
                }1 C5 A4 N! I+ r7 k2 h$ U3 r$ I

}5 O% s' ]+ H1 X; K9 R! i

else7 I: Q) ]# a; Z, x0 Y4 J

{2 o( E7 e* L' k3 ^5 K( O

pMatrix=new myMatrix;        //创建矩阵对象 
9 }& Z; x1 z1 {  J
                if(!pMatrix) return NULL;, h: y/ i( s& `- P8 w6 Y

pMatrix->Array=new double[k];# H- L3 E* `5 ?4 K7 ~

if(!pMatrix->Array) 
7 u2 j( x* a\\" k! `! v+ d\\" s8 Z6 ~# Y
                { 
! @- S. O1 z7 w( }\\" x5 J! d
                        delete pMatrix; 
: D\\" l/ Z3 ?! R2 v$ G
                        return NULL;9 b\\" v0 F% R- G: {& V

}0 S$ s' ~: H1 G3 A. j) }' i0 [& C

if(InsertKey((char *)&pMatrix,-1,Matrix,pMatrix,DelMatrix,NULL,0,NowKey))        //将矩阵对象注册到Lu 
# T! ^8 n4 D; _( s) L
                { 
0 |4 N: H5 b! t! @/ g
                        delete pMatrix;0 d- {( ?. L- ~1 ?

return NULL;6 J2 I8 |7 Y' z+ X0 Z% P) }

} 
; d2 a! }: @' h: i6 o/ a, {9 S. H# Z0 N
        }+ d4 S8 {$ e& ^) D, s

pMatrix->ArrayLen=k; pMatrix->Dim[0]=m; pMatrix->Dim[1]=n; 
, `9 o( Q) @$ k- P2 {
        return pMatrix; 
% y7 V# n7 I, y- B1 A, s' d1 A
}5 H# j% m* |% s\\" y  v. f

LuData _stdcall OpMatrix(luINT mm,LuData *xx,void *hFor,int theOperator)        //运算符重载函数，用于LockKey函数8 p0 Z, c0 c8 t7 U+ c  G

{\\" L- C. [: b8 L4 a; J# e3 {

LuData a;* L+ N# d$ @: G: A- f& L& ?& O

myMatrix *pMatrix1,*pMatrix2,*pMatrix3; 
% D- ]; e3 Z6 X# W' C- V3 k7 i
        luVOID i,j,k,m,n,u,v; 
! i5 y6 s( W  N# U
        double *pa,*pb,*pc;7 q3 S9 z5 n8 i: G% J( A

luMessage pMessage; 
( n, ?' p2 M+ B5 `, \
        wchar_t wchNum[32];+ d: b8 \5 L4 `

char chNum[32]; 
) d: w& V& {8 U! ^2 O/ b3 E: X
        a.BType=luStaData_nil; a.VType=luStaData_nil; a.x=0;\\" F7 D7 i6 n) B

switch(theOperator): f1 s' u0 g& |. ^; [2 H+ s1 N

{; v3 p) T' H0 e2 D3 `4 N7 ?

case 2:        //重载运算符* 
' R5 x: X9 l1 `% H
                pMatrix1=(myMatrix *)SearchKey((char *)&(xx->x),sizeof(luVOID),Matrix);4 g1 r: h* s) n! f4 H

pMatrix2=(myMatrix *)SearchKey((char *)&((xx+1)->x),sizeof(luVOID),Matrix);6 e; A/ w\\" _4 T& t

if(!pMatrix1 || !pMatrix2) break;        //对象句柄无效，不是矩阵 
, C\\" [- V. ]# B* X& x' W
                if(pMatrix1->Dim[1]!=pMatrix2->Dim[0]) break;        //维数不匹配% g4 I- s' z& Q. W1 Y* K

pMatrix3=NewMatrix(pMatrix1->Dim[0],pMatrix2->Dim[1]);        //生成新矩阵 
\\" r( I* E9 N9 I% j! u) b
                if(!pMatrix3) break; 
! O& w6 N, u* d* x8 T
                pa=pMatrix1->Array; pb=pMatrix2->Array; pc=pMatrix3->Array;( M5 W( Y* @2 w% ?( i6 G# W- g

m=pMatrix1->Dim[0]; n=pMatrix1->Dim[1]; k=pMatrix2->Dim[1];  }& M2 m( S$ ^

for(i=0; i<m; i++)        //矩阵乘1 T1 o( g6 [$ U  a! h8 |( _

{* o) p5 A6 m, |& O  U/ o3 k- x$ s

for(j=0; j<k; j++) 
/ {- |4 G, E/ J5 ?3 O
                        {3 }\\" f* S; B1 ^4 ?$ [

u=i*k+j; pc[u]=0.0;\\" K8 T/ i/ z: C\\" k

for (v=0; v<n; v++)\\" i$ n\\" f' Z5 v; M9 U1 [

{5 J  ^! C/ X) B3 n

pc[u]=pc[u]+pa[i*n+v]*pb[v*k+j];/ w8 K% j6 |2 v4 @- r

}$ n% u/ ~9 n# @0 j

}2 p& K\\" J$ |0 {( y+ U6 c8 m

} 
, n4 Z. k6 [& J# [$ _  l
                FunReObj(hFor);        //告诉Lu，返回一个动态对象 
8 G* f2 G+ P  G7 O7 z& l
                a.BType=Matrix; a.VType=Matrix; a.x=0; *(luVOID *)&(a.x)=(luVOID)pMatrix3;9 t' J) u$ X) a( q- }9 E3 O& S

break; 
$ @8 C  R9 w+ {2 O* ]; y0 p, _# }
        case 25:        //重载运算符.** s4 N. |! h8 r2 B2 Z2 ^

pMatrix1=(myMatrix *)SearchKey((char *)&(xx->x),sizeof(luVOID),Matrix); 
) s6 z7 Y- V6 W! k# b) L
                pMatrix2=(myMatrix *)SearchKey((char *)&((xx+1)->x),sizeof(luVOID),Matrix);7 T2 x. T; I! [& }4 z0 U; |# q5 `# d

if(!pMatrix1 || !pMatrix2) break;        //对象句柄无效，不是矩阵 
* m) X4 j$ g) v# {3 d: P; r8 K# R
                if(pMatrix1->Dim[0]!=pMatrix2->Dim[0] || pMatrix1->Dim[1]!=pMatrix2->Dim[1]) break;        //维数不相同5 a  I: \% X2 _) r6 Y

pMatrix3=NewMatrix(pMatrix1->Dim[0],pMatrix1->Dim[1]);        //生成新矩阵' h% \' g) k9 r( i- u  E

if(!pMatrix3) break; 
; |6 a- E5 S9 \  U
                for(i=0;i<pMatrix1->ArrayLen;i++) pMatrix3->Array[i]=pMatrix1->Array[i]*pMatrix2->Array[i];        //矩阵点乘 
5 {8 c& b: g5 J2 g  D
                FunReObj(hFor);        //告诉Lu，返回一个动态对象 
: J( a2 [7 b; l, n
                a.BType=Matrix; a.VType=Matrix; a.x=0; *(luVOID *)&(a.x)=(luVOID)pMatrix3;\\" Z7 m) J* p7 Q9 Y' }6 g, H

break; 
( c4 L- `) G0 c- l) d* r- O
        case 46:        //重载函数new 
2 Z7 n  y$ @9 e* J1 ]- R
                if(mm<2) break; 
% A' i; s2 m, z, e
                if((xx+1)->x<1 || (xx+2)->x<1 || (xx+1)->BType!=luStaData_int64 || (xx+2)->BType!=luStaData_int64) break;, A% W  ^7 n/ m( R4 _: {1 m$ v

pMatrix3=NewMatrix((luVOID)(xx+1)->x,(luVOID)(xx+2)->x);//生成新矩阵 
\\" j/ X  r7 u) F9 X: z* x8 X
                if(!pMatrix3) break;2 n. w% b4 g' u' b8 H. |' k9 U

for(j=0,i=3;i<=mm;i++,j++)        //赋初值4 Z6 C3 W6 c1 {: x2 D$ L- N

{) A3 X. c+ m( F\\" ?( F0 n

if(j>=pMatrix3->ArrayLen) break; 
( l1 [\\" F, D/ }7 G$ O2 r: o
                        if((xx+i)->BType!=luStaData_double) break;        //只接受实数参数 
' W* ]+ |, C2 K9 q& w\\" e+ L3 S* N6 |
                        pMatrix3->Array[j]=*(double *)&((xx+i)->x); 
7 H1 ]/ Q0 b3 T7 T
                }5 i3 _# \6 m1 ~

FunReObj(hFor);        //告诉Lu，返回一个动态对象4 r2 j6 u: \8 ?& I

a.BType=Matrix; a.VType=Matrix; a.x=0; *(luVOID *)&(a.x)=(luVOID)pMatrix3;9 L2 z, j  u5 m5 ^9 |( D

break;+ a1 \  I& o7 N- v

case 49:        //重载函数o 
! n0 w: ?) |5 K( u  B, z* \5 d. _8 I
                pMessage=(luMessage)SearchKey("\0\0\0\0",sizeof(luVOID),luPubKey_User); 
0 @0 c9 {1 H. F2 v  p
                if(!pMessage) break; 
. y5 N* O0 x1 }& e  W/ r. x' c
                pMatrix1=(myMatrix *)SearchKey((char *)&(xx->x),sizeof(luVOID),Matrix);5 O7 u* J5 N\\" a8 j3 R9 _& B# p

if(!pMatrix1) break;        //对象句柄无效，不是矩阵 
' c) C) D/ I! C3 \2 R
                pa=pMatrix1->Array;$ b- x' X4 o& o2 A  |

m=pMatrix1->Dim[0]; n=pMatrix1->Dim[1]; k=0; 
. _+ n7 a. ?6 w' i5 X7 c; p
                for(i=0; i<m; i++)        //输出矩阵 
7 {: c' H( e$ ?9 W' M  d3 _
                {# p+ s4 U8 K$ N8 r) I

pMessage(L"\r\n"); k+=2; 
7 ~  V  k1 c+ U1 P) @* _0 g. p0 q0 T1 y
                        for(j=0; j<n; j++) 
0 e6 K# }' }. O2 N/ e6 R, k! R\\" g
                        { 
/ x5 y% q' {& l1 s0 n4 R
                                _gcvt_s(chNum,pa[i*n+j],16); 
! m# Z; I( ^9 n- i\\" a
                                for(u=0;chNum[u];u++) {wchNum[u]=chNum[u]; k++;} 
  {$ s5 V! `3 l
                                wchNum[u]='\0'; 
+ }0 |; l  ^( J* {; D5 M( y
                                pMessage(wchNum); pMessage(L"  "); k+=2; 
: d6 L0 V) v  j
                        } 
; C  r5 ^3 F5 _2 D8 F+ X
                } 
3 y' x) K  g5 m+ [1 p& ]5 @
                pMessage(L"\r\n"); k+=2;& c) j2 J3 S7 S- A/ g2 R

a.BType=luStaData_int64; a.VType=luStaData_int64; a.x=k;        //按函数o的要求，返回输出的字符总数 
- W0 `) `\\" }$ F! ~+ Q8 _
                break;& h* l' h2 U  f6 Y$ J; ]

default:+ p2 F1 b: m1 @  W

break;0 v% h6 c, Z1 s* B' Y\\" U) j7 r

}  E2 D' ^7 _% u, T6 n

return a;4 n% `7 i& g. Z/ z

} 
! l. Z. I% W, h2 h
void main(void) 
6 _) _# M7 J& g8 |5 |\\" ]$ }
{ 
* h' i# ~% C8 o
        void *hFor;                //表达式句柄8 k1 ]5 v* ~0 q9 @

luINT nPara;                //存放表达式的自变量个数 
0 f& O1 J\\" ~) l: n. o9 A! }2 x; f
        LuData *pPara;                //存放输入自变量的数组指针) H9 e# V2 n/ e. p1 j% {9 L' i

luINT ErrBegin,ErrEnd;        //表达式编译出错的初始位置和结束位置1 F. `9 E/ j' }6 ~: [6 V

int ErrCode;                //错误代码0 v9 x3 C$ ?2 r

void *v;  m$ w. c7 p; ]8 W$ r

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.]}";//字符串表达式，矩阵乘& z1 U# E7 c- Y: _

//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.]}";//字符串表达式，矩阵点乘# J9 Z8 p* Z; ^% N2 I\\" [3 Y! c4 C

LuData Val; 
2 Z# ]# O, K1 r1 ?* n: h
        if(!InitLu()) return;        //初始化Lu 
1 J* L# X. m, k8 r\\" h* E
        while(LockKey(Matrix,DelMatrix,OpMatrix)){Matrix--;}        //锁定一个键，用于存储矩阵扩展类型+ d  |  o4 ]3 j  b) b3 x

( c$ Y9 }* v0 L4 e. y/ W

Val.BType=luStaData_int64; Val.VType=luStaData_int64; Val.x=Matrix;        //定义整数常量% @, J0 f9 {# x9 q; I% w

SetConst(L"matrix",&Val);        //设置整数常量& d+ |  V: U; `6 D( o

InsertKey("\0\0\0\0",4,luPubKey_User,LuMessage,NULL,NULL,1,v); //使Lu运行时可输出函数信息 
) M9 Q+ K5 b* c
        wcout.imbue(locale("chs"));        //设置输出的locale为中文 
9 K) Y; E& z. Z+ ?
  ( q+ g- Z. P. p8 _) D( [\\" a9 W

ErrCode=LuCom(ForStr,0,0,0,hFor,nPara,pPara,ErrBegin,ErrEnd); //编译表达式# h/ K/ j7 _2 t1 h0 ]# E3 ?

if(ErrCode)' G+ K$ ?2 R\\" z- e  `9 `8 ]\\" X

{4 C1 s1 M% S9 o* j2 V  m( z, Q, L

wcout<<L"表达式有错误！错误代码："<<ErrCode<<endl; 
% B/ D; d: V& `2 u3 m) r& y
        } 
; ^8 Z  J6 L% N. m
        else 
. V7 w7 N  p) y3 O$ D5 _
        { 
& {$ f7 \7 r1 `, H! u6 c3 O
                LuCal(hFor,pPara);        //计算表达式的值 
( s0 S- `, s2 ]3 F) t$ _3 N8 F; u
        }- Y0 F5 l  X) ^: ^  G\\" w: e6 u% d

LockKey(Matrix,NULL,OpMatrix);//解锁键Matrix，本例中，该函数可以不用 
' L! X8 n, B7 |! x; L
        FreeLu();                        //释放Lu 
9 {  O  ?* P% u
}

习题：

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

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

main(:a,b,c,d,t,i)=
: z0 n( U4 T9 R4 m( l
a=new[matrix,2,2: 1.,2.,2.,1.],: q( W' D\" K9 S, Z. Z
b=new[matrix,2,2: 2.,1.,1.,2.],
; I2 H: G# j7 E
c=new[matrix,2,2: 2/3.,-1/3.,-1/3.,2/3.],
! d: \* f5 e- F0 I3 E3 P
t=clock(),
# v* O* W1 l7 r0 d8 @
d=a*b, i=0, while{i<1000000, d=d*c*b, i++},
: n! _/ u. g3 I; A+ C7 G
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\"}";//字符串表达式

复制代码

结果：