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

查看: 7786|回复: 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>
\\" ]. @\\" [' ^7 e, X) m$ B
#include <iostream>
4 c z4 n, T1 |5 a7 [
#include <math.h>! d6 k- e% U6 O3 b7 x) F; t
#include "lu32.h"8 o. B- V& ~8 ]: N% W
#pragma comment( lib, "lu32.lib" )
% A9 B# z& }: C+ P
using namespace std;3 Y0 V D4 L; \3 L' m
//自定义矩阵
0 d! v3 @' H& E( E9 ]
class myMatrix$ n: r; H4 j# S+ D; k D
{: q! q( [( M+ t
public:, K8 ^* C9 O. M5 ]4 |
double *Array; //数据缓冲区0 l8 v% e- K M0 t$ A) F
luVOID ArrayLen; //数据缓冲区长度
6 ~( L5 y8 E. b' ]
luVOID Dim[2]; //矩阵维数: Y\\" M& s# O* t\\" q' c( R- T
myMatrix(){Array=NULL; ArrayLen=0; Dim[0]=0; Dim[1]=0;}/ f3 m/ S$ ^. o/ a/ r% g9 h
~myMatrix()3 R# H0 t! ^* I, T
{7 q( _4 I- C2 G5 X, c0 \
if(Array) delete[] Array;6 k# Y3 n0 b) Y- q% X0 K+ b
}7 \% V: E+ z1 [' S% M
};9 q9 u1 j1 F+ u! L\\" j
luKEY Matrix=-1000; //标识矩阵类型，最终的Matrix由LockKey决定* N0 i\\" p5 ?' M6 N\\" A! N\\" L
void _stdcall LuMessage(wchar_t *pch)//输出动态库信息，该函数注册到Lu，由Lu二级函数调用
( j. |1 P7 {; s' H1 F2 C
{& X; t: j- f! |8 g/ v/ M
wcout<<pch;
& u& N5 V, z- n0 @; _1 O3 s1 p- ?
}
- i: P: n( a+ A7 z: D8 R\\" U+ |7 q
void _stdcall DelMatrix(void *me) //用于LockKey函数及InsertKey函数，使Lu能自动销毁myMatrix对象' u5 ?: m v; S
{. t% H; ^2 N& D
delete (myMatrix *)me;
: _7 T, c+ Q% C( k) Z
}
% U+ [* `7 w& \
myMatrix * _stdcall NewMatrix(luVOID m,luVOID n) //生成一个myMatrix对象
1 O8 f, N* O! p- B\\" S. R
{
~\\" b% a9 h; o\\" b
myMatrix *pMatrix;& x5 @/ i0 c7 K4 |, g
luVOID k;
2 j- ]5 d+ L' i& q# _
double *pa;! Z2 d9 Q% b1 {$ ]2 E, N
char keyname[sizeof(luVOID)];
2 v D: X1 e; J: ]9 S
void *NowKey;9 `! X& g1 U! F& F( E' n
k=m*n;
% {: O$ }+ {# M
pMatrix=(myMatrix *)GetBufObj(Matrix,keyname);//先尝试从缓冲区中获取一个矩阵对象
; `: k/ w ?, e7 h' W
if(pMatrix)% o/ I7 R0 d( z* A0 g
{
. m, s( p7 W8 G4 d0 O9 l
if(pMatrix->ArrayLen!=k) //重置矩阵的大小
2 v) t8 @5 ?8 W
{
4 u3 }# r: d8 N' g4 Q6 G* T
pa=new double[k];\\" T; g/ P\\" `& [& n
if(!pa)/ B6 K6 u, U( A
{0 e& `* `/ ~' N9 F f u9 N8 \
DeleteKey(keyname,sizeof(luVOID),Matrix,DelMatrix,1); //将矩阵对象放回缓冲区
' N3 ?, H( j0 I' O8 j! n9 }; H
return NULL;
2 h) p: l0 k1 a. k) V6 c
}
9 `$ }# L7 K% I, n/ a
delete[] pMatrix->Array;
5 S& i4 ]. I8 K* Q
pMatrix->Array=pa;# I( b: l) q4 H0 A5 A) i1 \6 j
}
2 q) A: @- N5 o& Q
}
5 d1 }2 ]( z/ b9 B\\" ~
else2 w5 a4 s& n* w' [/ U
{* [, w% P, N& A1 V. I6 T }
pMatrix=new myMatrix; //创建矩阵对象' p* n3 d% l7 e5 q$ i% `; x# `
if(!pMatrix) return NULL;
; {1 p8 q L/ V, w/ k1 Z\\" p% q
pMatrix->Array=new double[k];1 F8 |) l0 `1 k$ m& l- g3 c# g$ V
if(!pMatrix->Array)
5 `+ a6 M, T6 y2 B
{
- Z+ G4 b5 J4 F: \1 {; `
delete pMatrix;
, G+ l' g: ?\\" k$ t3 d4 q
return NULL;, N5 p3 @% p3 K* L
}( L8 e6 N+ U7 e) n; |; \7 y- s- X3 U\\" B' A
if(InsertKey((char *)&pMatrix,-1,Matrix,pMatrix,DelMatrix,NULL,0,NowKey)) //将矩阵对象注册到Lu
3 u0 U j8 B3 M g
{
$ ~; R, r% s4 a1 ]
delete pMatrix;
return NULL;; B( z/ `7 h( A9 j3 E% g
}& W4 K) b/ L$ t
}1 I, a4 S\\" k6 o
pMatrix->ArrayLen=k; pMatrix->Dim[0]=m; pMatrix->Dim[1]=n;3 U+ R4 k7 @# q% b4 a. h
return pMatrix;
( T2 ]: E7 G* f( \
}0 l5 E! y\\" l0 a. | ~; Y, T
LuData _stdcall OpMatrix(luINT mm,LuData *xx,void *hFor,int theOperator) //运算符重载函数，用于LockKey函数
0 @# J, z3 G7 C# ]0 b
{\\" W* E& [4 N3 m( N\\" j
LuData a;
% l6 B* R\\" f* n
myMatrix *pMatrix1,*pMatrix2,*pMatrix3;
1 x1 j; ~. b0 Z( L4 N+ @
luVOID i,j,k,m,n,u,v;! n9 i8 D* l& I# U+ l0 n+ G
double *pa,*pb,*pc;, ?8 F( [( Y; r2 S0 R3 ?$ _
luMessage pMessage;$ ~' q+ F: ]4 \, P. n
wchar_t wchNum[32];
' s8 u+ f+ X5 p- N F
char chNum[32];
% a7 e& Z$ ~5 [: d+ `2 L
a.BType=luStaData_nil; a.VType=luStaData_nil; a.x=0;9 i2 l+ E+ O! T+ i6 I
switch(theOperator)
' X5 C6 D) e E) S/ a. d, a
{
# t' U& R- S n\\" G8 b+ c
case 2: //重载运算符*
! W* Z& Y4 s* B
pMatrix1=(myMatrix *)SearchKey((char *)&(xx->x),sizeof(luVOID),Matrix);4 f/ n* M4 t j8 @
pMatrix2=(myMatrix *)SearchKey((char *)&((xx+1)->x),sizeof(luVOID),Matrix);
' ~' R8 }* T; j( o
if(!pMatrix1 || !pMatrix2) break; //对象句柄无效，不是矩阵) z, J* _2 H o0 d/ o
if(pMatrix1->Dim[1]!=pMatrix2->Dim[0]) break; //维数不匹配
/ Z4 Y0 \! I/ }- t2 H$ h
pMatrix3=NewMatrix(pMatrix1->Dim[0],pMatrix2->Dim[1]); //生成新矩阵
; S5 P, f9 g. E. w
if(!pMatrix3) break;1 x6 l1 [% o; e: i. r- x% l
pa=pMatrix1->Array; pb=pMatrix2->Array; pc=pMatrix3->Array;) `+ [% K1 p% ^. \0 s0 R/ a( r
m=pMatrix1->Dim[0]; n=pMatrix1->Dim[1]; k=pMatrix2->Dim[1];! D/ b, B0 |+ p n
for(i=0; i<m; i++) //矩阵乘; U/ i- m8 e8 e( i* a# z; n: W
{
% o: C; p7 M% o* g$ G( R$ x
for(j=0; j<k; j++)
& ^2 a\\" s% c5 z, P0 l
{
: i* \1 q; o\\" P3 v% a, l0 N- r
u=i*k+j; pc[u]=0.0;! b; P\\" f9 }2 B. `& p4 m
for (v=0; v<n; v++): r4 r! k& t. M8 x
{4 N. Q' `8 n% r; r( h1 h% o, o+ R
pc[u]=pc[u]+pa[i*n+v]*pb[v*k+j];
* X) H( @9 E( s
}
, f! m! ^\\" P& n6 R6 g, v# O1 q! d
}
. q1 Q$ e9 {' O( g
}& {/ w0 x \; ]* z6 D, a\\" o! g
FunReObj(hFor); //告诉Lu，返回一个动态对象
/ K: \/ ]6 Z! T& X, R) I
a.BType=Matrix; a.VType=Matrix; a.x=0; *(luVOID *)&(a.x)=(luVOID)pMatrix3;) w8 }( c\\" b1 K3 r5 G* X
break;
8 s$ A: s! B! P, A Q* d
case 25: //重载运算符.*- U* `\\" J: m) E! a3 ?2 q; K* _8 B
pMatrix1=(myMatrix *)SearchKey((char *)&(xx->x),sizeof(luVOID),Matrix);
I7 j; L& {. f; A2 z( Q: F
pMatrix2=(myMatrix *)SearchKey((char *)&((xx+1)->x),sizeof(luVOID),Matrix);% q' P5 M3 C; ^( W- Z; v\\" C `
if(!pMatrix1 || !pMatrix2) break; //对象句柄无效，不是矩阵. |4 q7 d- n$ P2 Q5 C; h% x; e\\" |
if(pMatrix1->Dim[0]!=pMatrix2->Dim[0] || pMatrix1->Dim[1]!=pMatrix2->Dim[1]) break; //维数不相同
! n5 U/ w4 [: @0 o. t; w
pMatrix3=NewMatrix(pMatrix1->Dim[0],pMatrix1->Dim[1]); //生成新矩阵
6 i- Y& [3 }' z, W) o
if(!pMatrix3) break;$ s# z X, J) E5 f+ R3 x( M+ K1 C6 ~7 K
for(i=0;i<pMatrix1->ArrayLen;i++) pMatrix3->Array[i]=pMatrix1->Array[i]*pMatrix2->Array[i]; //矩阵点乘
\\" {' m1 A7 M! i7 f\\" _) A
FunReObj(hFor); //告诉Lu，返回一个动态对象
+ S6 C* G2 X: A' h
a.BType=Matrix; a.VType=Matrix; a.x=0; *(luVOID *)&(a.x)=(luVOID)pMatrix3;* t; O4 t( C C1 g
break;
0 i. H7 p4 E8 G# p8 i/ E
case 46: //重载函数new
$ ^4 g. u* A& z, `
if(mm<2) break;
( f; ~2 D- z9 V6 ` I8 a8 V$ I$ S
if((xx+1)->x<1 || (xx+2)->x<1 || (xx+1)->BType!=luStaData_int64 || (xx+2)->BType!=luStaData_int64) break;\\" p2 b9 Y+ k) O0 h
pMatrix3=NewMatrix((luVOID)(xx+1)->x,(luVOID)(xx+2)->x);//生成新矩阵0 w _) ^5 [4 b D! I; ?8 L
if(!pMatrix3) break;
( k9 n' t$ n C K3 u
for(j=0,i=3;i<=mm;i++,j++) //赋初值
+ P& H. G) A( J- `6 r# M: R
{
! i& V5 F/ e2 A, H3 r
if(j>=pMatrix3->ArrayLen) break;# d0 [( J* N$ n7 L0 h) h$ ?1 b D
if((xx+i)->BType!=luStaData_double) break; //只接受实数参数\\" H4 D3 F5 l0 x9 H3 u! ?9 p
pMatrix3->Array[j]=*(double *)&((xx+i)->x);; r8 W' M8 x, y\\" u/ [\\" h3 B: Q
}
2 ]0 }; j n+ u\\" l
FunReObj(hFor); //告诉Lu，返回一个动态对象% Q9 N' L3 |% T* M+ A( n2 d* T
a.BType=Matrix; a.VType=Matrix; a.x=0; *(luVOID *)&(a.x)=(luVOID)pMatrix3;8 t! W; y8 _\\" l* B2 G3 X/ |
break;
( m1 _' x: \5 R
case 49: //重载函数o. N9 q2 W\\" m+ g5 l- v6 n( G
pMessage=(luMessage)SearchKey("\0\0\0\0",sizeof(luVOID),luPubKey_User);7 K! s7 N# E2 X/ {/ P
if(!pMessage) break;+ b# E( c$ E+ [ h
pMatrix1=(myMatrix *)SearchKey((char *)&(xx->x),sizeof(luVOID),Matrix);
+ ]5 w4 q0 {* f; A/ ?
if(!pMatrix1) break; //对象句柄无效，不是矩阵5 r' |; m( Q r) W% ?' b6 V
pa=pMatrix1->Array;2 x& ]- C8 d% v: N& X
m=pMatrix1->Dim[0]; n=pMatrix1->Dim[1]; k=0;
/ Z: \\\" q) V1 W. m
for(i=0; i<m; i++) //输出矩阵+ t @3 a, [4 a$ B+ B- S8 |# M/ q
{
2 r E( U, {/ L4 i
pMessage(L"\r\n"); k+=2;
~\\" J: q$ j) W0 n# ]: w: q
for(j=0; j<n; j++)
j0 r( y; O9 b* J
{ }# g* w9 b! U, @# k, K* h; G
_gcvt_s(chNum,pa[i*n+j],16);
# Q4 n; Q P\\" X4 S. \6 k9 U# H
for(u=0;chNum[u];u++) {wchNum[u]=chNum[u]; k++;}
# M3 @' Q; Z2 ]8 w\\" @$ X
wchNum[u]='\0';. Y' U3 S8 V. q1 U% i
pMessage(wchNum); pMessage(L" "); k+=2;8 k7 p: ], O* o0 B) b: E
}
/ H, z+ O, _: t) V/ c
}0 Z, ~: J4 J: ?( d
pMessage(L"\r\n"); k+=2;
! p% a3 g: A! |- h: D7 L
a.BType=luStaData_int64; a.VType=luStaData_int64; a.x=k; //按函数o的要求，返回输出的字符总数
! y5 y# u% W- q. t# S4 |
break;1 k) i4 |: c a9 M
default:. M3 J% h5 {9 ~
break;
& K: k+ g1 g6 j2 X/ L0 l( c
}& G+ B9 I5 I: u) g\\" k
return a;5 n5 u/ m& C# @# A% T; J/ A1 |
}: @( F; R5 ]+ L; b2 z0 j
void main(void). y. @9 p, G$ M$ C7 `, }, F
{. |3 }9 _ u: S2 a `/ X' K) ]8 i
void *hFor; //表达式句柄 C; z9 W: D- `1 c/ [) ] H# W: _
luINT nPara; //存放表达式的自变量个数9 y' [+ \' @9 c
LuData *pPara; //存放输入自变量的数组指针
) T0 l( T/ h! I/ \% q6 K( m# {
luINT ErrBegin,ErrEnd; //表达式编译出错的初始位置和结束位置
% s* I7 A2 W0 f% ^
int ErrCode; //错误代码
! u* X3 l, J9 ]$ f! u& B2 q
void *v;
* T( v7 n7 Y8 F g. T
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.]}";//字符串表达式，矩阵乘
8 C; {) X$ t\\" K
//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.]}";//字符串表达式，矩阵点乘6 Q ]' S3 e\\" H# j; ~& E- E
LuData Val;
, }$ H5 I# N) J4 Q
if(!InitLu()) return; //初始化Lu
' J& C. ^9 x; Y) r& y4 z
while(LockKey(Matrix,DelMatrix,OpMatrix)){Matrix--;} //锁定一个键，用于存储矩阵扩展类型
7 {! l( Y+ u( R/ x
. N2 T2 g$ s% `3 ^& [
Val.BType=luStaData_int64; Val.VType=luStaData_int64; Val.x=Matrix; //定义整数常量
7 a3 ]' I2 C# N0 u5 A6 {# g
SetConst(L"matrix",&Val); //设置整数常量
; y\\" d/ ]7 ~# p$ j- _4 R/ u! N: r1 j
InsertKey("\0\0\0\0",4,luPubKey_User,LuMessage,NULL,NULL,1,v); //使Lu运行时可输出函数信息
Y) A\\" _1 |) m$ ? ]5 [/ j
wcout.imbue(locale("chs")); //设置输出的locale为中文
; _2 T( V6 X. a5 d7 ~, x
# H( h/ l; Z* R- B; ^
ErrCode=LuCom(ForStr,0,0,0,hFor,nPara,pPara,ErrBegin,ErrEnd); //编译表达式
; x# \/ e\\" a! T1 Y4 F
if(ErrCode) o% `# o# Z4 l
{
, w) @0 G$ |* j. J1 n& Z
wcout<<L"表达式有错误！错误代码："<<ErrCode<<endl;
6 n' N S# M( m) z! q9 |
}
! E5 v& ~) X+ ?$ b( r
else- N+ p) b& A [4 y0 k
{
( }! x# f) X) @4 v U4 K7 ?
LuCal(hFor,pPara); //计算表达式的值$ @& K\\" R% Z' D0 g% Y5 _8 w
}4 o) j7 _. E+ L- n8 l; Q7 k
LockKey(Matrix,NULL,OpMatrix);//解锁键Matrix，本例中，该函数可以不用% b0 e6 l: C) q$ A9 o
FreeLu(); //释放Lu
9 W5 o, i. \2 A3 m) C$ |
}

#include <windows.h> 
\\" ]. @\\" [' ^7 e, X) m$ B
#include <iostream> 
4 c  z4 n, T1 |5 a7 [
#include <math.h>! d6 k- e% U6 O3 b7 x) F; t

#include "lu32.h"8 o. B- V& ~8 ]: N% W

#pragma comment( lib, "lu32.lib" ) 
% A9 B# z& }: C+ P
using namespace std;3 Y0 V  D4 L; \3 L' m

//自定义矩阵 
0 d! v3 @' H& E( E9 ]
class myMatrix$ n: r; H4 j# S+ D; k  D

{: q! q( [( M+ t

public:, K8 ^* C9 O. M5 ]4 |

double *Array;        //数据缓冲区0 l8 v% e- K  M0 t$ A) F

luVOID ArrayLen;        //数据缓冲区长度 
6 ~( L5 y8 E. b' ]
        luVOID Dim[2];        //矩阵维数: Y\\" M& s# O* t\\" q' c( R- T

myMatrix(){Array=NULL; ArrayLen=0; Dim[0]=0; Dim[1]=0;}/ f3 m/ S$ ^. o/ a/ r% g9 h

~myMatrix()3 R# H0 t! ^* I, T

{7 q( _4 I- C2 G5 X, c0 \

if(Array) delete[] Array;6 k# Y3 n0 b) Y- q% X0 K+ b

}7 \% V: E+ z1 [' S% M

};9 q9 u1 j1 F+ u! L\\" j

luKEY Matrix=-1000;        //标识矩阵类型，最终的Matrix由LockKey决定* N0 i\\" p5 ?' M6 N\\" A! N\\" L

void _stdcall LuMessage(wchar_t *pch)//输出动态库信息，该函数注册到Lu，由Lu二级函数调用 
( j. |1 P7 {; s' H1 F2 C
{& X; t: j- f! |8 g/ v/ M

wcout<<pch; 
& u& N5 V, z- n0 @; _1 O3 s1 p- ?
} 
- i: P: n( a+ A7 z: D8 R\\" U+ |7 q
void _stdcall DelMatrix(void *me)        //用于LockKey函数及InsertKey函数，使Lu能自动销毁myMatrix对象' u5 ?: m  v; S

{. t% H; ^2 N& D

delete (myMatrix *)me; 
: _7 T, c+ Q% C( k) Z
} 
% U+ [* `7 w& \
myMatrix * _stdcall NewMatrix(luVOID m,luVOID n)        //生成一个myMatrix对象 
1 O8 f, N* O! p- B\\" S. R
{ 
  ~\\" b% a9 h; o\\" b
        myMatrix *pMatrix;& x5 @/ i0 c7 K4 |, g

luVOID k; 
2 j- ]5 d+ L' i& q# _
        double *pa;! Z2 d9 Q% b1 {$ ]2 E, N

char keyname[sizeof(luVOID)]; 
2 v  D: X1 e; J: ]9 S
        void *NowKey;9 `! X& g1 U! F& F( E' n

k=m*n; 
% {: O$ }+ {# M
        pMatrix=(myMatrix *)GetBufObj(Matrix,keyname);//先尝试从缓冲区中获取一个矩阵对象 
; `: k/ w  ?, e7 h' W
        if(pMatrix)% o/ I7 R0 d( z* A0 g

{ 
. m, s( p7 W8 G4 d0 O9 l
                if(pMatrix->ArrayLen!=k)        //重置矩阵的大小 
2 v) t8 @5 ?8 W
                { 
4 u3 }# r: d8 N' g4 Q6 G* T
                        pa=new double[k];\\" T; g/ P\\" `& [& n

if(!pa)/ B6 K6 u, U( A

{0 e& `* `/ ~' N9 F  f  u9 N8 \

DeleteKey(keyname,sizeof(luVOID),Matrix,DelMatrix,1);        //将矩阵对象放回缓冲区 
' N3 ?, H( j0 I' O8 j! n9 }; H
                                return NULL; 
2 h) p: l0 k1 a. k) V6 c
                        } 
9 `$ }# L7 K% I, n/ a
                        delete[] pMatrix->Array; 
5 S& i4 ]. I8 K* Q
                        pMatrix->Array=pa;# I( b: l) q4 H0 A5 A) i1 \6 j

} 
2 q) A: @- N5 o& Q
        } 
5 d1 }2 ]( z/ b9 B\\" ~
        else2 w5 a4 s& n* w' [/ U

{* [, w% P, N& A1 V. I6 T  }

pMatrix=new myMatrix;        //创建矩阵对象' p* n3 d% l7 e5 q$ i% `; x# `

if(!pMatrix) return NULL; 
; {1 p8 q  L/ V, w/ k1 Z\\" p% q
                pMatrix->Array=new double[k];1 F8 |) l0 `1 k$ m& l- g3 c# g$ V

if(!pMatrix->Array) 
5 `+ a6 M, T6 y2 B
                { 
- Z+ G4 b5 J4 F: \1 {; `
                        delete pMatrix; 
, G+ l' g: ?\\" k$ t3 d4 q
                        return NULL;, N5 p3 @% p3 K* L

}( L8 e6 N+ U7 e) n; |; \7 y- s- X3 U\\" B' A

if(InsertKey((char *)&pMatrix,-1,Matrix,pMatrix,DelMatrix,NULL,0,NowKey))        //将矩阵对象注册到Lu 
3 u0 U  j8 B3 M  g
                { 
$ ~; R, r% s4 a1 ]
                        delete pMatrix; 
# c2 z\\" B5 V6 v  ~1 _0 r, G' c) b, U
                        return NULL;; B( z/ `7 h( A9 j3 E% g

}& W4 K) b/ L$ t

}1 I, a4 S\\" k6 o

pMatrix->ArrayLen=k; pMatrix->Dim[0]=m; pMatrix->Dim[1]=n;3 U+ R4 k7 @# q% b4 a. h

return pMatrix; 
( T2 ]: E7 G* f( \
}0 l5 E! y\\" l0 a. |  ~; Y, T

LuData _stdcall OpMatrix(luINT mm,LuData *xx,void *hFor,int theOperator)        //运算符重载函数，用于LockKey函数 
0 @# J, z3 G7 C# ]0 b
{\\" W* E& [4 N3 m( N\\" j

LuData a; 
% l6 B* R\\" f* n
        myMatrix *pMatrix1,*pMatrix2,*pMatrix3; 
1 x1 j; ~. b0 Z( L4 N+ @
        luVOID i,j,k,m,n,u,v;! n9 i8 D* l& I# U+ l0 n+ G

double *pa,*pb,*pc;, ?8 F( [( Y; r2 S0 R3 ?$ _

luMessage pMessage;$ ~' q+ F: ]4 \, P. n

wchar_t wchNum[32]; 
' s8 u+ f+ X5 p- N  F
        char chNum[32]; 
% a7 e& Z$ ~5 [: d+ `2 L
        a.BType=luStaData_nil; a.VType=luStaData_nil; a.x=0;9 i2 l+ E+ O! T+ i6 I

switch(theOperator) 
' X5 C6 D) e  E) S/ a. d, a
        { 
# t' U& R- S  n\\" G8 b+ c
        case 2:        //重载运算符* 
! W* Z& Y4 s* B
                pMatrix1=(myMatrix *)SearchKey((char *)&(xx->x),sizeof(luVOID),Matrix);4 f/ n* M4 t  j8 @

pMatrix2=(myMatrix *)SearchKey((char *)&((xx+1)->x),sizeof(luVOID),Matrix); 
' ~' R8 }* T; j( o
                if(!pMatrix1 || !pMatrix2) break;        //对象句柄无效，不是矩阵) z, J* _2 H  o0 d/ o

if(pMatrix1->Dim[1]!=pMatrix2->Dim[0]) break;        //维数不匹配 
/ Z4 Y0 \! I/ }- t2 H$ h
                pMatrix3=NewMatrix(pMatrix1->Dim[0],pMatrix2->Dim[1]);        //生成新矩阵 
; S5 P, f9 g. E. w
                if(!pMatrix3) break;1 x6 l1 [% o; e: i. r- x% l

pa=pMatrix1->Array; pb=pMatrix2->Array; pc=pMatrix3->Array;) `+ [% K1 p% ^. \0 s0 R/ a( r

m=pMatrix1->Dim[0]; n=pMatrix1->Dim[1]; k=pMatrix2->Dim[1];! D/ b, B0 |+ p  n

for(i=0; i<m; i++)        //矩阵乘; U/ i- m8 e8 e( i* a# z; n: W

{ 
% o: C; p7 M% o* g$ G( R$ x
                        for(j=0; j<k; j++) 
& ^2 a\\" s% c5 z, P0 l
                        { 
: i* \1 q; o\\" P3 v% a, l0 N- r
                                u=i*k+j; pc[u]=0.0;! b; P\\" f9 }2 B. `& p4 m

for (v=0; v<n; v++): r4 r! k& t. M8 x

{4 N. Q' `8 n% r; r( h1 h% o, o+ R

pc[u]=pc[u]+pa[i*n+v]*pb[v*k+j]; 
* X) H( @9 E( s
                                } 
, f! m! ^\\" P& n6 R6 g, v# O1 q! d
                        } 
. q1 Q$ e9 {' O( g
                }& {/ w0 x  \; ]* z6 D, a\\" o! g

FunReObj(hFor);        //告诉Lu，返回一个动态对象 
/ K: \/ ]6 Z! T& X, R) I
                a.BType=Matrix; a.VType=Matrix; a.x=0; *(luVOID *)&(a.x)=(luVOID)pMatrix3;) w8 }( c\\" b1 K3 r5 G* X

break; 
8 s$ A: s! B! P, A  Q* d
        case 25:        //重载运算符.*- U* `\\" J: m) E! a3 ?2 q; K* _8 B

pMatrix1=(myMatrix *)SearchKey((char *)&(xx->x),sizeof(luVOID),Matrix); 
  I7 j; L& {. f; A2 z( Q: F
                pMatrix2=(myMatrix *)SearchKey((char *)&((xx+1)->x),sizeof(luVOID),Matrix);% q' P5 M3 C; ^( W- Z; v\\" C  `

if(!pMatrix1 || !pMatrix2) break;        //对象句柄无效，不是矩阵. |4 q7 d- n$ P2 Q5 C; h% x; e\\" |

if(pMatrix1->Dim[0]!=pMatrix2->Dim[0] || pMatrix1->Dim[1]!=pMatrix2->Dim[1]) break;        //维数不相同 
! n5 U/ w4 [: @0 o. t; w
                pMatrix3=NewMatrix(pMatrix1->Dim[0],pMatrix1->Dim[1]);        //生成新矩阵 
6 i- Y& [3 }' z, W) o
                if(!pMatrix3) break;$ s# z  X, J) E5 f+ R3 x( M+ K1 C6 ~7 K

for(i=0;i<pMatrix1->ArrayLen;i++) pMatrix3->Array[i]=pMatrix1->Array[i]*pMatrix2->Array[i];        //矩阵点乘 
\\" {' m1 A7 M! i7 f\\" _) A
                FunReObj(hFor);        //告诉Lu，返回一个动态对象 
+ S6 C* G2 X: A' h
                a.BType=Matrix; a.VType=Matrix; a.x=0; *(luVOID *)&(a.x)=(luVOID)pMatrix3;* t; O4 t( C  C1 g

break; 
0 i. H7 p4 E8 G# p8 i/ E
        case 46:        //重载函数new 
$ ^4 g. u* A& z, `
                if(mm<2) break; 
( f; ~2 D- z9 V6 `  I8 a8 V$ I$ S
                if((xx+1)->x<1 || (xx+2)->x<1 || (xx+1)->BType!=luStaData_int64 || (xx+2)->BType!=luStaData_int64) break;\\" p2 b9 Y+ k) O0 h

pMatrix3=NewMatrix((luVOID)(xx+1)->x,(luVOID)(xx+2)->x);//生成新矩阵0 w  _) ^5 [4 b  D! I; ?8 L

if(!pMatrix3) break; 
( k9 n' t$ n  C  K3 u
                for(j=0,i=3;i<=mm;i++,j++)        //赋初值 
+ P& H. G) A( J- `6 r# M: R
                { 
! i& V5 F/ e2 A, H3 r
                        if(j>=pMatrix3->ArrayLen) break;# d0 [( J* N$ n7 L0 h) h$ ?1 b  D

if((xx+i)->BType!=luStaData_double) break;        //只接受实数参数\\" H4 D3 F5 l0 x9 H3 u! ?9 p

pMatrix3->Array[j]=*(double *)&((xx+i)->x);; r8 W' M8 x, y\\" u/ [\\" h3 B: Q

} 
2 ]0 }; j  n+ u\\" l
                FunReObj(hFor);        //告诉Lu，返回一个动态对象% Q9 N' L3 |% T* M+ A( n2 d* T

a.BType=Matrix; a.VType=Matrix; a.x=0; *(luVOID *)&(a.x)=(luVOID)pMatrix3;8 t! W; y8 _\\" l* B2 G3 X/ |

break; 
( m1 _' x: \5 R
        case 49:        //重载函数o. N9 q2 W\\" m+ g5 l- v6 n( G

pMessage=(luMessage)SearchKey("\0\0\0\0",sizeof(luVOID),luPubKey_User);7 K! s7 N# E2 X/ {/ P

if(!pMessage) break;+ b# E( c$ E+ [  h

pMatrix1=(myMatrix *)SearchKey((char *)&(xx->x),sizeof(luVOID),Matrix); 
+ ]5 w4 q0 {* f; A/ ?
                if(!pMatrix1) break;        //对象句柄无效，不是矩阵5 r' |; m( Q  r) W% ?' b6 V

pa=pMatrix1->Array;2 x& ]- C8 d% v: N& X

m=pMatrix1->Dim[0]; n=pMatrix1->Dim[1]; k=0; 
/ Z: \\\" q) V1 W. m
                for(i=0; i<m; i++)        //输出矩阵+ t  @3 a, [4 a$ B+ B- S8 |# M/ q

{ 
2 r  E( U, {/ L4 i
                        pMessage(L"\r\n"); k+=2; 
  ~\\" J: q$ j) W0 n# ]: w: q
                        for(j=0; j<n; j++) 
  j0 r( y; O9 b* J
                        {  }# g* w9 b! U, @# k, K* h; G

_gcvt_s(chNum,pa[i*n+j],16); 
# Q4 n; Q  P\\" X4 S. \6 k9 U# H
                                for(u=0;chNum[u];u++) {wchNum[u]=chNum[u]; k++;} 
# M3 @' Q; Z2 ]8 w\\" @$ X
                                wchNum[u]='\0';. Y' U3 S8 V. q1 U% i

pMessage(wchNum); pMessage(L"  "); k+=2;8 k7 p: ], O* o0 B) b: E

} 
/ H, z+ O, _: t) V/ c
                }0 Z, ~: J4 J: ?( d

pMessage(L"\r\n"); k+=2; 
! p% a3 g: A! |- h: D7 L
                a.BType=luStaData_int64; a.VType=luStaData_int64; a.x=k;        //按函数o的要求，返回输出的字符总数 
! y5 y# u% W- q. t# S4 |
                break;1 k) i4 |: c  a9 M

default:. M3 J% h5 {9 ~

break; 
& K: k+ g1 g6 j2 X/ L0 l( c
        }& G+ B9 I5 I: u) g\\" k

return a;5 n5 u/ m& C# @# A% T; J/ A1 |

}: @( F; R5 ]+ L; b2 z0 j

void main(void). y. @9 p, G$ M$ C7 `, }, F

{. |3 }9 _  u: S2 a  `/ X' K) ]8 i

void *hFor;                //表达式句柄  C; z9 W: D- `1 c/ [) ]  H# W: _

luINT nPara;                //存放表达式的自变量个数9 y' [+ \' @9 c

LuData *pPara;                //存放输入自变量的数组指针 
) T0 l( T/ h! I/ \% q6 K( m# {
        luINT ErrBegin,ErrEnd;        //表达式编译出错的初始位置和结束位置 
% s* I7 A2 W0 f% ^
        int ErrCode;                //错误代码 
! u* X3 l, J9 ]$ f! u& B2 q
        void *v; 
* T( v7 n7 Y8 F  g. T
        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.]}";//字符串表达式，矩阵乘 
8 C; {) X$ t\\" K
        //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.]}";//字符串表达式，矩阵点乘6 Q  ]' S3 e\\" H# j; ~& E- E

LuData Val; 
, }$ H5 I# N) J4 Q
        if(!InitLu()) return;        //初始化Lu 
' J& C. ^9 x; Y) r& y4 z
        while(LockKey(Matrix,DelMatrix,OpMatrix)){Matrix--;}        //锁定一个键，用于存储矩阵扩展类型 
7 {! l( Y+ u( R/ x
. N2 T2 g$ s% `3 ^& [

Val.BType=luStaData_int64; Val.VType=luStaData_int64; Val.x=Matrix;        //定义整数常量 
7 a3 ]' I2 C# N0 u5 A6 {# g
        SetConst(L"matrix",&Val);        //设置整数常量 
; y\\" d/ ]7 ~# p$ j- _4 R/ u! N: r1 j
        InsertKey("\0\0\0\0",4,luPubKey_User,LuMessage,NULL,NULL,1,v); //使Lu运行时可输出函数信息 
  Y) A\\" _1 |) m$ ?  ]5 [/ j
        wcout.imbue(locale("chs"));        //设置输出的locale为中文 
; _2 T( V6 X. a5 d7 ~, x
  # H( h/ l; Z* R- B; ^

ErrCode=LuCom(ForStr,0,0,0,hFor,nPara,pPara,ErrBegin,ErrEnd); //编译表达式 
; x# \/ e\\" a! T1 Y4 F
        if(ErrCode)  o% `# o# Z4 l

{ 
, w) @0 G$ |* j. J1 n& Z
                wcout<<L"表达式有错误！错误代码："<<ErrCode<<endl; 
6 n' N  S# M( m) z! q9 |
        } 
! E5 v& ~) X+ ?$ b( r
        else- N+ p) b& A  [4 y0 k

{ 
( }! x# f) X) @4 v  U4 K7 ?
                LuCal(hFor,pPara);        //计算表达式的值$ @& K\\" R% Z' D0 g% Y5 _8 w

}4 o) j7 _. E+ L- n8 l; Q7 k

LockKey(Matrix,NULL,OpMatrix);//解锁键Matrix，本例中，该函数可以不用% b0 e6 l: C) q$ A9 o

FreeLu();                        //释放Lu 
9 W5 o, i. \2 A3 m) C$ |
}

习题：

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

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

main(:a,b,c,d,t,i)=
6 a: B5 A, z2 t) L+ ~& \
a=new[matrix,2,2: 1.,2.,2.,1.],
; f) _8 U) Q1 j+ Y, U
b=new[matrix,2,2: 2.,1.,1.,2.], }* o5 h. l* b. W0 Y: v
c=new[matrix,2,2: 2/3.,-1/3.,-1/3.,2/3.],- B9 \5 c) m) x2 p1 }# P/ ?4 `- b
t=clock(),9 K9 i9 @ L7 J' C/ F4 x) x
d=a*b, i=0, while{i<1000000, d=d*c*b, i++},
$ R- G# N: a0 |9 B4 V, d
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\"}";//字符串表达式

复制代码

结果：