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

查看: 8924|回复: 2

在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>' d) R4 F r6 e( Z4 j7 q0 R
#include <iostream>
- C\\" J% V( H2 ]9 |; A
#include <math.h>1 h( y. F) F+ Z' N! \
#include "lu32.h"
( I/ i+ Y% [\\" v
#pragma comment( lib, "lu32.lib" )- K\\" K\\" V\\" k: B
using namespace std;0 a1 L4 l I1 V: W
//自定义矩阵2 Z* W7 I1 ?- d
class myMatrix+ \: e- B& w1 x H' n; d8 R
{) E8 r) {5 N5 c- {9 `
public:
1 J' |; |1 W. w4 }8 t
double *Array; //数据缓冲区
) s8 x# \9 T: b/ s
luVOID ArrayLen; //数据缓冲区长度
* [( X+ P& j) D; F. G
luVOID Dim[2]; //矩阵维数' D4 k' O7 G0 A$ ~0 _) [
myMatrix(){Array=NULL; ArrayLen=0; Dim[0]=0; Dim[1]=0;}
- k+ g- H1 H5 t
~myMatrix() f2 \, u2 U- Y/ M
{
0 d% t7 ], | B# @ V
if(Array) delete[] Array;- F6 l2 f C) K- N
}
\\" _6 o( g\\" s5 t) P: q H: x; {
};
2 ~' w/ w$ |0 F+ Z. p! M) y5 |
luKEY Matrix=-1000; //标识矩阵类型，最终的Matrix由LockKey决定
$ [7 T& I# A! p0 E
void _stdcall LuMessage(wchar_t *pch)//输出动态库信息，该函数注册到Lu，由Lu二级函数调用 N& Z( U\\" W4 m3 p
{ |8 x\\" P |3 y3 g
wcout<<pch;
, ~/ J* B' d/ G, E0 B* f
}* ~\\" B. {' ?: b( E
void _stdcall DelMatrix(void *me) //用于LockKey函数及InsertKey函数，使Lu能自动销毁myMatrix对象
. b z& _' F: |- K) t1 {, t
{; G) U( U\\" }3 M7 c/ w, e7 {
delete (myMatrix *)me;
, w& A' F7 l6 v
}
+ S5 d4 s2 K0 F2 \9 v# R8 C
myMatrix * _stdcall NewMatrix(luVOID m,luVOID n) //生成一个myMatrix对象# s8 p0 p7 Q$ T& g4 @0 _
{1 O9 e$ K+ L\\" @' c3 E
myMatrix *pMatrix;
* _0 T\\" U\\" ?* |
luVOID k;
% G+ A$ y( E1 c2 t- Z# ]
double *pa; X: p/ i) P4 x7 \7 H% d! T( K
char keyname[sizeof(luVOID)]; ~/ |( i1 K7 t- k0 r
void *NowKey;) ?* v/ S. w8 J& R/ s
k=m*n;
% a# A, D/ T$ o$ E# E$ `\\" u# W
pMatrix=(myMatrix *)GetBufObj(Matrix,keyname);//先尝试从缓冲区中获取一个矩阵对象: |6 \, y5 V& d8 V7 a$ h
if(pMatrix)
! t. s0 C3 |& q2 M1 m8 ~' ^7 j( p# [
{
8 K3 B* n/ D! i+ [9 }) y
if(pMatrix->ArrayLen!=k) //重置矩阵的大小
4 `\\" `6 {& {$ Q H! ^% G( z
{
/ |$ E6 k- d4 o) _/ I) ]5 o
pa=new double[k];
3 F2 w/ W\\" V9 _
if(!pa)
9 x4 U: H& z1 r1 p' z7 m$ g
{8 Z9 }. I; o% k\\" J. O& T) e8 {
DeleteKey(keyname,sizeof(luVOID),Matrix,DelMatrix,1); //将矩阵对象放回缓冲区$ y\\" v) y( m7 \5 `: I! G8 j
return NULL;! k3 Q; U- b9 N$ {2 R$ Q
}: J& A8 {; H% U3 s0 u& y\\" R1 N
delete[] pMatrix->Array;
3 W& E. |8 q4 M* H
pMatrix->Array=pa;+ U: o! U$ j\\" d, r
}
# h% b+ O/ I, A& M, Z1 J. X9 I
}
' a3 F8 j2 M4 q% f* f8 M; I5 e% i
else$ w7 I6 E* ?, `& o
{' J1 R/ M* H\\" U- m7 F/ \) t* k9 f
pMatrix=new myMatrix; //创建矩阵对象 }6 N: ^\\" N9 `7 Z% Z: }) @
if(!pMatrix) return NULL;
; j6 h\\" f+ y6 G! K( I4 H
pMatrix->Array=new double[k]; u) [7 g/ o8 M* H' H$ n- y
if(!pMatrix->Array)- Y6 q5 W+ J6 t6 C
{0 [# N1 k( f9 f1 R\\" s
delete pMatrix;: D+ V2 i, R$ ~% s, f\\" r% E3 Z
return NULL;
* Y6 h6 a E7 A+ N3 x* X: R' O7 G
}% U% e' {) c8 V1 n! g
if(InsertKey((char *)&pMatrix,-1,Matrix,pMatrix,DelMatrix,NULL,0,NowKey)) //将矩阵对象注册到Lu2 @* J- p# x7 t8 U; h* M t
{/ e7 b5 ]8 M% B
delete pMatrix;
, D1 V! Y1 Q7 `8 a. f
return NULL;
( G% w& R6 d& u. M( I1 {
}
) ]\\" t, x$ I5 o* {
}
! y5 }. \2 X: t- `) U
pMatrix->ArrayLen=k; pMatrix->Dim[0]=m; pMatrix->Dim[1]=n;
9 g# B4 p* @6 n
return pMatrix;- k. y8 B* O1 l0 A
}
$ }3 E* [& A; G7 Y1 G( d% O
LuData _stdcall OpMatrix(luINT mm,LuData *xx,void *hFor,int theOperator) //运算符重载函数，用于LockKey函数
4 L; M6 @6 `( L* M8 ?
{- ~) Z5 U }+ i0 m0 h
LuData a;
; N% S, C4 l' X
myMatrix *pMatrix1,*pMatrix2,*pMatrix3;# v1 l; s& U! `\\" q) [1 L* b
luVOID i,j,k,m,n,u,v;
! u- h7 B% V1 \; M4 h6 B2 }
double *pa,*pb,*pc;
0 k1 G: O$ ]+ a l% A
luMessage pMessage;
/ f: |# Z* x+ V2 q- y
wchar_t wchNum[32];
: l; Z [1 _, W1 c
char chNum[32];. x& F1 q) |% {\\" t* B
a.BType=luStaData_nil; a.VType=luStaData_nil; a.x=0;/ g5 H* H; M9 `0 S
switch(theOperator)* O\\" @; i# k. X1 {
{$ r7 ]8 B% f( Z+ D
case 2: //重载运算符*
* U. Y. E( a. F
pMatrix1=(myMatrix *)SearchKey((char *)&(xx->x),sizeof(luVOID),Matrix);* R% R8 B* D+ A/ U6 _
pMatrix2=(myMatrix *)SearchKey((char *)&((xx+1)->x),sizeof(luVOID),Matrix);
- a3 D\\" S- B# m; V. C/ c
if(!pMatrix1 || !pMatrix2) break; //对象句柄无效，不是矩阵
; c* ~0 h% G& g& G9 [! H1 k6 t1 t( P
if(pMatrix1->Dim[1]!=pMatrix2->Dim[0]) break; //维数不匹配8 g- X0 k\\" a% Q3 X& Q/ O
pMatrix3=NewMatrix(pMatrix1->Dim[0],pMatrix2->Dim[1]); //生成新矩阵# M% G. ~, M, [% T5 u) q# U0 f1 X
if(!pMatrix3) break;9 r& t) Y7 F9 C; c' r! Y
pa=pMatrix1->Array; pb=pMatrix2->Array; pc=pMatrix3->Array;
& X; s# G I2 j/ O. D
m=pMatrix1->Dim[0]; n=pMatrix1->Dim[1]; k=pMatrix2->Dim[1];
5 m# G6 S7 ]5 j- N/ g7 Y
for(i=0; i<m; i++) //矩阵乘/ E( {* ~- T+ n* I: s
{! n7 _. H\\" S5 A. Z4 ]8 E! v2 J5 z
for(j=0; j<k; j++)
9 V& E( Y0 V* z4 Y% R- J
{' c, E! a\\" `5 c' p% ~# a
u=i*k+j; pc[u]=0.0;
& I2 [2 t. T5 g4 d g- k
for (v=0; v<n; v++)! x( H1 k% v1 s! }' d9 k
{
% I- f9 D# r0 Q! O- S1 b
pc[u]=pc[u]+pa[i*n+v]*pb[v*k+j];: r- |1 z, T, i8 \3 @5 J9 r
}
% K. y7 u4 l3 D- `; |7 t
}
- E; G0 p5 r7 C) ?. c: w
}, J/ W: I+ w5 J
FunReObj(hFor); //告诉Lu，返回一个动态对象' J! L' V* j% E. [7 x+ K4 `. p
a.BType=Matrix; a.VType=Matrix; a.x=0; *(luVOID *)&(a.x)=(luVOID)pMatrix3;& E* z# H7 |; E/ [$ W
break;
( w9 b B3 U {0 e Y8 c' B( s
case 25: //重载运算符.*
7 q* ]+ q# j. c! z\\" h
pMatrix1=(myMatrix *)SearchKey((char *)&(xx->x),sizeof(luVOID),Matrix);8 [2 c6 n- T; I( j) s3 |! x
pMatrix2=(myMatrix *)SearchKey((char *)&((xx+1)->x),sizeof(luVOID),Matrix);
5 _2 H) D6 Z( M7 U1 L
if(!pMatrix1 || !pMatrix2) break; //对象句柄无效，不是矩阵
; r\\" m1 z4 { K5 N; ^- S) Z
if(pMatrix1->Dim[0]!=pMatrix2->Dim[0] || pMatrix1->Dim[1]!=pMatrix2->Dim[1]) break; //维数不相同! H! D3 N: f0 D* l1 B: z
pMatrix3=NewMatrix(pMatrix1->Dim[0],pMatrix1->Dim[1]); //生成新矩阵
3 k! I. u\\" g- d1 @; Y
if(!pMatrix3) break;
n6 N, N! k% m! _
for(i=0;i<pMatrix1->ArrayLen;i++) pMatrix3->Array[i]=pMatrix1->Array[i]*pMatrix2->Array[i]; //矩阵点乘
% L( h7 I- \+ l# G
FunReObj(hFor); //告诉Lu，返回一个动态对象6 ?, a& w/ |' ~0 n d' f/ l7 M
a.BType=Matrix; a.VType=Matrix; a.x=0; *(luVOID *)&(a.x)=(luVOID)pMatrix3;
8 d2 l0 l7 B2 L. [: r# C7 K
break;
; J, J* {) `7 ?' m
case 46: //重载函数new
1 i% l- b# [/ }& _2 ?* z
if(mm<2) break;
/ ?8 @3 q6 g! ?- i6 F% j' ?
if((xx+1)->x<1 || (xx+2)->x<1 || (xx+1)->BType!=luStaData_int64 || (xx+2)->BType!=luStaData_int64) break;. X; K: X0 n, s6 u8 j+ v
pMatrix3=NewMatrix((luVOID)(xx+1)->x,(luVOID)(xx+2)->x);//生成新矩阵( M6 Y. x: z& J& @) ^
if(!pMatrix3) break;
\\" }3 f- E3 |7 G; H. X7 O
for(j=0,i=3;i<=mm;i++,j++) //赋初值: t& c& x5 H' t& \0 h* d$ N
{0 ]* w\\" @7 s6 |1 e
if(j>=pMatrix3->ArrayLen) break;1 K& e' U/ i9 [. M6 B# ^
if((xx+i)->BType!=luStaData_double) break; //只接受实数参数
5 u\\" J0 `0 i+ w+ Z$ W
pMatrix3->Array[j]=*(double *)&((xx+i)->x);) `/ @8 B& X# Y
}4 N z+ G% F: W0 q- p: C
FunReObj(hFor); //告诉Lu，返回一个动态对象; Q( I1 @, z/ J
a.BType=Matrix; a.VType=Matrix; a.x=0; *(luVOID *)&(a.x)=(luVOID)pMatrix3;+ C+ r E n2 K; {6 J/ K$ I( b, U
break;
+ x; ?5 f8 r8 N5 X$ P0 {9 N
case 49: //重载函数o
9 n6 \$ }3 \0 N
pMessage=(luMessage)SearchKey("\0\0\0\0",sizeof(luVOID),luPubKey_User);: }' x. Q\\" e' O9 t8 e4 L5 \1 I
if(!pMessage) break;5 w2 e: ^% ?6 I5 _$ P+ B) p
pMatrix1=(myMatrix *)SearchKey((char *)&(xx->x),sizeof(luVOID),Matrix);# u1 U$ O\\" k @2 D. K
if(!pMatrix1) break; //对象句柄无效，不是矩阵
1 j: j- R. h3 z h* p' r3 r
pa=pMatrix1->Array;8 _% ]+ E, Q, G4 C1 |
m=pMatrix1->Dim[0]; n=pMatrix1->Dim[1]; k=0;
- I) f2 M2 O8 ]! J2 n( J8 C8 [- D
for(i=0; i<m; i++) //输出矩阵: H4 q) N: q7 x\\" e6 R h: \1 \0 z/ W) R
{
l2 P1 j/ s! P2 [0 e
pMessage(L"\r\n"); k+=2;
, A& N# t+ J8 Y; K# M* @
for(j=0; j<n; j++)
$ d m4 E! M8 x. A& R; X
{! t! L# s5 `0 [6 V+ n
_gcvt_s(chNum,pa[i*n+j],16);
5 e$ m& ^: k% J- L
for(u=0;chNum[u];u++) {wchNum[u]=chNum[u]; k++;}
7 {' B9 z0 f$ A, r6 c
wchNum[u]='\0';; U8 ^ {3 F\\" k\\" F
pMessage(wchNum); pMessage(L" "); k+=2;
/ z! J! @) X+ s\\" j. _! B9 B
}
! w\\" I4 |/ C7 e7 U3 X$ b
}+ S% {9 C% ^, N. [' X( Z3 }
pMessage(L"\r\n"); k+=2;3 `% L! ^5 U\\" Y) D, e6 p% {: Q
a.BType=luStaData_int64; a.VType=luStaData_int64; a.x=k; //按函数o的要求，返回输出的字符总数
5 X9 C o( A/ p$ w) u
break;
/ O K. d, Q\\" R, g; b- N
default:9 ^4 J5 j, r5 \- z
break;
}+ V y% F$ x5 \7 d: O+ c
return a;4 F: |1 i# o7 ?3 b+ X* z
}
. D) b! Y. J _* x
void main(void)
9 S( b( @7 j3 J3 Q
{7 n7 V# Z' f' J, H, e
void *hFor; //表达式句柄
7 C8 ~, S( U2 i) Q
luINT nPara; //存放表达式的自变量个数9 e R& M+ w8 Z9 [# e
LuData *pPara; //存放输入自变量的数组指针1 s5 n& }% N3 L6 _' ?+ C/ R
luINT ErrBegin,ErrEnd; //表达式编译出错的初始位置和结束位置
/ l/ a4 m G/ |2 G& W, ~$ F; b
int ErrCode; //错误代码
/ P/ t- v. x7 p' j
void *v;0 c0 @+ l2 V- j6 s/ `
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.]}";//字符串表达式，矩阵乘
# W& V# c: ]0 W* d
//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.]}";//字符串表达式，矩阵点乘
8 a0 Y: u+ J9 C0 M
LuData Val;$ B1 a7 {; Z4 m: f
if(!InitLu()) return; //初始化Lu8 v; w1 Z1 k\\" `; b
while(LockKey(Matrix,DelMatrix,OpMatrix)){Matrix--;} //锁定一个键，用于存储矩阵扩展类型) B7 C2 F% t\\" Z
& y r$ d: |\\" d\\" w/ y p
Val.BType=luStaData_int64; Val.VType=luStaData_int64; Val.x=Matrix; //定义整数常量
0 I! l+ P- k! @+ h* Y( ?) Z
SetConst(L"matrix",&Val); //设置整数常量
% u2 @: S2 ?+ m, s8 |* \8 l) ], t! j1 L
InsertKey("\0\0\0\0",4,luPubKey_User,LuMessage,NULL,NULL,1,v); //使Lu运行时可输出函数信息
. o7 s1 |' v! z, p
wcout.imbue(locale("chs")); //设置输出的locale为中文* l+ |; g\\" U. C: w+ R9 ^2 r$ j. O+ q
\\" Y% C& h0 i( b/ K
ErrCode=LuCom(ForStr,0,0,0,hFor,nPara,pPara,ErrBegin,ErrEnd); //编译表达式
+ L3 B+ A$ }5 m8 p. g
if(ErrCode)2 a& _( I4 q8 [( ~5 v
{
) J/ }4 o1 A' K1 j6 j$ ~
wcout<<L"表达式有错误！错误代码："<<ErrCode<<endl;
f* C6 s8 D3 n3 l7 j2 ]; p$ l
}
4 X8 z4 U: _( _+ W& }+ \
else
( E+ I ?& g. r$ H$ \
{2 h# u! ^( y\\" ~9 `: q
LuCal(hFor,pPara); //计算表达式的值1 I8 o& R' _- d\\" r
}8 B3 U* D! [+ `- Y1 s
LockKey(Matrix,NULL,OpMatrix);//解锁键Matrix，本例中，该函数可以不用7 X1 H' ]: q- d; m8 ^( X
FreeLu(); //释放Lu
( W- `( _1 W\\" l& I r
}

#include <windows.h>' d) R4 F  r6 e( Z4 j7 q0 R

#include <iostream> 
- C\\" J% V( H2 ]9 |; A
#include <math.h>1 h( y. F) F+ Z' N! \

#include "lu32.h" 
( I/ i+ Y% [\\" v
#pragma comment( lib, "lu32.lib" )- K\\" K\\" V\\" k: B

using namespace std;0 a1 L4 l  I1 V: W

//自定义矩阵2 Z* W7 I1 ?- d

class myMatrix+ \: e- B& w1 x  H' n; d8 R

{) E8 r) {5 N5 c- {9 `

public: 
1 J' |; |1 W. w4 }8 t
        double *Array;        //数据缓冲区 
) s8 x# \9 T: b/ s
        luVOID ArrayLen;        //数据缓冲区长度 
* [( X+ P& j) D; F. G
        luVOID Dim[2];        //矩阵维数' D4 k' O7 G0 A$ ~0 _) [

myMatrix(){Array=NULL; ArrayLen=0; Dim[0]=0; Dim[1]=0;} 
- k+ g- H1 H5 t
        ~myMatrix()  f2 \, u2 U- Y/ M

{ 
0 d% t7 ], |  B# @  V
                if(Array) delete[] Array;- F6 l2 f  C) K- N

} 
\\" _6 o( g\\" s5 t) P: q  H: x; {
}; 
2 ~' w/ w$ |0 F+ Z. p! M) y5 |
luKEY Matrix=-1000;        //标识矩阵类型，最终的Matrix由LockKey决定 
$ [7 T& I# A! p0 E
void _stdcall LuMessage(wchar_t *pch)//输出动态库信息，该函数注册到Lu，由Lu二级函数调用   N& Z( U\\" W4 m3 p

{  |8 x\\" P  |3 y3 g

wcout<<pch; 
, ~/ J* B' d/ G, E0 B* f
}* ~\\" B. {' ?: b( E

void _stdcall DelMatrix(void *me)        //用于LockKey函数及InsertKey函数，使Lu能自动销毁myMatrix对象 
. b  z& _' F: |- K) t1 {, t
{; G) U( U\\" }3 M7 c/ w, e7 {

delete (myMatrix *)me; 
, w& A' F7 l6 v
} 
+ S5 d4 s2 K0 F2 \9 v# R8 C
myMatrix * _stdcall NewMatrix(luVOID m,luVOID n)        //生成一个myMatrix对象# s8 p0 p7 Q$ T& g4 @0 _

{1 O9 e$ K+ L\\" @' c3 E

myMatrix *pMatrix; 
* _0 T\\" U\\" ?* |
        luVOID k; 
% G+ A$ y( E1 c2 t- Z# ]
        double *pa;  X: p/ i) P4 x7 \7 H% d! T( K

char keyname[sizeof(luVOID)];  ~/ |( i1 K7 t- k0 r

void *NowKey;) ?* v/ S. w8 J& R/ s

k=m*n; 
% a# A, D/ T$ o$ E# E$ `\\" u# W
        pMatrix=(myMatrix *)GetBufObj(Matrix,keyname);//先尝试从缓冲区中获取一个矩阵对象: |6 \, y5 V& d8 V7 a$ h

if(pMatrix) 
! t. s0 C3 |& q2 M1 m8 ~' ^7 j( p# [
        { 
8 K3 B* n/ D! i+ [9 }) y
                if(pMatrix->ArrayLen!=k)        //重置矩阵的大小 
4 `\\" `6 {& {$ Q  H! ^% G( z
                { 
/ |$ E6 k- d4 o) _/ I) ]5 o
                        pa=new double[k]; 
3 F2 w/ W\\" V9 _
                        if(!pa) 
9 x4 U: H& z1 r1 p' z7 m$ g
                        {8 Z9 }. I; o% k\\" J. O& T) e8 {

DeleteKey(keyname,sizeof(luVOID),Matrix,DelMatrix,1);        //将矩阵对象放回缓冲区$ y\\" v) y( m7 \5 `: I! G8 j

return NULL;! k3 Q; U- b9 N$ {2 R$ Q

}: J& A8 {; H% U3 s0 u& y\\" R1 N

delete[] pMatrix->Array; 
3 W& E. |8 q4 M* H
                        pMatrix->Array=pa;+ U: o! U$ j\\" d, r

} 
# h% b+ O/ I, A& M, Z1 J. X9 I
        } 
' a3 F8 j2 M4 q% f* f8 M; I5 e% i
        else$ w7 I6 E* ?, `& o

{' J1 R/ M* H\\" U- m7 F/ \) t* k9 f

pMatrix=new myMatrix;        //创建矩阵对象  }6 N: ^\\" N9 `7 Z% Z: }) @

if(!pMatrix) return NULL; 
; j6 h\\" f+ y6 G! K( I4 H
                pMatrix->Array=new double[k];  u) [7 g/ o8 M* H' H$ n- y

if(!pMatrix->Array)- Y6 q5 W+ J6 t6 C

{0 [# N1 k( f9 f1 R\\" s

delete pMatrix;: D+ V2 i, R$ ~% s, f\\" r% E3 Z

return NULL; 
* Y6 h6 a  E7 A+ N3 x* X: R' O7 G
                }% U% e' {) c8 V1 n! g

if(InsertKey((char *)&pMatrix,-1,Matrix,pMatrix,DelMatrix,NULL,0,NowKey))        //将矩阵对象注册到Lu2 @* J- p# x7 t8 U; h* M  t

{/ e7 b5 ]8 M% B

delete pMatrix; 
, D1 V! Y1 Q7 `8 a. f
                        return NULL; 
( G% w& R6 d& u. M( I1 {
                } 
) ]\\" t, x$ I5 o* {
        } 
! y5 }. \2 X: t- `) U
        pMatrix->ArrayLen=k; pMatrix->Dim[0]=m; pMatrix->Dim[1]=n; 
9 g# B4 p* @6 n
        return pMatrix;- k. y8 B* O1 l0 A

} 
$ }3 E* [& A; G7 Y1 G( d% O
LuData _stdcall OpMatrix(luINT mm,LuData *xx,void *hFor,int theOperator)        //运算符重载函数，用于LockKey函数 
4 L; M6 @6 `( L* M8 ?
{- ~) Z5 U  }+ i0 m0 h

LuData a; 
; N% S, C4 l' X
        myMatrix *pMatrix1,*pMatrix2,*pMatrix3;# v1 l; s& U! `\\" q) [1 L* b

luVOID i,j,k,m,n,u,v; 
! u- h7 B% V1 \; M4 h6 B2 }
        double *pa,*pb,*pc; 
0 k1 G: O$ ]+ a  l% A
        luMessage pMessage; 
/ f: |# Z* x+ V2 q- y
        wchar_t wchNum[32]; 
: l; Z  [1 _, W1 c
        char chNum[32];. x& F1 q) |% {\\" t* B

a.BType=luStaData_nil; a.VType=luStaData_nil; a.x=0;/ g5 H* H; M9 `0 S

switch(theOperator)* O\\" @; i# k. X1 {

{$ r7 ]8 B% f( Z+ D

case 2:        //重载运算符* 
* U. Y. E( a. F
                pMatrix1=(myMatrix *)SearchKey((char *)&(xx->x),sizeof(luVOID),Matrix);* R% R8 B* D+ A/ U6 _

pMatrix2=(myMatrix *)SearchKey((char *)&((xx+1)->x),sizeof(luVOID),Matrix); 
- a3 D\\" S- B# m; V. C/ c
                if(!pMatrix1 || !pMatrix2) break;        //对象句柄无效，不是矩阵 
; c* ~0 h% G& g& G9 [! H1 k6 t1 t( P
                if(pMatrix1->Dim[1]!=pMatrix2->Dim[0]) break;        //维数不匹配8 g- X0 k\\" a% Q3 X& Q/ O

pMatrix3=NewMatrix(pMatrix1->Dim[0],pMatrix2->Dim[1]);        //生成新矩阵# M% G. ~, M, [% T5 u) q# U0 f1 X

if(!pMatrix3) break;9 r& t) Y7 F9 C; c' r! Y

pa=pMatrix1->Array; pb=pMatrix2->Array; pc=pMatrix3->Array; 
& X; s# G  I2 j/ O. D
                m=pMatrix1->Dim[0]; n=pMatrix1->Dim[1]; k=pMatrix2->Dim[1]; 
5 m# G6 S7 ]5 j- N/ g7 Y
                for(i=0; i<m; i++)        //矩阵乘/ E( {* ~- T+ n* I: s

{! n7 _. H\\" S5 A. Z4 ]8 E! v2 J5 z

for(j=0; j<k; j++) 
9 V& E( Y0 V* z4 Y% R- J
                        {' c, E! a\\" `5 c' p% ~# a

u=i*k+j; pc[u]=0.0; 
& I2 [2 t. T5 g4 d  g- k
                                for (v=0; v<n; v++)! x( H1 k% v1 s! }' d9 k

{ 
% I- f9 D# r0 Q! O- S1 b
                                        pc[u]=pc[u]+pa[i*n+v]*pb[v*k+j];: r- |1 z, T, i8 \3 @5 J9 r

} 
% K. y7 u4 l3 D- `; |7 t
                        } 
- E; G0 p5 r7 C) ?. c: w
                }, J/ W: I+ w5 J

FunReObj(hFor);        //告诉Lu，返回一个动态对象' J! L' V* j% E. [7 x+ K4 `. p

a.BType=Matrix; a.VType=Matrix; a.x=0; *(luVOID *)&(a.x)=(luVOID)pMatrix3;& E* z# H7 |; E/ [$ W

break; 
( w9 b  B3 U  {0 e  Y8 c' B( s
        case 25:        //重载运算符.* 
7 q* ]+ q# j. c! z\\" h
                pMatrix1=(myMatrix *)SearchKey((char *)&(xx->x),sizeof(luVOID),Matrix);8 [2 c6 n- T; I( j) s3 |! x

pMatrix2=(myMatrix *)SearchKey((char *)&((xx+1)->x),sizeof(luVOID),Matrix); 
5 _2 H) D6 Z( M7 U1 L
                if(!pMatrix1 || !pMatrix2) break;        //对象句柄无效，不是矩阵 
; r\\" m1 z4 {  K5 N; ^- S) Z
                if(pMatrix1->Dim[0]!=pMatrix2->Dim[0] || pMatrix1->Dim[1]!=pMatrix2->Dim[1]) break;        //维数不相同! H! D3 N: f0 D* l1 B: z

pMatrix3=NewMatrix(pMatrix1->Dim[0],pMatrix1->Dim[1]);        //生成新矩阵 
3 k! I. u\\" g- d1 @; Y
                if(!pMatrix3) break; 
  n6 N, N! k% m! _
                for(i=0;i<pMatrix1->ArrayLen;i++) pMatrix3->Array[i]=pMatrix1->Array[i]*pMatrix2->Array[i];        //矩阵点乘 
% L( h7 I- \+ l# G
                FunReObj(hFor);        //告诉Lu，返回一个动态对象6 ?, a& w/ |' ~0 n  d' f/ l7 M

a.BType=Matrix; a.VType=Matrix; a.x=0; *(luVOID *)&(a.x)=(luVOID)pMatrix3; 
8 d2 l0 l7 B2 L. [: r# C7 K
                break; 
; J, J* {) `7 ?' m
        case 46:        //重载函数new 
1 i% l- b# [/ }& _2 ?* z
                if(mm<2) break; 
/ ?8 @3 q6 g! ?- i6 F% j' ?
                if((xx+1)->x<1 || (xx+2)->x<1 || (xx+1)->BType!=luStaData_int64 || (xx+2)->BType!=luStaData_int64) break;. X; K: X0 n, s6 u8 j+ v

pMatrix3=NewMatrix((luVOID)(xx+1)->x,(luVOID)(xx+2)->x);//生成新矩阵( M6 Y. x: z& J& @) ^

if(!pMatrix3) break; 
\\" }3 f- E3 |7 G; H. X7 O
                for(j=0,i=3;i<=mm;i++,j++)        //赋初值: t& c& x5 H' t& \0 h* d$ N

{0 ]* w\\" @7 s6 |1 e

if(j>=pMatrix3->ArrayLen) break;1 K& e' U/ i9 [. M6 B# ^

if((xx+i)->BType!=luStaData_double) break;        //只接受实数参数 
5 u\\" J0 `0 i+ w+ Z$ W
                        pMatrix3->Array[j]=*(double *)&((xx+i)->x);) `/ @8 B& X# Y

}4 N  z+ G% F: W0 q- p: C

FunReObj(hFor);        //告诉Lu，返回一个动态对象; Q( I1 @, z/ J

a.BType=Matrix; a.VType=Matrix; a.x=0; *(luVOID *)&(a.x)=(luVOID)pMatrix3;+ C+ r  E  n2 K; {6 J/ K$ I( b, U

break; 
+ x; ?5 f8 r8 N5 X$ P0 {9 N
        case 49:        //重载函数o 
9 n6 \$ }3 \0 N
                pMessage=(luMessage)SearchKey("\0\0\0\0",sizeof(luVOID),luPubKey_User);: }' x. Q\\" e' O9 t8 e4 L5 \1 I

if(!pMessage) break;5 w2 e: ^% ?6 I5 _$ P+ B) p

pMatrix1=(myMatrix *)SearchKey((char *)&(xx->x),sizeof(luVOID),Matrix);# u1 U$ O\\" k  @2 D. K

if(!pMatrix1) break;        //对象句柄无效，不是矩阵 
1 j: j- R. h3 z  h* p' r3 r
                pa=pMatrix1->Array;8 _% ]+ E, Q, G4 C1 |

m=pMatrix1->Dim[0]; n=pMatrix1->Dim[1]; k=0; 
- I) f2 M2 O8 ]! J2 n( J8 C8 [- D
                for(i=0; i<m; i++)        //输出矩阵: H4 q) N: q7 x\\" e6 R  h: \1 \0 z/ W) R

{ 
  l2 P1 j/ s! P2 [0 e
                        pMessage(L"\r\n"); k+=2; 
, A& N# t+ J8 Y; K# M* @
                        for(j=0; j<n; j++) 
$ d  m4 E! M8 x. A& R; X
                        {! t! L# s5 `0 [6 V+ n

_gcvt_s(chNum,pa[i*n+j],16); 
5 e$ m& ^: k% J- L
                                for(u=0;chNum[u];u++) {wchNum[u]=chNum[u]; k++;} 
7 {' B9 z0 f$ A, r6 c
                                wchNum[u]='\0';; U8 ^  {3 F\\" k\\" F

pMessage(wchNum); pMessage(L"  "); k+=2; 
/ z! J! @) X+ s\\" j. _! B9 B
                        } 
! w\\" I4 |/ C7 e7 U3 X$ b
                }+ S% {9 C% ^, N. [' X( Z3 }

pMessage(L"\r\n"); k+=2;3 `% L! ^5 U\\" Y) D, e6 p% {: Q

a.BType=luStaData_int64; a.VType=luStaData_int64; a.x=k;        //按函数o的要求，返回输出的字符总数 
5 X9 C  o( A/ p$ w) u
                break; 
/ O  K. d, Q\\" R, g; b- N
        default:9 ^4 J5 j, r5 \- z

break; 
* y. S: t# }' e$ A; }6 v  l0 B  |9 P
        }+ V  y% F$ x5 \7 d: O+ c

return a;4 F: |1 i# o7 ?3 b+ X* z

} 
. D) b! Y. J  _* x
void main(void) 
9 S( b( @7 j3 J3 Q
{7 n7 V# Z' f' J, H, e

void *hFor;                //表达式句柄 
7 C8 ~, S( U2 i) Q
        luINT nPara;                //存放表达式的自变量个数9 e  R& M+ w8 Z9 [# e

LuData *pPara;                //存放输入自变量的数组指针1 s5 n& }% N3 L6 _' ?+ C/ R

luINT ErrBegin,ErrEnd;        //表达式编译出错的初始位置和结束位置 
/ l/ a4 m  G/ |2 G& W, ~$ F; b
        int ErrCode;                //错误代码 
/ P/ t- v. x7 p' j
        void *v;0 c0 @+ l2 V- j6 s/ `

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.]}";//字符串表达式，矩阵乘 
# W& V# c: ]0 W* d
        //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.]}";//字符串表达式，矩阵点乘 
8 a0 Y: u+ J9 C0 M
        LuData Val;$ B1 a7 {; Z4 m: f

if(!InitLu()) return;        //初始化Lu8 v; w1 Z1 k\\" `; b

while(LockKey(Matrix,DelMatrix,OpMatrix)){Matrix--;}        //锁定一个键，用于存储矩阵扩展类型) B7 C2 F% t\\" Z

& y  r$ d: |\\" d\\" w/ y  p

Val.BType=luStaData_int64; Val.VType=luStaData_int64; Val.x=Matrix;        //定义整数常量 
0 I! l+ P- k! @+ h* Y( ?) Z
        SetConst(L"matrix",&Val);        //设置整数常量 
% u2 @: S2 ?+ m, s8 |* \8 l) ], t! j1 L
        InsertKey("\0\0\0\0",4,luPubKey_User,LuMessage,NULL,NULL,1,v); //使Lu运行时可输出函数信息 
. o7 s1 |' v! z, p
        wcout.imbue(locale("chs"));        //设置输出的locale为中文* l+ |; g\\" U. C: w+ R9 ^2 r$ j. O+ q

\\" Y% C& h0 i( b/ K

ErrCode=LuCom(ForStr,0,0,0,hFor,nPara,pPara,ErrBegin,ErrEnd); //编译表达式 
+ L3 B+ A$ }5 m8 p. g
        if(ErrCode)2 a& _( I4 q8 [( ~5 v

{ 
) J/ }4 o1 A' K1 j6 j$ ~
                wcout<<L"表达式有错误！错误代码："<<ErrCode<<endl; 
  f* C6 s8 D3 n3 l7 j2 ]; p$ l
        } 
4 X8 z4 U: _( _+ W& }+ \
        else 
( E+ I  ?& g. r$ H$ \
        {2 h# u! ^( y\\" ~9 `: q

LuCal(hFor,pPara);        //计算表达式的值1 I8 o& R' _- d\\" r

}8 B3 U* D! [+ `- Y1 s

LockKey(Matrix,NULL,OpMatrix);//解锁键Matrix，本例中，该函数可以不用7 X1 H' ]: q- d; m8 ^( X

FreeLu();                        //释放Lu 
( W- `( _1 W\\" l& I  r
}

习题：

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

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

main(:a,b,c,d,t,i)=$ |( D0 u) @5 v
a=new[matrix,2,2: 1.,2.,2.,1.],$ y$ n\" d0 X4 O' i- K. E2 o* h
b=new[matrix,2,2: 2.,1.,1.,2.],8 U- T2 P) W% u9 Y# {' @% b( m' C
c=new[matrix,2,2: 2/3.,-1/3.,-1/3.,2/3.],
- j5 b: b$ i0 v4 E5 S( ]
t=clock(),# x* h' ?\" ]6 [
d=a*b, i=0, while{i<1000000, d=d*c*b, i++},
2 J9 ]3 A2 ~! Q, F# w
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\"}";//字符串表达式

复制代码

结果：