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

查看: 8486|回复: 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>
0 V& H\\" n3 d0 M& N X( j
#include <iostream>% u# `) {7 {' Z\\" B- m8 h* j
#include <math.h>. d1 R) p _# H: R
#include "lu32.h"3 [7 J0 |# W6 D3 n: V$ I: s- N) @
#pragma comment( lib, "lu32.lib" )
8 r, l' }& a$ ?- _! a/ x
using namespace std;$ K; \: x/ M. }$ W$ h
//自定义矩阵
' ?2 q+ u, ~% p! E+ x2 h
class myMatrix: v+ j0 x0 h9 \ {; Z
{6 h. z% ^$ g, {8 N
public:
7 _ I) q4 n% }! y z\\" C# R, w
double *Array; //数据缓冲区9 M7 G/ l/ q\\" {\\" C1 U
luVOID ArrayLen; //数据缓冲区长度
+ e+ T3 R4 g# X5 L; N* S
luVOID Dim[2]; //矩阵维数
# O3 }/ L7 P1 ~# S0 H2 d
myMatrix(){Array=NULL; ArrayLen=0; Dim[0]=0; Dim[1]=0;}
. f) N& S% J4 Q' W
~myMatrix()2 |$ g& g+ o\\" L
{( N! g9 {# C2 h4 e6 ?8 g
if(Array) delete[] Array;, s4 \) G; q7 W. [& o
}/ `3 \) a2 n3 S/ \' b( D. P+ Q4 s5 `
};# ]# q5 v& a) [
luKEY Matrix=-1000; //标识矩阵类型，最终的Matrix由LockKey决定
2 U, @, R- @( V: x6 L4 m/ c
void _stdcall LuMessage(wchar_t *pch)//输出动态库信息，该函数注册到Lu，由Lu二级函数调用 }: f; T$ ?& [
{
* {& s8 `) u5 \9 Q& p
wcout<<pch;
; p! b! _: T! p3 C
}
- D1 {* Y; F5 D0 G1 D0 k D\\" S
void _stdcall DelMatrix(void *me) //用于LockKey函数及InsertKey函数，使Lu能自动销毁myMatrix对象: `' f! d6 a/ t2 l5 o6 `
{\\" l) ~$ }& ?2 R* N8 t& a
delete (myMatrix *)me;/ l/ G2 E( j9 m( ~\\" V5 R
}, J( e6 {8 w) g* h- L+ y
myMatrix * _stdcall NewMatrix(luVOID m,luVOID n) //生成一个myMatrix对象1 ?2 G$ ]$ n. j8 b/ I2 Y, ~; l
{' B: t! F9 O( Y) v+ a* d
myMatrix *pMatrix;
9 J0 A: @. A2 U0 Y( t$ i+ b4 ]
luVOID k;
& B. O5 i& S3 a
double *pa;, s1 w1 p\\" m- _0 C
char keyname[sizeof(luVOID)];. T- M- i5 e3 v7 r2 |. T
void *NowKey;
2 N8 u: T h1 e8 c. d1 h/ z
k=m*n;
* H/ l\\" f$ ?+ X+ k
pMatrix=(myMatrix *)GetBufObj(Matrix,keyname);//先尝试从缓冲区中获取一个矩阵对象8 s* g1 ?* _: J& k
if(pMatrix)! A# e+ X8 n5 [, y6 B
{\\" M4 y6 n f* U& m
if(pMatrix->ArrayLen!=k) //重置矩阵的大小
8 b: H, u5 o/ Y9 d\\" {) L2 \
{* I; c+ g7 X) q( O\\" ?5 c
pa=new double[k];
$ X2 z+ a0 A- y, o9 n# x
if(!pa). X# Q9 @\\" V6 B; ? Q
{( N: l- q7 ^% t* e8 E
DeleteKey(keyname,sizeof(luVOID),Matrix,DelMatrix,1); //将矩阵对象放回缓冲区, o; a, `1 @6 u2 e
return NULL;' c. N/ C/ T2 Q/ h( I
}
6 G4 I* ~* S4 {: ?
delete[] pMatrix->Array;+ q1 o5 {1 ^9 q& E( x( }4 I
pMatrix->Array=pa;
& D! [: O! I7 M1 n# o
}8 L9 @6 b9 C& b& P5 J\\" [
}, F9 ]- Q\\" ]5 u$ [$ @6 w* E' \
else5 ]$ K\\" i0 P$ {* q
{& a& o4 s$ S c6 H! t4 s1 l
pMatrix=new myMatrix; //创建矩阵对象; b0 S! Y* H+ c* d/ q' x
if(!pMatrix) return NULL;
& A# x& G+ g. N4 N- T5 ?4 d& l
pMatrix->Array=new double[k];5 w3 U1 v# c) |% A6 w c: T
if(!pMatrix->Array)
* x, P8 x# [* A4 ~
{2 ]* b6 R$ X: a' O& c- z' h
delete pMatrix;6 b7 B5 C8 m6 b7 y3 T3 t
return NULL;7 w8 j( R$ Q1 v
}
; H, w7 x\\" N w8 [6 I. |+ ?
if(InsertKey((char *)&pMatrix,-1,Matrix,pMatrix,DelMatrix,NULL,0,NowKey)) //将矩阵对象注册到Lu
1 h, Z$ w& a+ B- h
{9 a/ E5 U5 P2 M; {\\" b\\" I. W
delete pMatrix;
+ Y. H& Z$ u! y7 Y$ X
return NULL;; x9 n+ ?: _6 g' q! _9 l\\" `
}6 E2 V! \1 a4 Y; z- {! b
}4 h$ o- P+ f ^
pMatrix->ArrayLen=k; pMatrix->Dim[0]=m; pMatrix->Dim[1]=n;
- B. u) H- D! y E2 P
return pMatrix;- x: ]\\" k' A, I\\" r
}( e' k% ^; T0 [
LuData _stdcall OpMatrix(luINT mm,LuData *xx,void *hFor,int theOperator) //运算符重载函数，用于LockKey函数
- ^9 G# ?: a: [: {7 _
{4 B5 ]5 x% N6 N9 v! t! [* x7 H
LuData a;7 ^. |& I( o! B1 J5 J+ W6 h
myMatrix *pMatrix1,*pMatrix2,*pMatrix3;% k8 O, m. X) J) a
luVOID i,j,k,m,n,u,v;1 L. X8 L# c7 Q# t
double *pa,*pb,*pc;/ G- R$ B- b V; U& Y
luMessage pMessage;\\" J% X7 \% Z( b( g\\" }& J
wchar_t wchNum[32];
3 N( Y/ a5 z) @8 u\\" T% J& C' L
char chNum[32];$ A: k- r! n. o( f y: j& O* [0 U
a.BType=luStaData_nil; a.VType=luStaData_nil; a.x=0;
( p( C6 L$ x\\" j0 s, b
switch(theOperator); ]( \! X# U$ o# t9 K, s; m7 S2 b- u
{
. A6 I( a' S5 [+ n; G
case 2: //重载运算符*1 c0 O. M3 S* n- X8 r
pMatrix1=(myMatrix *)SearchKey((char *)&(xx->x),sizeof(luVOID),Matrix);7 E6 [! z* _+ a9 U; W; w+ j
pMatrix2=(myMatrix *)SearchKey((char *)&((xx+1)->x),sizeof(luVOID),Matrix);5 m, X\\" d( o# Q. @
if(!pMatrix1 || !pMatrix2) break; //对象句柄无效，不是矩阵# Q5 k- m! A) d
if(pMatrix1->Dim[1]!=pMatrix2->Dim[0]) break; //维数不匹配2 r8 u- J1 {: S0 y7 s* @: E
pMatrix3=NewMatrix(pMatrix1->Dim[0],pMatrix2->Dim[1]); //生成新矩阵' A* N, {, Z% v' }
if(!pMatrix3) break;( T, T1 } e; r/ f- S5 Q' r+ h$ d
pa=pMatrix1->Array; pb=pMatrix2->Array; pc=pMatrix3->Array;5 q5 _ f3 }/ |
m=pMatrix1->Dim[0]; n=pMatrix1->Dim[1]; k=pMatrix2->Dim[1];: I7 r; S& C- w4 q6 M
for(i=0; i<m; i++) //矩阵乘% I' O) a2 o3 o3 L
{
& Z$ I0 L8 M) k) T8 p
for(j=0; j<k; j++)
w% O3 ^6 ]- o0 g# |
{
, {* y- G% t! B: I+ t3 T
u=i*k+j; pc[u]=0.0;
2 G' e D) z( {; I! d1 V
for (v=0; v<n; v++)
2 s9 ~9 s3 u8 b; d0 R+ Y) Y
{
, C' _( [+ V/ [% o
pc[u]=pc[u]+pa[i*n+v]*pb[v*k+j];
}
. Z8 B/ N# c, H+ C2 A\\" X
}
}
5 B2 g4 u( C\\" U% x4 e9 c
FunReObj(hFor); //告诉Lu，返回一个动态对象% L2 V: }! O% F9 {+ X. ]
a.BType=Matrix; a.VType=Matrix; a.x=0; *(luVOID *)&(a.x)=(luVOID)pMatrix3;
! i+ @& L7 ^1 z
break;: {9 ]: s! Y/ H$ f
case 25: //重载运算符.*- l6 g5 T! g% l% s\\" B! A- j3 ]& q
pMatrix1=(myMatrix *)SearchKey((char *)&(xx->x),sizeof(luVOID),Matrix);# ]( H/ i! ^4 c( ~' B\\" ]4 v\\" `6 f
pMatrix2=(myMatrix *)SearchKey((char *)&((xx+1)->x),sizeof(luVOID),Matrix);2 M1 A7 x+ e. l A
if(!pMatrix1 || !pMatrix2) break; //对象句柄无效，不是矩阵% Y9 ^: l. R# A8 i
if(pMatrix1->Dim[0]!=pMatrix2->Dim[0] || pMatrix1->Dim[1]!=pMatrix2->Dim[1]) break; //维数不相同
; w' L# R\\" c# V# G
pMatrix3=NewMatrix(pMatrix1->Dim[0],pMatrix1->Dim[1]); //生成新矩阵
/ A5 I, {1 b5 H0 {$ r3 {
if(!pMatrix3) break;# R8 r* y4 `\\" }( b( k' x+ ~2 |2 D' g1 Z
for(i=0;i<pMatrix1->ArrayLen;i++) pMatrix3->Array[i]=pMatrix1->Array[i]*pMatrix2->Array[i]; //矩阵点乘
& ]9 a0 n p1 r\\" |+ u
FunReObj(hFor); //告诉Lu，返回一个动态对象3 {) c; Y- J9 T3 w
a.BType=Matrix; a.VType=Matrix; a.x=0; *(luVOID *)&(a.x)=(luVOID)pMatrix3;, j8 v; L0 h/ l: w: A' P4 j
break;
* K' a1 E# W1 i. s' D7 s
case 46: //重载函数new5 H2 f/ ^$ r5 ~
if(mm<2) break;9 s1 G\\" N; Q4 L
if((xx+1)->x<1 || (xx+2)->x<1 || (xx+1)->BType!=luStaData_int64 || (xx+2)->BType!=luStaData_int64) break;: _) s1 s2 s- o2 q
pMatrix3=NewMatrix((luVOID)(xx+1)->x,(luVOID)(xx+2)->x);//生成新矩阵
6 h+ q; [9 G- W/ U\\" {' ^6 W0 Z
if(!pMatrix3) break;5 a) a' v8 d- S5 h* c4 q) e
for(j=0,i=3;i<=mm;i++,j++) //赋初值
{# r+ v$ n/ `( p. o& U
if(j>=pMatrix3->ArrayLen) break;
5 ~& b+ B) I& Q. G, x
if((xx+i)->BType!=luStaData_double) break; //只接受实数参数 v2 e o) j- K2 V3 q
pMatrix3->Array[j]=*(double *)&((xx+i)->x);
; R5 C( ~9 i0 p& f
}- Y. ^9 L. u' k3 O& C
FunReObj(hFor); //告诉Lu，返回一个动态对象
; N0 j& P) y/ `3 u' B0 s* C! V
a.BType=Matrix; a.VType=Matrix; a.x=0; *(luVOID *)&(a.x)=(luVOID)pMatrix3;
% {7 h- L9 D- S8 X+ ^$ k# e: B
break;0 j+ W9 {/ k: _' E( \0 Q- V9 J
case 49: //重载函数o2 }0 V3 N% {2 k7 ~6 A
pMessage=(luMessage)SearchKey("\0\0\0\0",sizeof(luVOID),luPubKey_User); m8 u# h K. _5 N, p
if(!pMessage) break;
0 _5 l9 n3 V- v
pMatrix1=(myMatrix *)SearchKey((char *)&(xx->x),sizeof(luVOID),Matrix);7 Q9 l\\" m7 g* ]# t) N
if(!pMatrix1) break; //对象句柄无效，不是矩阵0 ^7 s4 K3 u+ |7 f* R5 E
pa=pMatrix1->Array;
R. Q% J8 S E5 R. n3 C
m=pMatrix1->Dim[0]; n=pMatrix1->Dim[1]; k=0;
' N5 r- S' q/ }7 Z) y
for(i=0; i<m; i++) //输出矩阵, F7 V) X- M. A. e. g7 h
{, V& w0 N1 g9 b. e
pMessage(L"\r\n"); k+=2;
2 q) D$ D1 O/ S1 K3 v3 s. Z
for(j=0; j<n; j++)
& e2 i' i; b6 {\\" e& Y Q4 F
{
# }! A; O+ u3 P$ L) `
_gcvt_s(chNum,pa[i*n+j],16);; e/ z* [4 R\\" [6 q9 i
for(u=0;chNum[u];u++) {wchNum[u]=chNum[u]; k++;}& F& X4 Y7 g' r
wchNum[u]='\0';5 H\\" H$ v4 @2 f( \
pMessage(wchNum); pMessage(L" "); k+=2;4 N' n0 z8 e: p+ _/ H
}+ q( E# h# [ K; E6 g8 Z! J0 T) c; h# `
}
0 v* Y& j* _. ]& {9 o$ _- O1 I) w
pMessage(L"\r\n"); k+=2;
$ ]) y5 l5 \% V8 x T; h6 d
a.BType=luStaData_int64; a.VType=luStaData_int64; a.x=k; //按函数o的要求，返回输出的字符总数
$ s& Q/ o+ P; r1 k; z+ R8 r$ J% B& q
break;7 r0 q% N7 z3 D# f- s3 F( D' A
default:4 Q' |& C2 ~# C\\" Z
break;
; X' [2 K: @( z
}1 K* k, d) z2 r0 U+ u
return a;% r% ]4 m4 t0 L. t* u8 o* p2 W
}5 b2 e3 t+ M# n) v: d* v2 a
void main(void)
; f1 u( `3 m' V\\" Y
{8 D' K4 L7 }- B( N
void *hFor; //表达式句柄
# P9 m* W: B( X, W E0 o9 F
luINT nPara; //存放表达式的自变量个数
& j6 ?& u/ p% y
LuData *pPara; //存放输入自变量的数组指针 Q/ I# R( n- n- [; n) P9 J
luINT ErrBegin,ErrEnd; //表达式编译出错的初始位置和结束位置
\\" g* U& @0 r- z
int ErrCode; //错误代码
& G5 }% Y- }8 f$ _/ M: e
void *v;
$ d1 y4 \ z9 f- k' w
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.]}";//字符串表达式，矩阵乘
# J7 K: P8 y1 ~; ~3 @/ 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 O8 g, i. w {+ N( B# ]( s
LuData Val;
% ]' I/ y' w! p, L3 T
if(!InitLu()) return; //初始化Lu5 ~7 n- H( x; ?$ |7 M
while(LockKey(Matrix,DelMatrix,OpMatrix)){Matrix--;} //锁定一个键，用于存储矩阵扩展类型
( ^; [0 q( f- U/ m1 t
1 |' Q: t, x: P8 c% x3 l Z
Val.BType=luStaData_int64; Val.VType=luStaData_int64; Val.x=Matrix; //定义整数常量( @! B\\" T! H0 s, R
SetConst(L"matrix",&Val); //设置整数常量
2 c5 `! r4 n9 ^7 c' z
InsertKey("\0\0\0\0",4,luPubKey_User,LuMessage,NULL,NULL,1,v); //使Lu运行时可输出函数信息
, P8 S& h: q8 f3 g
wcout.imbue(locale("chs")); //设置输出的locale为中文' r1 d: j! O b* A# u1 B. q
8 Z) h& ~# N9 w2 q; _! D: X
ErrCode=LuCom(ForStr,0,0,0,hFor,nPara,pPara,ErrBegin,ErrEnd); //编译表达式
- k* p) a* o- y\\" Q) r
if(ErrCode)! @0 i4 Y* F2 U/ b. r
{
: p/ q; S3 X* @
wcout<<L"表达式有错误！错误代码："<<ErrCode<<endl;
% G2 c3 F% ]0 Y% V2 t
}
. g, b; s+ H) z; W% S$ H1 u5 e/ n
else
& f k7 h! Q' I0 E9 S
{8 m1 w2 w/ q y
LuCal(hFor,pPara); //计算表达式的值( n* g+ q: w4 V
}3 ~+ N# a9 J# R t
LockKey(Matrix,NULL,OpMatrix);//解锁键Matrix，本例中，该函数可以不用( J( X2 a5 s( C1 b( D O$ | u s
FreeLu(); //释放Lu
# D& G k: f% s L
}

#include <windows.h> 
0 V& H\\" n3 d0 M& N  X( j
#include <iostream>% u# `) {7 {' Z\\" B- m8 h* j

#include <math.h>. d1 R) p  _# H: R

#include "lu32.h"3 [7 J0 |# W6 D3 n: V$ I: s- N) @

#pragma comment( lib, "lu32.lib" ) 
8 r, l' }& a$ ?- _! a/ x
using namespace std;$ K; \: x/ M. }$ W$ h

//自定义矩阵 
' ?2 q+ u, ~% p! E+ x2 h
class myMatrix: v+ j0 x0 h9 \  {; Z

{6 h. z% ^$ g, {8 N

public: 
7 _  I) q4 n% }! y  z\\" C# R, w
        double *Array;        //数据缓冲区9 M7 G/ l/ q\\" {\\" C1 U

luVOID ArrayLen;        //数据缓冲区长度 
+ e+ T3 R4 g# X5 L; N* S
        luVOID Dim[2];        //矩阵维数 
# O3 }/ L7 P1 ~# S0 H2 d
        myMatrix(){Array=NULL; ArrayLen=0; Dim[0]=0; Dim[1]=0;} 
. f) N& S% J4 Q' W
        ~myMatrix()2 |$ g& g+ o\\" L

{( N! g9 {# C2 h4 e6 ?8 g

if(Array) delete[] Array;, s4 \) G; q7 W. [& o

}/ `3 \) a2 n3 S/ \' b( D. P+ Q4 s5 `

};# ]# q5 v& a) [

luKEY Matrix=-1000;        //标识矩阵类型，最终的Matrix由LockKey决定 
2 U, @, R- @( V: x6 L4 m/ c
void _stdcall LuMessage(wchar_t *pch)//输出动态库信息，该函数注册到Lu，由Lu二级函数调用   }: f; T$ ?& [

{ 
* {& s8 `) u5 \9 Q& p
        wcout<<pch; 
; p! b! _: T! p3 C
} 
- D1 {* Y; F5 D0 G1 D0 k  D\\" S
void _stdcall DelMatrix(void *me)        //用于LockKey函数及InsertKey函数，使Lu能自动销毁myMatrix对象: `' f! d6 a/ t2 l5 o6 `

{\\" l) ~$ }& ?2 R* N8 t& a

delete (myMatrix *)me;/ l/ G2 E( j9 m( ~\\" V5 R

}, J( e6 {8 w) g* h- L+ y

myMatrix * _stdcall NewMatrix(luVOID m,luVOID n)        //生成一个myMatrix对象1 ?2 G$ ]$ n. j8 b/ I2 Y, ~; l

{' B: t! F9 O( Y) v+ a* d

myMatrix *pMatrix; 
9 J0 A: @. A2 U0 Y( t$ i+ b4 ]
        luVOID k; 
& B. O5 i& S3 a
        double *pa;, s1 w1 p\\" m- _0 C

char keyname[sizeof(luVOID)];. T- M- i5 e3 v7 r2 |. T

void *NowKey; 
2 N8 u: T  h1 e8 c. d1 h/ z
        k=m*n; 
* H/ l\\" f$ ?+ X+ k
        pMatrix=(myMatrix *)GetBufObj(Matrix,keyname);//先尝试从缓冲区中获取一个矩阵对象8 s* g1 ?* _: J& k

if(pMatrix)! A# e+ X8 n5 [, y6 B

{\\" M4 y6 n  f* U& m

if(pMatrix->ArrayLen!=k)        //重置矩阵的大小 
8 b: H, u5 o/ Y9 d\\" {) L2 \
                {* I; c+ g7 X) q( O\\" ?5 c

pa=new double[k]; 
$ X2 z+ a0 A- y, o9 n# x
                        if(!pa). X# Q9 @\\" V6 B; ?  Q

{( N: l- q7 ^% t* e8 E

DeleteKey(keyname,sizeof(luVOID),Matrix,DelMatrix,1);        //将矩阵对象放回缓冲区, o; a, `1 @6 u2 e

return NULL;' c. N/ C/ T2 Q/ h( I

} 
6 G4 I* ~* S4 {: ?
                        delete[] pMatrix->Array;+ q1 o5 {1 ^9 q& E( x( }4 I

pMatrix->Array=pa; 
& D! [: O! I7 M1 n# o
                }8 L9 @6 b9 C& b& P5 J\\" [

}, F9 ]- Q\\" ]5 u$ [$ @6 w* E' \

else5 ]$ K\\" i0 P$ {* q

{& a& o4 s$ S  c6 H! t4 s1 l

pMatrix=new myMatrix;        //创建矩阵对象; b0 S! Y* H+ c* d/ q' x

if(!pMatrix) return NULL; 
& A# x& G+ g. N4 N- T5 ?4 d& l
                pMatrix->Array=new double[k];5 w3 U1 v# c) |% A6 w  c: T

if(!pMatrix->Array) 
* x, P8 x# [* A4 ~
                {2 ]* b6 R$ X: a' O& c- z' h

delete pMatrix;6 b7 B5 C8 m6 b7 y3 T3 t

return NULL;7 w8 j( R$ Q1 v

} 
; H, w7 x\\" N  w8 [6 I. |+ ?
                if(InsertKey((char *)&pMatrix,-1,Matrix,pMatrix,DelMatrix,NULL,0,NowKey))        //将矩阵对象注册到Lu 
1 h, Z$ w& a+ B- h
                {9 a/ E5 U5 P2 M; {\\" b\\" I. W

delete pMatrix; 
+ Y. H& Z$ u! y7 Y$ X
                        return NULL;; x9 n+ ?: _6 g' q! _9 l\\" `

}6 E2 V! \1 a4 Y; z- {! b

}4 h$ o- P+ f  ^

pMatrix->ArrayLen=k; pMatrix->Dim[0]=m; pMatrix->Dim[1]=n; 
- B. u) H- D! y  E2 P
        return pMatrix;- x: ]\\" k' A, I\\" r

}( e' k% ^; T0 [

LuData _stdcall OpMatrix(luINT mm,LuData *xx,void *hFor,int theOperator)        //运算符重载函数，用于LockKey函数 
- ^9 G# ?: a: [: {7 _
{4 B5 ]5 x% N6 N9 v! t! [* x7 H

LuData a;7 ^. |& I( o! B1 J5 J+ W6 h

myMatrix *pMatrix1,*pMatrix2,*pMatrix3;% k8 O, m. X) J) a

luVOID i,j,k,m,n,u,v;1 L. X8 L# c7 Q# t

double *pa,*pb,*pc;/ G- R$ B- b  V; U& Y

luMessage pMessage;\\" J% X7 \% Z( b( g\\" }& J

wchar_t wchNum[32]; 
3 N( Y/ a5 z) @8 u\\" T% J& C' L
        char chNum[32];$ A: k- r! n. o( f  y: j& O* [0 U

a.BType=luStaData_nil; a.VType=luStaData_nil; a.x=0; 
( p( C6 L$ x\\" j0 s, b
        switch(theOperator); ]( \! X# U$ o# t9 K, s; m7 S2 b- u

{ 
. A6 I( a' S5 [+ n; G
        case 2:        //重载运算符*1 c0 O. M3 S* n- X8 r

pMatrix1=(myMatrix *)SearchKey((char *)&(xx->x),sizeof(luVOID),Matrix);7 E6 [! z* _+ a9 U; W; w+ j

pMatrix2=(myMatrix *)SearchKey((char *)&((xx+1)->x),sizeof(luVOID),Matrix);5 m, X\\" d( o# Q. @

if(!pMatrix1 || !pMatrix2) break;        //对象句柄无效，不是矩阵# Q5 k- m! A) d

if(pMatrix1->Dim[1]!=pMatrix2->Dim[0]) break;        //维数不匹配2 r8 u- J1 {: S0 y7 s* @: E

pMatrix3=NewMatrix(pMatrix1->Dim[0],pMatrix2->Dim[1]);        //生成新矩阵' A* N, {, Z% v' }

if(!pMatrix3) break;( T, T1 }  e; r/ f- S5 Q' r+ h$ d

pa=pMatrix1->Array; pb=pMatrix2->Array; pc=pMatrix3->Array;5 q5 _  f3 }/ |

m=pMatrix1->Dim[0]; n=pMatrix1->Dim[1]; k=pMatrix2->Dim[1];: I7 r; S& C- w4 q6 M

for(i=0; i<m; i++)        //矩阵乘% I' O) a2 o3 o3 L

{ 
& Z$ I0 L8 M) k) T8 p
                        for(j=0; j<k; j++) 
  w% O3 ^6 ]- o0 g# |
                        { 
, {* y- G% t! B: I+ t3 T
                                u=i*k+j; pc[u]=0.0; 
2 G' e  D) z( {; I! d1 V
                                for (v=0; v<n; v++) 
2 s9 ~9 s3 u8 b; d0 R+ Y) Y
                                { 
, C' _( [+ V/ [% o
                                        pc[u]=pc[u]+pa[i*n+v]*pb[v*k+j]; 
! D/ L\\" T\\" W8 ]. H\\" ?! a8 s- z9 F6 q
                                } 
. Z8 B/ N# c, H+ C2 A\\" X
                        } 
6 [, Q. [5 j. d) ~+ u  q1 p' e( v9 z( }
                } 
5 B2 g4 u( C\\" U% x4 e9 c
                FunReObj(hFor);        //告诉Lu，返回一个动态对象% L2 V: }! O% F9 {+ X. ]

a.BType=Matrix; a.VType=Matrix; a.x=0; *(luVOID *)&(a.x)=(luVOID)pMatrix3; 
! i+ @& L7 ^1 z
                break;: {9 ]: s! Y/ H$ f

case 25:        //重载运算符.*- l6 g5 T! g% l% s\\" B! A- j3 ]& q

pMatrix1=(myMatrix *)SearchKey((char *)&(xx->x),sizeof(luVOID),Matrix);# ]( H/ i! ^4 c( ~' B\\" ]4 v\\" `6 f

pMatrix2=(myMatrix *)SearchKey((char *)&((xx+1)->x),sizeof(luVOID),Matrix);2 M1 A7 x+ e. l  A

if(!pMatrix1 || !pMatrix2) break;        //对象句柄无效，不是矩阵% Y9 ^: l. R# A8 i

if(pMatrix1->Dim[0]!=pMatrix2->Dim[0] || pMatrix1->Dim[1]!=pMatrix2->Dim[1]) break;        //维数不相同 
; w' L# R\\" c# V# G
                pMatrix3=NewMatrix(pMatrix1->Dim[0],pMatrix1->Dim[1]);        //生成新矩阵 
/ A5 I, {1 b5 H0 {$ r3 {
                if(!pMatrix3) break;# R8 r* y4 `\\" }( b( k' x+ ~2 |2 D' g1 Z

for(i=0;i<pMatrix1->ArrayLen;i++) pMatrix3->Array[i]=pMatrix1->Array[i]*pMatrix2->Array[i];        //矩阵点乘 
& ]9 a0 n  p1 r\\" |+ u
                FunReObj(hFor);        //告诉Lu，返回一个动态对象3 {) c; Y- J9 T3 w

a.BType=Matrix; a.VType=Matrix; a.x=0; *(luVOID *)&(a.x)=(luVOID)pMatrix3;, j8 v; L0 h/ l: w: A' P4 j

break; 
* K' a1 E# W1 i. s' D7 s
        case 46:        //重载函数new5 H2 f/ ^$ r5 ~

if(mm<2) break;9 s1 G\\" N; Q4 L

if((xx+1)->x<1 || (xx+2)->x<1 || (xx+1)->BType!=luStaData_int64 || (xx+2)->BType!=luStaData_int64) break;: _) s1 s2 s- o2 q

pMatrix3=NewMatrix((luVOID)(xx+1)->x,(luVOID)(xx+2)->x);//生成新矩阵 
6 h+ q; [9 G- W/ U\\" {' ^6 W0 Z
                if(!pMatrix3) break;5 a) a' v8 d- S5 h* c4 q) e

for(j=0,i=3;i<=mm;i++,j++)        //赋初值 
% A8 t5 ~3 R/ P. ]5 X3 c) D+ l' Q\\" ^; w# D
                {# r+ v$ n/ `( p. o& U

if(j>=pMatrix3->ArrayLen) break; 
5 ~& b+ B) I& Q. G, x
                        if((xx+i)->BType!=luStaData_double) break;        //只接受实数参数  v2 e  o) j- K2 V3 q

pMatrix3->Array[j]=*(double *)&((xx+i)->x); 
; R5 C( ~9 i0 p& f
                }- Y. ^9 L. u' k3 O& C

FunReObj(hFor);        //告诉Lu，返回一个动态对象 
; N0 j& P) y/ `3 u' B0 s* C! V
                a.BType=Matrix; a.VType=Matrix; a.x=0; *(luVOID *)&(a.x)=(luVOID)pMatrix3; 
% {7 h- L9 D- S8 X+ ^$ k# e: B
                break;0 j+ W9 {/ k: _' E( \0 Q- V9 J

case 49:        //重载函数o2 }0 V3 N% {2 k7 ~6 A

pMessage=(luMessage)SearchKey("\0\0\0\0",sizeof(luVOID),luPubKey_User);  m8 u# h  K. _5 N, p

if(!pMessage) break; 
0 _5 l9 n3 V- v
                pMatrix1=(myMatrix *)SearchKey((char *)&(xx->x),sizeof(luVOID),Matrix);7 Q9 l\\" m7 g* ]# t) N

if(!pMatrix1) break;        //对象句柄无效，不是矩阵0 ^7 s4 K3 u+ |7 f* R5 E

pa=pMatrix1->Array; 
  R. Q% J8 S  E5 R. n3 C
                m=pMatrix1->Dim[0]; n=pMatrix1->Dim[1]; k=0; 
' N5 r- S' q/ }7 Z) y
                for(i=0; i<m; i++)        //输出矩阵, F7 V) X- M. A. e. g7 h

{, V& w0 N1 g9 b. e

pMessage(L"\r\n"); k+=2; 
2 q) D$ D1 O/ S1 K3 v3 s. Z
                        for(j=0; j<n; j++) 
& e2 i' i; b6 {\\" e& Y  Q4 F
                        { 
# }! A; O+ u3 P$ L) `
                                _gcvt_s(chNum,pa[i*n+j],16);; e/ z* [4 R\\" [6 q9 i

for(u=0;chNum[u];u++) {wchNum[u]=chNum[u]; k++;}& F& X4 Y7 g' r

wchNum[u]='\0';5 H\\" H$ v4 @2 f( \

pMessage(wchNum); pMessage(L"  "); k+=2;4 N' n0 z8 e: p+ _/ H

}+ q( E# h# [  K; E6 g8 Z! J0 T) c; h# `

} 
0 v* Y& j* _. ]& {9 o$ _- O1 I) w
                pMessage(L"\r\n"); k+=2; 
$ ]) y5 l5 \% V8 x  T; h6 d
                a.BType=luStaData_int64; a.VType=luStaData_int64; a.x=k;        //按函数o的要求，返回输出的字符总数 
$ s& Q/ o+ P; r1 k; z+ R8 r$ J% B& q
                break;7 r0 q% N7 z3 D# f- s3 F( D' A

default:4 Q' |& C2 ~# C\\" Z

break; 
; X' [2 K: @( z
        }1 K* k, d) z2 r0 U+ u

return a;% r% ]4 m4 t0 L. t* u8 o* p2 W

}5 b2 e3 t+ M# n) v: d* v2 a

void main(void) 
; f1 u( `3 m' V\\" Y
{8 D' K4 L7 }- B( N

void *hFor;                //表达式句柄 
# P9 m* W: B( X, W  E0 o9 F
        luINT nPara;                //存放表达式的自变量个数 
& j6 ?& u/ p% y
        LuData *pPara;                //存放输入自变量的数组指针  Q/ I# R( n- n- [; n) P9 J

luINT ErrBegin,ErrEnd;        //表达式编译出错的初始位置和结束位置 
\\" g* U& @0 r- z
        int ErrCode;                //错误代码 
& G5 }% Y- }8 f$ _/ M: e
        void *v; 
$ d1 y4 \  z9 f- k' w
        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.]}";//字符串表达式，矩阵乘 
# J7 K: P8 y1 ~; ~3 @/ 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 O8 g, i. w  {+ N( B# ]( s

LuData Val; 
% ]' I/ y' w! p, L3 T
        if(!InitLu()) return;        //初始化Lu5 ~7 n- H( x; ?$ |7 M

while(LockKey(Matrix,DelMatrix,OpMatrix)){Matrix--;}        //锁定一个键，用于存储矩阵扩展类型 
( ^; [0 q( f- U/ m1 t
 
1 |' Q: t, x: P8 c% x3 l  Z
        Val.BType=luStaData_int64; Val.VType=luStaData_int64; Val.x=Matrix;        //定义整数常量( @! B\\" T! H0 s, R

SetConst(L"matrix",&Val);        //设置整数常量 
2 c5 `! r4 n9 ^7 c' z
        InsertKey("\0\0\0\0",4,luPubKey_User,LuMessage,NULL,NULL,1,v); //使Lu运行时可输出函数信息 
, P8 S& h: q8 f3 g
        wcout.imbue(locale("chs"));        //设置输出的locale为中文' r1 d: j! O  b* A# u1 B. q

8 Z) h& ~# N9 w2 q; _! D: X

ErrCode=LuCom(ForStr,0,0,0,hFor,nPara,pPara,ErrBegin,ErrEnd); //编译表达式 
- k* p) a* o- y\\" Q) r
        if(ErrCode)! @0 i4 Y* F2 U/ b. r

{ 
: p/ q; S3 X* @
                wcout<<L"表达式有错误！错误代码："<<ErrCode<<endl; 
% G2 c3 F% ]0 Y% V2 t
        } 
. g, b; s+ H) z; W% S$ H1 u5 e/ n
        else 
& f  k7 h! Q' I0 E9 S
        {8 m1 w2 w/ q  y

LuCal(hFor,pPara);        //计算表达式的值( n* g+ q: w4 V

}3 ~+ N# a9 J# R  t

LockKey(Matrix,NULL,OpMatrix);//解锁键Matrix，本例中，该函数可以不用( J( X2 a5 s( C1 b( D  O$ |  u  s

FreeLu();                        //释放Lu 
# D& G  k: f% s  L
}

习题：

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

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

main(:a,b,c,d,t,i)=! b5 ^2 b& d0 @' A6 I; H1 X
a=new[matrix,2,2: 1.,2.,2.,1.],
( l\" F$ w& q, \# _/ J
b=new[matrix,2,2: 2.,1.,1.,2.],0 |3 j' ]2 d\" w* s
c=new[matrix,2,2: 2/3.,-1/3.,-1/3.,2/3.],
2 @! D( h8 y2 e9 T5 w$ d5 N2 ?; V
t=clock(),\" ~9 V0 P3 |3 j. o+ J% r: {
d=a*b, i=0, while{i<1000000, d=d*c*b, i++},* i# h( D5 H8 w0 v% `; R
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\"}";//字符串表达式

复制代码

结果：