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

查看: 7782|回复: 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>
3 N, L) x5 L; ^4 ^: Y n; g
#include <iostream>
! z' G+ Q7 Y7 B
#include <math.h>' e H/ V2 ^' T+ F\\" z4 R+ V
#include "lu32.h"
1 a% E8 N: I+ M h- H: k- c
#pragma comment( lib, "lu32.lib" )
2 \' R; c3 {8 y5 h& Y4 f& B\\" p
using namespace std;0 E9 \% Z) i6 o
//自定义矩阵
! Q( T+ V% J* S& N
class myMatrix; z3 F6 j- x9 P8 `, J
{3 p3 J! \) y% H0 ^
public:
/ B) B' d* s1 O' h3 F* c- ^
double *Array; //数据缓冲区! j' W2 O\\" l( `+ u' l6 T
luVOID ArrayLen; //数据缓冲区长度6 W9 N! o5 g( i |- J
luVOID Dim[2]; //矩阵维数
x\\" z8 R( K' U9 a
myMatrix(){Array=NULL; ArrayLen=0; Dim[0]=0; Dim[1]=0;}
~myMatrix()
) L* {$ T! h\\" `2 W7 t5 x' |( o
{
8 _' D; h5 U\\" T
if(Array) delete[] Array;
8 {) r/ r* d( D6 [+ U
}1 a\\" f/ N- N( d( J7 Y& K& h
};: y: D$ u, T2 H( b9 ?
luKEY Matrix=-1000; //标识矩阵类型，最终的Matrix由LockKey决定
1 X0 k8 j6 w T9 q6 `8 T
void _stdcall LuMessage(wchar_t *pch)//输出动态库信息，该函数注册到Lu，由Lu二级函数调用
, h9 X( e! W2 k: j
{! L- B\\" M! A9 N/ U; c' n
wcout<<pch;- \4 I# h4 Q- t) M# @# ]+ p
}
! L' _\\" P; Y9 G/ h) X7 `* n! d
void _stdcall DelMatrix(void *me) //用于LockKey函数及InsertKey函数，使Lu能自动销毁myMatrix对象
& }9 v7 `9 o/ v9 V' C3 r# v
{7 j% x' {8 P y; E& T
delete (myMatrix *)me;4 D; }! `0 I, T% C) s; T
}
8 @% [\\" {0 ^* g; T/ X4 N
myMatrix * _stdcall NewMatrix(luVOID m,luVOID n) //生成一个myMatrix对象
! S5 L1 m& R0 h# ]# Q! q
{9 z, B) D2 C4 M0 Y7 r
myMatrix *pMatrix;' \4 `# t! A# n\\" q\\" N4 Y6 p
luVOID k;3 E2 o) R: L) q) G
double *pa;
! U1 H. c- `& c: g1 c
char keyname[sizeof(luVOID)];( R2 a! I! \- q! G! G) h
void *NowKey;# o* B- q2 ~; c$ _) K
k=m*n;
* S\\" m$ p; O9 Z; o( ]; M
pMatrix=(myMatrix *)GetBufObj(Matrix,keyname);//先尝试从缓冲区中获取一个矩阵对象. `* e6 h3 ^7 p6 }* |
if(pMatrix)
: a9 P, z T, u$ P' U `
{* k4 r9 e* d7 X2 c& A( r
if(pMatrix->ArrayLen!=k) //重置矩阵的大小; J8 b B2 a5 k+ o% o\\" _4 g! s
{
pa=new double[k];+ @+ r/ o2 O. }, P# c/ e
if(!pa)
0 i8 z: J7 F6 e& Y9 k
{+ |6 k# f L2 u
DeleteKey(keyname,sizeof(luVOID),Matrix,DelMatrix,1); //将矩阵对象放回缓冲区7 a3 O, @+ ?) P, p6 Q# z J
return NULL;
. q u( x# }; `5 Z3 c* S, y* R
}) e# x+ q) f8 O6 o& C# v
delete[] pMatrix->Array;
+ W9 x/ I& I% a
pMatrix->Array=pa;
2 u! g\\" d. j E* R3 @+ z, k3 x
}
/ K0 ?5 s1 y6 m% o
}
p; [, c$ `$ ]! N4 Y4 J# @
else( ^ @4 L; e\\" ^3 K$ @- @
{
\\" M\\" Y3 ?/ h# e) f0 F
pMatrix=new myMatrix; //创建矩阵对象5 i* n0 E\\" F& S3 X2 [4 }
if(!pMatrix) return NULL;
, v2 s) i$ _+ g' D
pMatrix->Array=new double[k];/ B. H: I! m9 N& _
if(!pMatrix->Array)
4 F1 J- B* ^4 }4 F\\" b) v8 [
{% g+ F5 m( r3 ~
delete pMatrix;
7 _7 A9 h% u\\" @\\" `
return NULL;
\\" i V3 _: f- P4 M3 U% l6 J8 ]& `
}0 I1 K+ A n$ r5 g
if(InsertKey((char *)&pMatrix,-1,Matrix,pMatrix,DelMatrix,NULL,0,NowKey)) //将矩阵对象注册到Lu0 W4 ~) D) H\\" g* P\\" V, b& X
{
; P9 e, F\\" H* Q, l0 T8 H
delete pMatrix;
) n- B/ u1 F% y0 R. V& u
return NULL;% f$ W2 h3 N9 r# f6 E( N3 |
}$ c3 Q/ _; z5 @1 B
}' t% o1 [: {\\" t% [% e, B
pMatrix->ArrayLen=k; pMatrix->Dim[0]=m; pMatrix->Dim[1]=n;0 H$ X5 Z. `8 |/ A
return pMatrix;
* Q* _5 y+ r- x# l+ U$ a
}6 n& o+ |5 r, s2 a* y
LuData _stdcall OpMatrix(luINT mm,LuData *xx,void *hFor,int theOperator) //运算符重载函数，用于LockKey函数$ {6 ^) g6 T\\" B* T# ?5 A
{
' f- @1 u% Z. Q |4 C4 t z
LuData a;
8 L) t+ {5 a8 A
myMatrix *pMatrix1,*pMatrix2,*pMatrix3;
& d0 T! j2 K: S
luVOID i,j,k,m,n,u,v;
2 J/ k s+ c* M, Z5 O
double *pa,*pb,*pc;2 ?! X8 t; s5 X* M) K* T
luMessage pMessage;3 C8 n\\" @/ h* M2 [\\" v9 p9 L: z5 t
wchar_t wchNum[32];
# N: M7 s7 z* K9 Q
char chNum[32];
1 U3 }0 ~9 d) s- x& s+ c
a.BType=luStaData_nil; a.VType=luStaData_nil; a.x=0;
! h) w! O8 D; i6 y% v' H
switch(theOperator)
) M& w' s3 k+ ~4 s9 N' a1 d X( `
{
' X7 w; ]' S+ h \) [
case 2: //重载运算符*
$ R! L+ H0 W\\" E, d* l
pMatrix1=(myMatrix *)SearchKey((char *)&(xx->x),sizeof(luVOID),Matrix);' L: m1 Y e\\" Z/ h) D7 V% x
pMatrix2=(myMatrix *)SearchKey((char *)&((xx+1)->x),sizeof(luVOID),Matrix);
v2 D r) \4 {1 g; c7 y( ~. s
if(!pMatrix1 || !pMatrix2) break; //对象句柄无效，不是矩阵
f. M2 e- S0 [1 l1 J0 y
if(pMatrix1->Dim[1]!=pMatrix2->Dim[0]) break; //维数不匹配
, ?. r2 ?/ c' V
pMatrix3=NewMatrix(pMatrix1->Dim[0],pMatrix2->Dim[1]); //生成新矩阵( @. p+ v4 x\\" c
if(!pMatrix3) break; ~: j9 j9 {' F7 t( }
pa=pMatrix1->Array; pb=pMatrix2->Array; pc=pMatrix3->Array;, t0 ]8 `: ]9 ^% ?7 ]( F- Y
m=pMatrix1->Dim[0]; n=pMatrix1->Dim[1]; k=pMatrix2->Dim[1];' Y\\" K6 D# ]% E0 B/ d\\" ?
for(i=0; i<m; i++) //矩阵乘
/ S. f0 a) \/ E1 h) c) K\\" |
{8 X7 ]/ W$ a- |& O( U& p5 L
for(j=0; j<k; j++) }/ P1 d0 e, K l( Z8 I
{+ q, D! v8 d2 U! B% }' s5 y\\" _
u=i*k+j; pc[u]=0.0;
x8 y7 i6 Q3 R0 J2 |7 L+ J
for (v=0; v<n; v++)4 P+ v+ T! b$ { M) U\\" P L/ _* u
{& B5 ~5 R6 F: E- |
pc[u]=pc[u]+pa[i*n+v]*pb[v*k+j];$ Z6 W6 C2 Z0 T5 p
}
7 `0 A6 P7 ~) U) G/ J4 y: ]9 E
}1 N5 w3 M, h. v2 ~
}
! ?2 f* D: o( ^) k8 q6 w8 Z
FunReObj(hFor); //告诉Lu，返回一个动态对象& q, @# D: \4 T/ |+ C
a.BType=Matrix; a.VType=Matrix; a.x=0; *(luVOID *)&(a.x)=(luVOID)pMatrix3;
$ D( y3 J J1 n& m! F
break;* }\\" Z+ w3 R' U, d7 g0 f
case 25: //重载运算符.*! Y6 ]* w, f3 x& V
pMatrix1=(myMatrix *)SearchKey((char *)&(xx->x),sizeof(luVOID),Matrix);2 d! T\\" S. E* d; V8 x# S
pMatrix2=(myMatrix *)SearchKey((char *)&((xx+1)->x),sizeof(luVOID),Matrix);
; P- Y( J/ ^% \* n3 a% M- E
if(!pMatrix1 || !pMatrix2) break; //对象句柄无效，不是矩阵5 E s3 U\\" d4 k4 s0 }! K) s. W( ~
if(pMatrix1->Dim[0]!=pMatrix2->Dim[0] || pMatrix1->Dim[1]!=pMatrix2->Dim[1]) break; //维数不相同
6 B5 P3 z- j( A/ ^8 W# \/ Y
pMatrix3=NewMatrix(pMatrix1->Dim[0],pMatrix1->Dim[1]); //生成新矩阵; t x1 W2 C3 e
if(!pMatrix3) break;' e\\" e3 K1 P' `' u
for(i=0;i<pMatrix1->ArrayLen;i++) pMatrix3->Array[i]=pMatrix1->Array[i]*pMatrix2->Array[i]; //矩阵点乘( J: E4 f* u4 A* R
FunReObj(hFor); //告诉Lu，返回一个动态对象
; Z: w( l* l: n p
a.BType=Matrix; a.VType=Matrix; a.x=0; *(luVOID *)&(a.x)=(luVOID)pMatrix3;; s3 s2 `$ R- i
break;
9 q7 t3 n# P3 \7 q0 l) O& n3 |/ j: v
case 46: //重载函数new
5 d8 P: Q4 w4 T4 g
if(mm<2) break;
3 j& V8 u/ A; L\\" s9 v) J6 @
if((xx+1)->x<1 || (xx+2)->x<1 || (xx+1)->BType!=luStaData_int64 || (xx+2)->BType!=luStaData_int64) break;
0 g* S/ d+ [9 N5 n- _; t9 ?% s
pMatrix3=NewMatrix((luVOID)(xx+1)->x,(luVOID)(xx+2)->x);//生成新矩阵\\" P+ f- v l* V
if(!pMatrix3) break;
3 z* h8 w4 R# m8 O3 C
for(j=0,i=3;i<=mm;i++,j++) //赋初值
2 w3 m3 g& j. a; K
{# W2 {9 w! }; w4 B7 h( x
if(j>=pMatrix3->ArrayLen) break;2 [ c' W\\" _/ S& }4 w
if((xx+i)->BType!=luStaData_double) break; //只接受实数参数8 _! |8 p6 }) F/ G, A; |
pMatrix3->Array[j]=*(double *)&((xx+i)->x);
7 u2 J& a* t& O+ z: E
}
. L4 D2 j6 T6 ]2 y
FunReObj(hFor); //告诉Lu，返回一个动态对象
7 p7 b C1 ~- \* r/ x\\" O# M; k
a.BType=Matrix; a.VType=Matrix; a.x=0; *(luVOID *)&(a.x)=(luVOID)pMatrix3;# O% [6 z9 O6 S4 Y
break;% t9 m7 a5 I O! v( ~1 L1 @
case 49: //重载函数o% I) O0 C: J9 Y* `
pMessage=(luMessage)SearchKey("\0\0\0\0",sizeof(luVOID),luPubKey_User);
4 z* ]( \% ] K
if(!pMessage) break;\\" n; n2 I# S$ m- Y0 \5 C$ n1 t
pMatrix1=(myMatrix *)SearchKey((char *)&(xx->x),sizeof(luVOID),Matrix);
2 I& V6 X) o! A
if(!pMatrix1) break; //对象句柄无效，不是矩阵
+ {5 M2 p\\" `! D- |, G
pa=pMatrix1->Array;
! R* T: }% w& F
m=pMatrix1->Dim[0]; n=pMatrix1->Dim[1]; k=0;# X4 b8 s3 k) s) L, F5 A+ L
for(i=0; i<m; i++) //输出矩阵
1 ~! F, n# q$ i' i3 G* K% Q
{4 Z8 ~* h: o$ [' p- c* \
pMessage(L"\r\n"); k+=2;
9 Z5 A( i5 h \9 j( r: m
for(j=0; j<n; j++)
+ }* @6 N* U0 M! b9 E4 g
{- f0 P2 k( W* a
_gcvt_s(chNum,pa[i*n+j],16);4 @' M3 T# q4 O. z+ _' [3 J5 W
for(u=0;chNum[u];u++) {wchNum[u]=chNum[u]; k++;}- O. C3 ], J6 I4 b( z9 s5 D+ r
wchNum[u]='\0';
; m* R8 ]: x- T! @/ @2 \: K+ K
pMessage(wchNum); pMessage(L" "); k+=2;! g u3 l0 `0 r7 u( p6 R0 u2 M+ O
}+ M( s% h R f; L: [6 P5 `) Z' S
}( z\\" s/ k5 T7 S+ N6 Q, S3 E
pMessage(L"\r\n"); k+=2;* ~* j! H7 A2 E: y, l5 D- p# b# p& G
a.BType=luStaData_int64; a.VType=luStaData_int64; a.x=k; //按函数o的要求，返回输出的字符总数; f. }9 k3 k1 @. D8 |9 G. B# k2 T
break;
3 H. {6 {. W. [8 h( g
default:
/ k( [* @+ C) _) I' h# P
break;
) e N( `5 i9 a N4 j0 F b
}- J( L% [* t/ \! f
return a;
, W4 y# l. D6 {\\" h# S$ Z% P
}
8 {7 }* W0 E I9 T: { Q$ v
void main(void)
6 ?+ X0 p9 Z' ?& E
{; @& S) a* g1 ] ?# g
void *hFor; //表达式句柄- T g% r4 {1 M# @: `
luINT nPara; //存放表达式的自变量个数6 ~! u/ y7 g0 |% Q7 K/ t
LuData *pPara; //存放输入自变量的数组指针
# T w+ d- h& U9 E
luINT ErrBegin,ErrEnd; //表达式编译出错的初始位置和结束位置' c/ r1 |% K' O9 l8 s
int ErrCode; //错误代码, ~. w7 N# U* t% `. i- c
void *v;/ Y0 Q! y\\" F9 {5 k
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.]}";//字符串表达式，矩阵乘
! R0 N# y- r e( Z; c, @
//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.]}";//字符串表达式，矩阵点乘0 U# g4 i( M! ^. T% e8 Z6 |
LuData Val;; P! }3 J; i5 |4 e* D. ?, Q\\" d
if(!InitLu()) return; //初始化Lu& @* H! d9 V5 d7 c7 f
while(LockKey(Matrix,DelMatrix,OpMatrix)){Matrix--;} //锁定一个键，用于存储矩阵扩展类型# M7 r* O, \/ J6 n2 i
9 ?0 R4 d' z) I0 P# l) j
Val.BType=luStaData_int64; Val.VType=luStaData_int64; Val.x=Matrix; //定义整数常量. h5 K# A( O' t. o1 O$ ^* Y8 p- q5 c
SetConst(L"matrix",&Val); //设置整数常量
) m! C j\\" N+ x4 x, B& \7 R
InsertKey("\0\0\0\0",4,luPubKey_User,LuMessage,NULL,NULL,1,v); //使Lu运行时可输出函数信息
* F' D }* V& L% _: U8 X
wcout.imbue(locale("chs")); //设置输出的locale为中文
2 _\\" B$ P$ Y6 @* N' O/ X
8 v* r1 a2 X; W* m; `
ErrCode=LuCom(ForStr,0,0,0,hFor,nPara,pPara,ErrBegin,ErrEnd); //编译表达式
6 D8 z/ \+ ~3 P) v\\" {$ F
if(ErrCode)
7 ?0 O1 w4 d3 C- K6 j+ j
{, A/ {' x: k1 F) ~5 s6 o
wcout<<L"表达式有错误！错误代码："<<ErrCode<<endl;3 q. n3 E) i0 D% Q, G8 g
}
$ Z- S\\" W& r6 e1 Y8 p* y
else\\" F\\" F\\" H9 h, c, t
{1 a+ w- C x! b; v
LuCal(hFor,pPara); //计算表达式的值
7 E% [& ~+ D# u* M1 Q# ]
}; p6 o6 q* C$ s, B6 Q# Y) O* x# f2 S& Y
LockKey(Matrix,NULL,OpMatrix);//解锁键Matrix，本例中，该函数可以不用. o\\" p9 h. I' J+ @* ~
FreeLu(); //释放Lu% f v0 K/ p1 k# i! F
}

#include <windows.h> 
3 N, L) x5 L; ^4 ^: Y  n; g
#include <iostream> 
! z' G+ Q7 Y7 B
#include <math.h>' e  H/ V2 ^' T+ F\\" z4 R+ V

#include "lu32.h" 
1 a% E8 N: I+ M  h- H: k- c
#pragma comment( lib, "lu32.lib" ) 
2 \' R; c3 {8 y5 h& Y4 f& B\\" p
using namespace std;0 E9 \% Z) i6 o

//自定义矩阵 
! Q( T+ V% J* S& N
class myMatrix; z3 F6 j- x9 P8 `, J

{3 p3 J! \) y% H0 ^

public: 
/ B) B' d* s1 O' h3 F* c- ^
        double *Array;        //数据缓冲区! j' W2 O\\" l( `+ u' l6 T

luVOID ArrayLen;        //数据缓冲区长度6 W9 N! o5 g( i  |- J

luVOID Dim[2];        //矩阵维数 
  x\\" z8 R( K' U9 a
        myMatrix(){Array=NULL; ArrayLen=0; Dim[0]=0; Dim[1]=0;} 
2 b6 b4 B+ ^6 k. K  M\\" q\\" Z1 ]2 o! `4 _
        ~myMatrix() 
) L* {$ T! h\\" `2 W7 t5 x' |( o
        { 
8 _' D; h5 U\\" T
                if(Array) delete[] Array; 
8 {) r/ r* d( D6 [+ U
        }1 a\\" f/ N- N( d( J7 Y& K& h

};: y: D$ u, T2 H( b9 ?

luKEY Matrix=-1000;        //标识矩阵类型，最终的Matrix由LockKey决定 
1 X0 k8 j6 w  T9 q6 `8 T
void _stdcall LuMessage(wchar_t *pch)//输出动态库信息，该函数注册到Lu，由Lu二级函数调用 
, h9 X( e! W2 k: j
{! L- B\\" M! A9 N/ U; c' n

wcout<<pch;- \4 I# h4 Q- t) M# @# ]+ p

} 
! L' _\\" P; Y9 G/ h) X7 `* n! d
void _stdcall DelMatrix(void *me)        //用于LockKey函数及InsertKey函数，使Lu能自动销毁myMatrix对象 
& }9 v7 `9 o/ v9 V' C3 r# v
{7 j% x' {8 P  y; E& T

delete (myMatrix *)me;4 D; }! `0 I, T% C) s; T

} 
8 @% [\\" {0 ^* g; T/ X4 N
myMatrix * _stdcall NewMatrix(luVOID m,luVOID n)        //生成一个myMatrix对象 
! S5 L1 m& R0 h# ]# Q! q
{9 z, B) D2 C4 M0 Y7 r

myMatrix *pMatrix;' \4 `# t! A# n\\" q\\" N4 Y6 p

luVOID k;3 E2 o) R: L) q) G

double *pa; 
! U1 H. c- `& c: g1 c
        char keyname[sizeof(luVOID)];( R2 a! I! \- q! G! G) h

void *NowKey;# o* B- q2 ~; c$ _) K

k=m*n; 
* S\\" m$ p; O9 Z; o( ]; M
        pMatrix=(myMatrix *)GetBufObj(Matrix,keyname);//先尝试从缓冲区中获取一个矩阵对象. `* e6 h3 ^7 p6 }* |

if(pMatrix) 
: a9 P, z  T, u$ P' U  `
        {* k4 r9 e* d7 X2 c& A( r

if(pMatrix->ArrayLen!=k)        //重置矩阵的大小; J8 b  B2 a5 k+ o% o\\" _4 g! s

{ 
9 x/ V* Y# Q. V9 T! f\\" E6 V, i6 j% [' U
                        pa=new double[k];+ @+ r/ o2 O. }, P# c/ e

if(!pa) 
0 i8 z: J7 F6 e& Y9 k
                        {+ |6 k# f  L2 u

DeleteKey(keyname,sizeof(luVOID),Matrix,DelMatrix,1);        //将矩阵对象放回缓冲区7 a3 O, @+ ?) P, p6 Q# z  J

return NULL; 
. q  u( x# }; `5 Z3 c* S, y* R
                        }) e# x+ q) f8 O6 o& C# v

delete[] pMatrix->Array; 
+ W9 x/ I& I% a
                        pMatrix->Array=pa; 
2 u! g\\" d. j  E* R3 @+ z, k3 x
                } 
/ K0 ?5 s1 y6 m% o
        } 
  p; [, c$ `$ ]! N4 Y4 J# @
        else( ^  @4 L; e\\" ^3 K$ @- @

{ 
\\" M\\" Y3 ?/ h# e) f0 F
                pMatrix=new myMatrix;        //创建矩阵对象5 i* n0 E\\" F& S3 X2 [4 }

if(!pMatrix) return NULL; 
, v2 s) i$ _+ g' D
                pMatrix->Array=new double[k];/ B. H: I! m9 N& _

if(!pMatrix->Array) 
4 F1 J- B* ^4 }4 F\\" b) v8 [
                {% g+ F5 m( r3 ~

delete pMatrix; 
7 _7 A9 h% u\\" @\\" `
                        return NULL; 
\\" i  V3 _: f- P4 M3 U% l6 J8 ]& `
                }0 I1 K+ A  n$ r5 g

if(InsertKey((char *)&pMatrix,-1,Matrix,pMatrix,DelMatrix,NULL,0,NowKey))        //将矩阵对象注册到Lu0 W4 ~) D) H\\" g* P\\" V, b& X

{ 
; P9 e, F\\" H* Q, l0 T8 H
                        delete pMatrix; 
) n- B/ u1 F% y0 R. V& u
                        return NULL;% f$ W2 h3 N9 r# f6 E( N3 |

}$ c3 Q/ _; z5 @1 B

}' t% o1 [: {\\" t% [% e, B

pMatrix->ArrayLen=k; pMatrix->Dim[0]=m; pMatrix->Dim[1]=n;0 H$ X5 Z. `8 |/ A

return pMatrix; 
* Q* _5 y+ r- x# l+ U$ a
}6 n& o+ |5 r, s2 a* y

LuData _stdcall OpMatrix(luINT mm,LuData *xx,void *hFor,int theOperator)        //运算符重载函数，用于LockKey函数$ {6 ^) g6 T\\" B* T# ?5 A

{ 
' f- @1 u% Z. Q  |4 C4 t  z
        LuData a; 
8 L) t+ {5 a8 A
        myMatrix *pMatrix1,*pMatrix2,*pMatrix3; 
& d0 T! j2 K: S
        luVOID i,j,k,m,n,u,v; 
2 J/ k  s+ c* M, Z5 O
        double *pa,*pb,*pc;2 ?! X8 t; s5 X* M) K* T

luMessage pMessage;3 C8 n\\" @/ h* M2 [\\" v9 p9 L: z5 t

wchar_t wchNum[32]; 
# N: M7 s7 z* K9 Q
        char chNum[32]; 
1 U3 }0 ~9 d) s- x& s+ c
        a.BType=luStaData_nil; a.VType=luStaData_nil; a.x=0; 
! h) w! O8 D; i6 y% v' H
        switch(theOperator) 
) M& w' s3 k+ ~4 s9 N' a1 d  X( `
        { 
' X7 w; ]' S+ h  \) [
        case 2:        //重载运算符* 
$ R! L+ H0 W\\" E, d* l
                pMatrix1=(myMatrix *)SearchKey((char *)&(xx->x),sizeof(luVOID),Matrix);' L: m1 Y  e\\" Z/ h) D7 V% x

pMatrix2=(myMatrix *)SearchKey((char *)&((xx+1)->x),sizeof(luVOID),Matrix); 
  v2 D  r) \4 {1 g; c7 y( ~. s
                if(!pMatrix1 || !pMatrix2) break;        //对象句柄无效，不是矩阵 
  f. M2 e- S0 [1 l1 J0 y
                if(pMatrix1->Dim[1]!=pMatrix2->Dim[0]) break;        //维数不匹配 
, ?. r2 ?/ c' V
                pMatrix3=NewMatrix(pMatrix1->Dim[0],pMatrix2->Dim[1]);        //生成新矩阵( @. p+ v4 x\\" c

if(!pMatrix3) break;  ~: j9 j9 {' F7 t( }

pa=pMatrix1->Array; pb=pMatrix2->Array; pc=pMatrix3->Array;, t0 ]8 `: ]9 ^% ?7 ]( F- Y

m=pMatrix1->Dim[0]; n=pMatrix1->Dim[1]; k=pMatrix2->Dim[1];' Y\\" K6 D# ]% E0 B/ d\\" ?

for(i=0; i<m; i++)        //矩阵乘 
/ S. f0 a) \/ E1 h) c) K\\" |
                {8 X7 ]/ W$ a- |& O( U& p5 L

for(j=0; j<k; j++)  }/ P1 d0 e, K  l( Z8 I

{+ q, D! v8 d2 U! B% }' s5 y\\" _

u=i*k+j; pc[u]=0.0; 
  x8 y7 i6 Q3 R0 J2 |7 L+ J
                                for (v=0; v<n; v++)4 P+ v+ T! b$ {  M) U\\" P  L/ _* u

{& B5 ~5 R6 F: E- |

pc[u]=pc[u]+pa[i*n+v]*pb[v*k+j];$ Z6 W6 C2 Z0 T5 p

} 
7 `0 A6 P7 ~) U) G/ J4 y: ]9 E
                        }1 N5 w3 M, h. v2 ~

} 
! ?2 f* D: o( ^) k8 q6 w8 Z
                FunReObj(hFor);        //告诉Lu，返回一个动态对象& q, @# D: \4 T/ |+ C

a.BType=Matrix; a.VType=Matrix; a.x=0; *(luVOID *)&(a.x)=(luVOID)pMatrix3; 
$ D( y3 J  J1 n& m! F
                break;* }\\" Z+ w3 R' U, d7 g0 f

case 25:        //重载运算符.*! Y6 ]* w, f3 x& V

pMatrix1=(myMatrix *)SearchKey((char *)&(xx->x),sizeof(luVOID),Matrix);2 d! T\\" S. E* d; V8 x# S

pMatrix2=(myMatrix *)SearchKey((char *)&((xx+1)->x),sizeof(luVOID),Matrix); 
; P- Y( J/ ^% \* n3 a% M- E
                if(!pMatrix1 || !pMatrix2) break;        //对象句柄无效，不是矩阵5 E  s3 U\\" d4 k4 s0 }! K) s. W( ~

if(pMatrix1->Dim[0]!=pMatrix2->Dim[0] || pMatrix1->Dim[1]!=pMatrix2->Dim[1]) break;        //维数不相同 
6 B5 P3 z- j( A/ ^8 W# \/ Y
                pMatrix3=NewMatrix(pMatrix1->Dim[0],pMatrix1->Dim[1]);        //生成新矩阵; t  x1 W2 C3 e

if(!pMatrix3) break;' e\\" e3 K1 P' `' u

for(i=0;i<pMatrix1->ArrayLen;i++) pMatrix3->Array[i]=pMatrix1->Array[i]*pMatrix2->Array[i];        //矩阵点乘( J: E4 f* u4 A* R

FunReObj(hFor);        //告诉Lu，返回一个动态对象 
; Z: w( l* l: n  p
                a.BType=Matrix; a.VType=Matrix; a.x=0; *(luVOID *)&(a.x)=(luVOID)pMatrix3;; s3 s2 `$ R- i

break; 
9 q7 t3 n# P3 \7 q0 l) O& n3 |/ j: v
        case 46:        //重载函数new 
5 d8 P: Q4 w4 T4 g
                if(mm<2) break; 
3 j& V8 u/ A; L\\" s9 v) J6 @
                if((xx+1)->x<1 || (xx+2)->x<1 || (xx+1)->BType!=luStaData_int64 || (xx+2)->BType!=luStaData_int64) break; 
0 g* S/ d+ [9 N5 n- _; t9 ?% s
                pMatrix3=NewMatrix((luVOID)(xx+1)->x,(luVOID)(xx+2)->x);//生成新矩阵\\" P+ f- v  l* V

if(!pMatrix3) break; 
3 z* h8 w4 R# m8 O3 C
                for(j=0,i=3;i<=mm;i++,j++)        //赋初值 
2 w3 m3 g& j. a; K
                {# W2 {9 w! }; w4 B7 h( x

if(j>=pMatrix3->ArrayLen) break;2 [  c' W\\" _/ S& }4 w

if((xx+i)->BType!=luStaData_double) break;        //只接受实数参数8 _! |8 p6 }) F/ G, A; |

pMatrix3->Array[j]=*(double *)&((xx+i)->x); 
7 u2 J& a* t& O+ z: E
                } 
. L4 D2 j6 T6 ]2 y
                FunReObj(hFor);        //告诉Lu，返回一个动态对象 
7 p7 b  C1 ~- \* r/ x\\" O# M; k
                a.BType=Matrix; a.VType=Matrix; a.x=0; *(luVOID *)&(a.x)=(luVOID)pMatrix3;# O% [6 z9 O6 S4 Y

break;% t9 m7 a5 I  O! v( ~1 L1 @

case 49:        //重载函数o% I) O0 C: J9 Y* `

pMessage=(luMessage)SearchKey("\0\0\0\0",sizeof(luVOID),luPubKey_User); 
4 z* ]( \% ]  K
                if(!pMessage) break;\\" n; n2 I# S$ m- Y0 \5 C$ n1 t

pMatrix1=(myMatrix *)SearchKey((char *)&(xx->x),sizeof(luVOID),Matrix); 
2 I& V6 X) o! A
                if(!pMatrix1) break;        //对象句柄无效，不是矩阵 
+ {5 M2 p\\" `! D- |, G
                pa=pMatrix1->Array; 
! R* T: }% w& F
                m=pMatrix1->Dim[0]; n=pMatrix1->Dim[1]; k=0;# X4 b8 s3 k) s) L, F5 A+ L

for(i=0; i<m; i++)        //输出矩阵 
1 ~! F, n# q$ i' i3 G* K% Q
                {4 Z8 ~* h: o$ [' p- c* \

pMessage(L"\r\n"); k+=2; 
9 Z5 A( i5 h  \9 j( r: m
                        for(j=0; j<n; j++) 
+ }* @6 N* U0 M! b9 E4 g
                        {- f0 P2 k( W* a

_gcvt_s(chNum,pa[i*n+j],16);4 @' M3 T# q4 O. z+ _' [3 J5 W

for(u=0;chNum[u];u++) {wchNum[u]=chNum[u]; k++;}- O. C3 ], J6 I4 b( z9 s5 D+ r

wchNum[u]='\0'; 
; m* R8 ]: x- T! @/ @2 \: K+ K
                                pMessage(wchNum); pMessage(L"  "); k+=2;! g  u3 l0 `0 r7 u( p6 R0 u2 M+ O

}+ M( s% h  R  f; L: [6 P5 `) Z' S

}( z\\" s/ k5 T7 S+ N6 Q, S3 E

pMessage(L"\r\n"); k+=2;* ~* j! H7 A2 E: y, l5 D- p# b# p& G

a.BType=luStaData_int64; a.VType=luStaData_int64; a.x=k;        //按函数o的要求，返回输出的字符总数; f. }9 k3 k1 @. D8 |9 G. B# k2 T

break; 
3 H. {6 {. W. [8 h( g
        default: 
/ k( [* @+ C) _) I' h# P
                break; 
) e  N( `5 i9 a  N4 j0 F  b
        }- J( L% [* t/ \! f

return a; 
, W4 y# l. D6 {\\" h# S$ Z% P
} 
8 {7 }* W0 E  I9 T: {  Q$ v
void main(void) 
6 ?+ X0 p9 Z' ?& E
{; @& S) a* g1 ]  ?# g

void *hFor;                //表达式句柄- T  g% r4 {1 M# @: `

luINT nPara;                //存放表达式的自变量个数6 ~! u/ y7 g0 |% Q7 K/ t

LuData *pPara;                //存放输入自变量的数组指针 
# T  w+ d- h& U9 E
        luINT ErrBegin,ErrEnd;        //表达式编译出错的初始位置和结束位置' c/ r1 |% K' O9 l8 s

int ErrCode;                //错误代码, ~. w7 N# U* t% `. i- c

void *v;/ Y0 Q! y\\" F9 {5 k

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.]}";//字符串表达式，矩阵乘 
! R0 N# y- r  e( Z; c, @
        //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.]}";//字符串表达式，矩阵点乘0 U# g4 i( M! ^. T% e8 Z6 |

LuData Val;; P! }3 J; i5 |4 e* D. ?, Q\\" d

if(!InitLu()) return;        //初始化Lu& @* H! d9 V5 d7 c7 f

while(LockKey(Matrix,DelMatrix,OpMatrix)){Matrix--;}        //锁定一个键，用于存储矩阵扩展类型# M7 r* O, \/ J6 n2 i

9 ?0 R4 d' z) I0 P# l) j

Val.BType=luStaData_int64; Val.VType=luStaData_int64; Val.x=Matrix;        //定义整数常量. h5 K# A( O' t. o1 O$ ^* Y8 p- q5 c

SetConst(L"matrix",&Val);        //设置整数常量 
) m! C  j\\" N+ x4 x, B& \7 R
        InsertKey("\0\0\0\0",4,luPubKey_User,LuMessage,NULL,NULL,1,v); //使Lu运行时可输出函数信息 
* F' D  }* V& L% _: U8 X
        wcout.imbue(locale("chs"));        //设置输出的locale为中文 
2 _\\" B$ P$ Y6 @* N' O/ X
  8 v* r1 a2 X; W* m; `

ErrCode=LuCom(ForStr,0,0,0,hFor,nPara,pPara,ErrBegin,ErrEnd); //编译表达式 
6 D8 z/ \+ ~3 P) v\\" {$ F
        if(ErrCode) 
7 ?0 O1 w4 d3 C- K6 j+ j
        {, A/ {' x: k1 F) ~5 s6 o

wcout<<L"表达式有错误！错误代码："<<ErrCode<<endl;3 q. n3 E) i0 D% Q, G8 g

} 
$ Z- S\\" W& r6 e1 Y8 p* y
        else\\" F\\" F\\" H9 h, c, t

{1 a+ w- C  x! b; v

LuCal(hFor,pPara);        //计算表达式的值 
7 E% [& ~+ D# u* M1 Q# ]
        }; p6 o6 q* C$ s, B6 Q# Y) O* x# f2 S& Y

LockKey(Matrix,NULL,OpMatrix);//解锁键Matrix，本例中，该函数可以不用. o\\" p9 h. I' J+ @* ~

FreeLu();                        //释放Lu% f  v0 K/ p1 k# i! F

}

习题：

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

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

main(:a,b,c,d,t,i)=
! O2 t m R, I% w( B7 l
a=new[matrix,2,2: 1.,2.,2.,1.],6 g- p& [- Q' l
b=new[matrix,2,2: 2.,1.,1.,2.],
5 w# V( T: B6 W/ t1 W\" F \
c=new[matrix,2,2: 2/3.,-1/3.,-1/3.,2/3.],
7 F0 w2 ~, v% i3 C9 w\" j! C
t=clock(),; g- [3 ?7 F( V3 E
d=a*b, i=0, while{i<1000000, d=d*c*b, i++},\" G$ `6 W& P3 k8 A4 D$ k
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\"}";//字符串表达式

复制代码

结果：