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

查看: 9039|回复: 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>9 q% Y8 n1 A' s8 M* n
#include <iostream>\\" _! W% t& P; F2 R1 [/ W2 `* Q
#include <math.h>
/ Y* U3 W* f8 D! R/ x
#include "lu32.h"* W# Y* H! ^1 v5 Q
#pragma comment( lib, "lu32.lib" )1 p X4 u0 n% z+ R! I, O2 O3 W( X9 [
using namespace std;
4 d% L/ l- M9 n( I5 U/ J* P
//自定义矩阵
& t3 C5 q8 w8 P( ^. _
class myMatrix
$ [& [1 s\\" X: t; j
{
. x! l7 e9 S! N0 c! h+ U
public:, a- U& b$ ]( w2 R0 I# D
double *Array; //数据缓冲区
7 h! X6 E+ |' _/ `, s5 j# ^4 h
luVOID ArrayLen; //数据缓冲区长度 a\\" E: q0 s/ h( a
luVOID Dim[2]; //矩阵维数4 k\\" y) t$ \\\" R
myMatrix(){Array=NULL; ArrayLen=0; Dim[0]=0; Dim[1]=0;}
$ L3 ^5 w7 w: K7 ~/ d
~myMatrix()
. d L8 `# t; L: X: X
{
4 o6 L: x6 N# u( w1 [
if(Array) delete[] Array;
1 n0 ?' I3 |* K0 _! Q# K# F
}& y! T6 Q/ v: \' r1 N; y
}; m' V7 s3 z# B3 j\\" {/ F
luKEY Matrix=-1000; //标识矩阵类型，最终的Matrix由LockKey决定! d( F+ H$ t8 K; m
void _stdcall LuMessage(wchar_t *pch)//输出动态库信息，该函数注册到Lu，由Lu二级函数调用 6 \' _' |! U @5 r! D t
{5 v9 S4 r; o3 r
wcout<<pch;
, a/ }! S5 ~3 D, H0 G
}
& m' Y; w7 H( ^9 ^* U# _& C1 |
void _stdcall DelMatrix(void *me) //用于LockKey函数及InsertKey函数，使Lu能自动销毁myMatrix对象
2 @# D9 ~: v; x; s$ A- M
{
& z$ \/ a% N4 W1 @8 i% Z- F
delete (myMatrix *)me;' v0 k' f' r. m, p. c& r! L
}# {2 ?1 E2 S, ?/ }. B
myMatrix * _stdcall NewMatrix(luVOID m,luVOID n) //生成一个myMatrix对象- E8 D! \* @6 Q! A) S% s0 e
{) r* f/ D: p% S1 g1 X1 W- K0 V) M& k
myMatrix *pMatrix;5 R0 b4 {4 R! V! v
luVOID k;$ v) G1 C% n* Z! r# q& g
double *pa;
8 I+ Y/ K$ n1 i. B: J; \4 a# N
char keyname[sizeof(luVOID)];
4 ~) Z: b- X, z\\" V; t* j$ e
void *NowKey;
5 U) j% P6 x% `# T* Y- Y
k=m*n;* B9 a0 g: U8 v& C7 n
pMatrix=(myMatrix *)GetBufObj(Matrix,keyname);//先尝试从缓冲区中获取一个矩阵对象* G) n- _7 }6 ]! p9 v7 N
if(pMatrix)1 K3 |6 I+ l$ {+ K; d
{
# K, W6 C( |& q; }
if(pMatrix->ArrayLen!=k) //重置矩阵的大小8 \; h Y9 v r; ]5 ~
{* s0 Z\\" Z' V9 l
pa=new double[k];- C3 D* t% c+ z+ M
if(!pa)# A/ |5 A( z8 O) O' \; r\\" R7 a) z
{9 I& |, x' e1 z
DeleteKey(keyname,sizeof(luVOID),Matrix,DelMatrix,1); //将矩阵对象放回缓冲区
' D1 W; n- x\\" N. ]8 a! o
return NULL;% o& x* u( p\\" A9 k8 C1 ]* Q- i
}, U1 @# R# @; w# G+ C: E1 x
delete[] pMatrix->Array;5 a/ o5 N: h1 T* D! o& g
pMatrix->Array=pa;
' ~& Y3 x# b9 V3 s0 D
}
/ y; ?5 ~. w N
}
% [- {; I3 Y\\" R3 [4 e, R# u
else; u/ b\\" j+ y0 v; C& D\\" @; v, g
{
5 D# @, U7 q9 x: h, l7 t
pMatrix=new myMatrix; //创建矩阵对象
; [$ }6 |5 W; j8 n$ G: S4 U5 |
if(!pMatrix) return NULL;* E( z; B8 N+ g* w5 W- r7 g/ p
pMatrix->Array=new double[k];
/ w1 J: @, Z) ?3 s! z2 D4 F
if(!pMatrix->Array)
I7 g F( l6 v& Q) f
{9 C: B\\" ]& T% B
delete pMatrix;4 W( x' [0 [! H\\" e
return NULL;
j1 P2 V! D0 ~7 i$ G- |
} j0 F2 t5 r) p# V$ L3 {
if(InsertKey((char *)&pMatrix,-1,Matrix,pMatrix,DelMatrix,NULL,0,NowKey)) //将矩阵对象注册到Lu
8 o V9 B4 b. B# |' Y u4 W
{5 g; G0 b( z1 `# z5 Z
delete pMatrix;1 D- V2 h+ z+ N9 z3 z, K5 c
return NULL;
; I0 D9 c\\" |0 {/ w6 `8 s4 C& h! L
}: [( M4 ]8 i\\" L+ b2 ^* A' s7 k* ^) c. e$ C
}1 a9 b9 F7 y6 B. T0 s- _5 \& |
pMatrix->ArrayLen=k; pMatrix->Dim[0]=m; pMatrix->Dim[1]=n;4 Y5 {5 A6 G2 S- t1 t( M
return pMatrix;
$ o: G, a+ T4 W1 w
}
1 o8 S& {- n\\" X* P
LuData _stdcall OpMatrix(luINT mm,LuData *xx,void *hFor,int theOperator) //运算符重载函数，用于LockKey函数
. I8 i9 `/ A- k: k
{
3 C5 P+ Y$ s; H8 T+ P\\" S
LuData a;, L3 a4 Y0 J2 i: D
myMatrix *pMatrix1,*pMatrix2,*pMatrix3;
- \- `7 C! s J- s6 x7 ? p8 B
luVOID i,j,k,m,n,u,v;
. N5 l/ Y3 y$ \2 @, y
double *pa,*pb,*pc;
\\" G0 z: n% q% x2 ]* h! {0 q7 E
luMessage pMessage;# d# I/ R. {6 n: i& @\\" p
wchar_t wchNum[32];
( [% M1 O4 l% E2 B' @
char chNum[32];. d0 }+ }* f0 H' Y
a.BType=luStaData_nil; a.VType=luStaData_nil; a.x=0;4 `. E5 C1 c* B0 D
switch(theOperator)
@, U! z: K5 r
{) l% j. Q3 G, y- y8 `& L
case 2: //重载运算符*% v! L# {) B) s& m' w9 p% z
pMatrix1=(myMatrix *)SearchKey((char *)&(xx->x),sizeof(luVOID),Matrix);
6 T% Z0 I4 ~' `7 G
pMatrix2=(myMatrix *)SearchKey((char *)&((xx+1)->x),sizeof(luVOID),Matrix);
- E$ u! f H2 J9 A6 ^6 E
if(!pMatrix1 || !pMatrix2) break; //对象句柄无效，不是矩阵; r( \6 K3 C* C K/ U# m! n
if(pMatrix1->Dim[1]!=pMatrix2->Dim[0]) break; //维数不匹配& ?, {- O2 d8 c. t6 M' D
pMatrix3=NewMatrix(pMatrix1->Dim[0],pMatrix2->Dim[1]); //生成新矩阵
/ o; h- Z+ F+ A6 Q; w\\" E
if(!pMatrix3) break;( z7 e; Z/ f' W$ C& G
pa=pMatrix1->Array; pb=pMatrix2->Array; pc=pMatrix3->Array;
! A# K( L9 ?# a- V
m=pMatrix1->Dim[0]; n=pMatrix1->Dim[1]; k=pMatrix2->Dim[1];% V- K# F9 j) p# ^0 z, \
for(i=0; i<m; i++) //矩阵乘
: s: L3 z, c* {9 X& x- k' S
{1 a6 v3 T9 M1 y) R5 X
for(j=0; j<k; j++)7 q, M$ v4 S$ Q& m
{
9 R( {/ B& D4 v% z X
u=i*k+j; pc[u]=0.0;
3 {/ _( L9 A0 |
for (v=0; v<n; v++)5 k5 v/ O( D2 _% S% t
{* _5 B) m! M( t/ p& A0 l1 R0 U
pc[u]=pc[u]+pa[i*n+v]*pb[v*k+j];
. [. ~1 s K2 J2 _6 y
}- L2 J: ~5 }& Z6 W+ q
}
$ N4 w0 \# a6 y( W, @$ W1 C+ U1 A
}5 r, z/ `! p2 }/ B+ Q
FunReObj(hFor); //告诉Lu，返回一个动态对象
- O) S# H7 `2 S
a.BType=Matrix; a.VType=Matrix; a.x=0; *(luVOID *)&(a.x)=(luVOID)pMatrix3;, u. x* ^: u4 W W0 m
break;
4 J5 D+ v' b; v6 M9 @
case 25: //重载运算符.*
+ x4 |( i6 [& V# T$ u
pMatrix1=(myMatrix *)SearchKey((char *)&(xx->x),sizeof(luVOID),Matrix);
. Y! y' s9 e; |/ p
pMatrix2=(myMatrix *)SearchKey((char *)&((xx+1)->x),sizeof(luVOID),Matrix);
) E1 H3 D0 ]- h, f) A
if(!pMatrix1 || !pMatrix2) break; //对象句柄无效，不是矩阵! t4 Z0 I. s U6 N% P( g8 ^\\" t( Q0 u
if(pMatrix1->Dim[0]!=pMatrix2->Dim[0] || pMatrix1->Dim[1]!=pMatrix2->Dim[1]) break; //维数不相同
; q5 V) S& @3 `( {
pMatrix3=NewMatrix(pMatrix1->Dim[0],pMatrix1->Dim[1]); //生成新矩阵
' b) h9 Z$ b7 r1 s6 f
if(!pMatrix3) break;
' [6 i2 [9 ? n: Q# c
for(i=0;i<pMatrix1->ArrayLen;i++) pMatrix3->Array[i]=pMatrix1->Array[i]*pMatrix2->Array[i]; //矩阵点乘
4 L; s9 d8 a$ W8 Z# h9 ^* s
FunReObj(hFor); //告诉Lu，返回一个动态对象8 G9 P: m2 \ Z' o$ ?
a.BType=Matrix; a.VType=Matrix; a.x=0; *(luVOID *)&(a.x)=(luVOID)pMatrix3;
6 N5 i' T% t0 ?8 X' H9 C6 q
break;
: F: p/ n& O) b& f P7 U& X6 U, F
case 46: //重载函数new7 j* t! y) b4 j* c/ v
if(mm<2) break;
6 @& h$ r\\" R; s3 i
if((xx+1)->x<1 || (xx+2)->x<1 || (xx+1)->BType!=luStaData_int64 || (xx+2)->BType!=luStaData_int64) break;7 N, i* O7 ~+ F7 d$ M: k
pMatrix3=NewMatrix((luVOID)(xx+1)->x,(luVOID)(xx+2)->x);//生成新矩阵8 r1 [: Q! E6 P, o6 [8 s
if(!pMatrix3) break;
for(j=0,i=3;i<=mm;i++,j++) //赋初值
\\" ]( ^, I5 q. \
{
7 E: j, g$ u/ D% e
if(j>=pMatrix3->ArrayLen) break;
* Y$ D9 J7 N D6 d1 D
if((xx+i)->BType!=luStaData_double) break; //只接受实数参数( l6 f1 G6 [; }- P0 j
pMatrix3->Array[j]=*(double *)&((xx+i)->x);
$ d5 d8 X\\" x$ ]: o% w0 {
}4 U6 o3 m8 E7 x! \ C* l! X' V
FunReObj(hFor); //告诉Lu，返回一个动态对象, n$ Z7 N4 [6 h5 D& D6 O4 ]. i
a.BType=Matrix; a.VType=Matrix; a.x=0; *(luVOID *)&(a.x)=(luVOID)pMatrix3;! J/ E: ], U, @. D8 v
break;6 |9 G7 m8 |1 U* M\\" ]* e
case 49: //重载函数o4 j4 c4 ~( G. g: q
pMessage=(luMessage)SearchKey("\0\0\0\0",sizeof(luVOID),luPubKey_User);0 U. C; f4 f! I) ^# ]\\" I! ~7 d2 {& \
if(!pMessage) break;/ i& r+ z3 Y1 N# d1 }, l
pMatrix1=(myMatrix *)SearchKey((char *)&(xx->x),sizeof(luVOID),Matrix);
0 w) i( d9 h x2 e\\" I2 [3 ^6 y0 ]
if(!pMatrix1) break; //对象句柄无效，不是矩阵
- B- m: o; Z( \& |# b; W& `! I
pa=pMatrix1->Array;
) i G' _) `4 I3 \
m=pMatrix1->Dim[0]; n=pMatrix1->Dim[1]; k=0;
4 K; j* h) @) H+ A0 t+ P
for(i=0; i<m; i++) //输出矩阵
/ P$ _' B3 K5 r3 w
{& S( ]1 Q\\" l# H
pMessage(L"\r\n"); k+=2;# m\\" @( g7 M) w5 i3 H. ^) S) ]
for(j=0; j<n; j++)
\\" }% _1 I6 y% L* e- [
{\\" O) X2 B, X) j( D9 S
_gcvt_s(chNum,pa[i*n+j],16);- q# M, Z9 X8 _$ x- c% P+ P$ `% {
for(u=0;chNum[u];u++) {wchNum[u]=chNum[u]; k++;}! Z\\" F& M* U) Y! o- i\\" Z
wchNum[u]='\0';
% R) r3 \1 N1 w. F4 e4 f
pMessage(wchNum); pMessage(L" "); k+=2;
7 x9 J/ v# z1 r X0 O
}
2 d& r) B\\" q\\" ~) ?! r( P; L
}
% B. [4 j1 G% v+ T# {: L
pMessage(L"\r\n"); k+=2;
0 ?8 m\\" ` h; { i% P) ^- [' P& L
a.BType=luStaData_int64; a.VType=luStaData_int64; a.x=k; //按函数o的要求，返回输出的字符总数
5 x4 T; g: i+ x# z) F5 t0 C) G
break;
) w# j/ T$ ^- {0 U) M
default:! t5 S- q. b/ F* o* D
break;/ N1 ~8 j) S2 V! S\\" s
}
/ i4 h% s0 Z2 X) p
return a;& ^( Y6 K6 v0 H$ c
}+ [' }8 l2 K' S& D
void main(void). q; }8 U$ V5 G5 ~
{
. r# ?4 p\\" V4 K7 }9 s/ E) b9 d
void *hFor; //表达式句柄4 e5 M* i) H9 U
luINT nPara; //存放表达式的自变量个数
' h3 i O7 C, X2 R% e, K& ]
LuData *pPara; //存放输入自变量的数组指针. e- v; ?. L2 T1 \& J* r4 i; \
luINT ErrBegin,ErrEnd; //表达式编译出错的初始位置和结束位置# K7 s, w& Q, j; b% r+ H
int ErrCode; //错误代码
, }7 I9 [ }( s9 X/ ?
void *v;+ m/ s1 M) t0 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.]}";//字符串表达式，矩阵乘, {; u\\" m9 v; O! |
//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.]}";//字符串表达式，矩阵点乘# |. q! ~\\" j3 V/ ?: R
LuData Val;
; x7 t- k$ S' }1 m! V& E5 s
if(!InitLu()) return; //初始化Lu* q/ ]' I) l; i$ E- x
while(LockKey(Matrix,DelMatrix,OpMatrix)){Matrix--;} //锁定一个键，用于存储矩阵扩展类型
0 z* n& v$ i! ?
6 t \ W6 I) U
Val.BType=luStaData_int64; Val.VType=luStaData_int64; Val.x=Matrix; //定义整数常量0 o& N3 m8 ?\\" n4 \7 e5 J& U
SetConst(L"matrix",&Val); //设置整数常量
7 @& ~& [5 T2 ]1 c w
InsertKey("\0\0\0\0",4,luPubKey_User,LuMessage,NULL,NULL,1,v); //使Lu运行时可输出函数信息% c: Y3 ^ R9 i Y! A# y6 H' e: @- @
wcout.imbue(locale("chs")); //设置输出的locale为中文3 M, Y! A/ p* ], Y6 o5 K2 w
/ J; e+ c. W; n6 x. N9 F
ErrCode=LuCom(ForStr,0,0,0,hFor,nPara,pPara,ErrBegin,ErrEnd); //编译表达式
2 i$ w$ U. E, B/ U+ E; i
if(ErrCode)
3 p$ \: i$ z$ j0 J
{
) `9 J\\" O! Z% R% V
wcout<<L"表达式有错误！错误代码："<<ErrCode<<endl;
+ j2 O* S4 O) \6 i0 F, J3 s
}
: t* Q, g4 G1 Q
else
% J! S: n4 Q4 t/ s9 r+ M\\" x
{
3 v x+ a3 C; K; F/ e
LuCal(hFor,pPara); //计算表达式的值- I9 o: z! ^. |+ f# F/ P9 L5 Z: n
}
* s# A, J* U6 e; S: t
LockKey(Matrix,NULL,OpMatrix);//解锁键Matrix，本例中，该函数可以不用9 Y, H! B9 ?\\" A$ _+ x$ V: w
FreeLu(); //释放Lu+ _' i. C& f2 J# `: E/ I4 V
}

#include <windows.h>9 q% Y8 n1 A' s8 M* n

#include <iostream>\\" _! W% t& P; F2 R1 [/ W2 `* Q

#include <math.h> 
/ Y* U3 W* f8 D! R/ x
#include "lu32.h"* W# Y* H! ^1 v5 Q

#pragma comment( lib, "lu32.lib" )1 p  X4 u0 n% z+ R! I, O2 O3 W( X9 [

using namespace std; 
4 d% L/ l- M9 n( I5 U/ J* P
//自定义矩阵 
& t3 C5 q8 w8 P( ^. _
class myMatrix 
$ [& [1 s\\" X: t; j
{ 
. x! l7 e9 S! N0 c! h+ U
public:, a- U& b$ ]( w2 R0 I# D

double *Array;        //数据缓冲区 
7 h! X6 E+ |' _/ `, s5 j# ^4 h
        luVOID ArrayLen;        //数据缓冲区长度  a\\" E: q0 s/ h( a

luVOID Dim[2];        //矩阵维数4 k\\" y) t$ \\\" R

myMatrix(){Array=NULL; ArrayLen=0; Dim[0]=0; Dim[1]=0;} 
$ L3 ^5 w7 w: K7 ~/ d
        ~myMatrix() 
. d  L8 `# t; L: X: X
        { 
4 o6 L: x6 N# u( w1 [
                if(Array) delete[] Array; 
1 n0 ?' I3 |* K0 _! Q# K# F
        }& y! T6 Q/ v: \' r1 N; y

};  m' V7 s3 z# B3 j\\" {/ F

luKEY Matrix=-1000;        //标识矩阵类型，最终的Matrix由LockKey决定! d( F+ H$ t8 K; m

void _stdcall LuMessage(wchar_t *pch)//输出动态库信息，该函数注册到Lu，由Lu二级函数调用 6 \' _' |! U  @5 r! D  t

{5 v9 S4 r; o3 r

wcout<<pch; 
, a/ }! S5 ~3 D, H0 G
} 
& m' Y; w7 H( ^9 ^* U# _& C1 |
void _stdcall DelMatrix(void *me)        //用于LockKey函数及InsertKey函数，使Lu能自动销毁myMatrix对象 
2 @# D9 ~: v; x; s$ A- M
{ 
& z$ \/ a% N4 W1 @8 i% Z- F
        delete (myMatrix *)me;' v0 k' f' r. m, p. c& r! L

}# {2 ?1 E2 S, ?/ }. B

myMatrix * _stdcall NewMatrix(luVOID m,luVOID n)        //生成一个myMatrix对象- E8 D! \* @6 Q! A) S% s0 e

{) r* f/ D: p% S1 g1 X1 W- K0 V) M& k

myMatrix *pMatrix;5 R0 b4 {4 R! V! v

luVOID k;$ v) G1 C% n* Z! r# q& g

double *pa; 
8 I+ Y/ K$ n1 i. B: J; \4 a# N
        char keyname[sizeof(luVOID)]; 
4 ~) Z: b- X, z\\" V; t* j$ e
        void *NowKey; 
5 U) j% P6 x% `# T* Y- Y
        k=m*n;* B9 a0 g: U8 v& C7 n

pMatrix=(myMatrix *)GetBufObj(Matrix,keyname);//先尝试从缓冲区中获取一个矩阵对象* G) n- _7 }6 ]! p9 v7 N

if(pMatrix)1 K3 |6 I+ l$ {+ K; d

{ 
# K, W6 C( |& q; }
                if(pMatrix->ArrayLen!=k)        //重置矩阵的大小8 \; h  Y9 v  r; ]5 ~

{* s0 Z\\" Z' V9 l

pa=new double[k];- C3 D* t% c+ z+ M

if(!pa)# A/ |5 A( z8 O) O' \; r\\" R7 a) z

{9 I& |, x' e1 z

DeleteKey(keyname,sizeof(luVOID),Matrix,DelMatrix,1);        //将矩阵对象放回缓冲区 
' D1 W; n- x\\" N. ]8 a! o
                                return NULL;% o& x* u( p\\" A9 k8 C1 ]* Q- i

}, U1 @# R# @; w# G+ C: E1 x

delete[] pMatrix->Array;5 a/ o5 N: h1 T* D! o& g

pMatrix->Array=pa; 
' ~& Y3 x# b9 V3 s0 D
                } 
/ y; ?5 ~. w  N
        } 
% [- {; I3 Y\\" R3 [4 e, R# u
        else; u/ b\\" j+ y0 v; C& D\\" @; v, g

{ 
5 D# @, U7 q9 x: h, l7 t
                pMatrix=new myMatrix;        //创建矩阵对象 
; [$ }6 |5 W; j8 n$ G: S4 U5 |
                if(!pMatrix) return NULL;* E( z; B8 N+ g* w5 W- r7 g/ p

pMatrix->Array=new double[k]; 
/ w1 J: @, Z) ?3 s! z2 D4 F
                if(!pMatrix->Array) 
  I7 g  F( l6 v& Q) f
                {9 C: B\\" ]& T% B

delete pMatrix;4 W( x' [0 [! H\\" e

return NULL; 
  j1 P2 V! D0 ~7 i$ G- |
                }  j0 F2 t5 r) p# V$ L3 {

if(InsertKey((char *)&pMatrix,-1,Matrix,pMatrix,DelMatrix,NULL,0,NowKey))        //将矩阵对象注册到Lu 
8 o  V9 B4 b. B# |' Y  u4 W
                {5 g; G0 b( z1 `# z5 Z

delete pMatrix;1 D- V2 h+ z+ N9 z3 z, K5 c

return NULL; 
; I0 D9 c\\" |0 {/ w6 `8 s4 C& h! L
                }: [( M4 ]8 i\\" L+ b2 ^* A' s7 k* ^) c. e$ C

}1 a9 b9 F7 y6 B. T0 s- _5 \& |

pMatrix->ArrayLen=k; pMatrix->Dim[0]=m; pMatrix->Dim[1]=n;4 Y5 {5 A6 G2 S- t1 t( M

return pMatrix; 
$ o: G, a+ T4 W1 w
} 
1 o8 S& {- n\\" X* P
LuData _stdcall OpMatrix(luINT mm,LuData *xx,void *hFor,int theOperator)        //运算符重载函数，用于LockKey函数 
. I8 i9 `/ A- k: k
{ 
3 C5 P+ Y$ s; H8 T+ P\\" S
        LuData a;, L3 a4 Y0 J2 i: D

myMatrix *pMatrix1,*pMatrix2,*pMatrix3; 
- \- `7 C! s  J- s6 x7 ?  p8 B
        luVOID i,j,k,m,n,u,v; 
. N5 l/ Y3 y$ \2 @, y
        double *pa,*pb,*pc; 
\\" G0 z: n% q% x2 ]* h! {0 q7 E
        luMessage pMessage;# d# I/ R. {6 n: i& @\\" p

wchar_t wchNum[32]; 
( [% M1 O4 l% E2 B' @
        char chNum[32];. d0 }+ }* f0 H' Y

a.BType=luStaData_nil; a.VType=luStaData_nil; a.x=0;4 `. E5 C1 c* B0 D

switch(theOperator) 
  @, U! z: K5 r
        {) l% j. Q3 G, y- y8 `& L

case 2:        //重载运算符*% v! L# {) B) s& m' w9 p% z

pMatrix1=(myMatrix *)SearchKey((char *)&(xx->x),sizeof(luVOID),Matrix); 
6 T% Z0 I4 ~' `7 G
                pMatrix2=(myMatrix *)SearchKey((char *)&((xx+1)->x),sizeof(luVOID),Matrix); 
- E$ u! f  H2 J9 A6 ^6 E
                if(!pMatrix1 || !pMatrix2) break;        //对象句柄无效，不是矩阵; r( \6 K3 C* C  K/ U# m! n

if(pMatrix1->Dim[1]!=pMatrix2->Dim[0]) break;        //维数不匹配& ?, {- O2 d8 c. t6 M' D

pMatrix3=NewMatrix(pMatrix1->Dim[0],pMatrix2->Dim[1]);        //生成新矩阵 
/ o; h- Z+ F+ A6 Q; w\\" E
                if(!pMatrix3) break;( z7 e; Z/ f' W$ C& G

pa=pMatrix1->Array; pb=pMatrix2->Array; pc=pMatrix3->Array; 
! A# K( L9 ?# a- V
                m=pMatrix1->Dim[0]; n=pMatrix1->Dim[1]; k=pMatrix2->Dim[1];% V- K# F9 j) p# ^0 z, \

for(i=0; i<m; i++)        //矩阵乘 
: s: L3 z, c* {9 X& x- k' S
                {1 a6 v3 T9 M1 y) R5 X

for(j=0; j<k; j++)7 q, M$ v4 S$ Q& m

{ 
9 R( {/ B& D4 v% z  X
                                u=i*k+j; pc[u]=0.0; 
3 {/ _( L9 A0 |
                                for (v=0; v<n; v++)5 k5 v/ O( D2 _% S% t

{* _5 B) m! M( t/ p& A0 l1 R0 U

pc[u]=pc[u]+pa[i*n+v]*pb[v*k+j]; 
. [. ~1 s  K2 J2 _6 y
                                }- L2 J: ~5 }& Z6 W+ q

} 
$ N4 w0 \# a6 y( W, @$ W1 C+ U1 A
                }5 r, z/ `! p2 }/ B+ Q

FunReObj(hFor);        //告诉Lu，返回一个动态对象 
- O) S# H7 `2 S
                a.BType=Matrix; a.VType=Matrix; a.x=0; *(luVOID *)&(a.x)=(luVOID)pMatrix3;, u. x* ^: u4 W  W0 m

break; 
4 J5 D+ v' b; v6 M9 @
        case 25:        //重载运算符.* 
+ x4 |( i6 [& V# T$ u
                pMatrix1=(myMatrix *)SearchKey((char *)&(xx->x),sizeof(luVOID),Matrix); 
. Y! y' s9 e; |/ p
                pMatrix2=(myMatrix *)SearchKey((char *)&((xx+1)->x),sizeof(luVOID),Matrix); 
) E1 H3 D0 ]- h, f) A
                if(!pMatrix1 || !pMatrix2) break;        //对象句柄无效，不是矩阵! t4 Z0 I. s  U6 N% P( g8 ^\\" t( Q0 u

if(pMatrix1->Dim[0]!=pMatrix2->Dim[0] || pMatrix1->Dim[1]!=pMatrix2->Dim[1]) break;        //维数不相同 
; q5 V) S& @3 `( {
                pMatrix3=NewMatrix(pMatrix1->Dim[0],pMatrix1->Dim[1]);        //生成新矩阵 
' b) h9 Z$ b7 r1 s6 f
                if(!pMatrix3) break; 
' [6 i2 [9 ?  n: Q# c
                for(i=0;i<pMatrix1->ArrayLen;i++) pMatrix3->Array[i]=pMatrix1->Array[i]*pMatrix2->Array[i];        //矩阵点乘 
4 L; s9 d8 a$ W8 Z# h9 ^* s
                FunReObj(hFor);        //告诉Lu，返回一个动态对象8 G9 P: m2 \  Z' o$ ?

a.BType=Matrix; a.VType=Matrix; a.x=0; *(luVOID *)&(a.x)=(luVOID)pMatrix3; 
6 N5 i' T% t0 ?8 X' H9 C6 q
                break; 
: F: p/ n& O) b& f  P7 U& X6 U, F
        case 46:        //重载函数new7 j* t! y) b4 j* c/ v

if(mm<2) break; 
6 @& h$ r\\" R; s3 i
                if((xx+1)->x<1 || (xx+2)->x<1 || (xx+1)->BType!=luStaData_int64 || (xx+2)->BType!=luStaData_int64) break;7 N, i* O7 ~+ F7 d$ M: k

pMatrix3=NewMatrix((luVOID)(xx+1)->x,(luVOID)(xx+2)->x);//生成新矩阵8 r1 [: Q! E6 P, o6 [8 s

if(!pMatrix3) break; 
6 O4 \2 P9 ^! A) W* L  b' z# K; I  r
                for(j=0,i=3;i<=mm;i++,j++)        //赋初值 
\\" ]( ^, I5 q. \
                { 
7 E: j, g$ u/ D% e
                        if(j>=pMatrix3->ArrayLen) break; 
* Y$ D9 J7 N  D6 d1 D
                        if((xx+i)->BType!=luStaData_double) break;        //只接受实数参数( l6 f1 G6 [; }- P0 j

pMatrix3->Array[j]=*(double *)&((xx+i)->x); 
$ d5 d8 X\\" x$ ]: o% w0 {
                }4 U6 o3 m8 E7 x! \  C* l! X' V

FunReObj(hFor);        //告诉Lu，返回一个动态对象, n$ Z7 N4 [6 h5 D& D6 O4 ]. i

a.BType=Matrix; a.VType=Matrix; a.x=0; *(luVOID *)&(a.x)=(luVOID)pMatrix3;! J/ E: ], U, @. D8 v

break;6 |9 G7 m8 |1 U* M\\" ]* e

case 49:        //重载函数o4 j4 c4 ~( G. g: q

pMessage=(luMessage)SearchKey("\0\0\0\0",sizeof(luVOID),luPubKey_User);0 U. C; f4 f! I) ^# ]\\" I! ~7 d2 {& \

if(!pMessage) break;/ i& r+ z3 Y1 N# d1 }, l

pMatrix1=(myMatrix *)SearchKey((char *)&(xx->x),sizeof(luVOID),Matrix); 
0 w) i( d9 h  x2 e\\" I2 [3 ^6 y0 ]
                if(!pMatrix1) break;        //对象句柄无效，不是矩阵 
- B- m: o; Z( \& |# b; W& `! I
                pa=pMatrix1->Array; 
) i  G' _) `4 I3 \
                m=pMatrix1->Dim[0]; n=pMatrix1->Dim[1]; k=0; 
4 K; j* h) @) H+ A0 t+ P
                for(i=0; i<m; i++)        //输出矩阵 
/ P$ _' B3 K5 r3 w
                {& S( ]1 Q\\" l# H

pMessage(L"\r\n"); k+=2;# m\\" @( g7 M) w5 i3 H. ^) S) ]

for(j=0; j<n; j++) 
\\" }% _1 I6 y% L* e- [
                        {\\" O) X2 B, X) j( D9 S

_gcvt_s(chNum,pa[i*n+j],16);- q# M, Z9 X8 _$ x- c% P+ P$ `% {

for(u=0;chNum[u];u++) {wchNum[u]=chNum[u]; k++;}! Z\\" F& M* U) Y! o- i\\" Z

wchNum[u]='\0'; 
% R) r3 \1 N1 w. F4 e4 f
                                pMessage(wchNum); pMessage(L"  "); k+=2; 
7 x9 J/ v# z1 r  X0 O
                        } 
2 d& r) B\\" q\\" ~) ?! r( P; L
                } 
% B. [4 j1 G% v+ T# {: L
                pMessage(L"\r\n"); k+=2; 
0 ?8 m\\" `  h; {  i% P) ^- [' P& L
                a.BType=luStaData_int64; a.VType=luStaData_int64; a.x=k;        //按函数o的要求，返回输出的字符总数 
5 x4 T; g: i+ x# z) F5 t0 C) G
                break; 
) w# j/ T$ ^- {0 U) M
        default:! t5 S- q. b/ F* o* D

break;/ N1 ~8 j) S2 V! S\\" s

} 
/ i4 h% s0 Z2 X) p
        return a;& ^( Y6 K6 v0 H$ c

}+ [' }8 l2 K' S& D

void main(void). q; }8 U$ V5 G5 ~

{ 
. r# ?4 p\\" V4 K7 }9 s/ E) b9 d
        void *hFor;                //表达式句柄4 e5 M* i) H9 U

luINT nPara;                //存放表达式的自变量个数 
' h3 i  O7 C, X2 R% e, K& ]
        LuData *pPara;                //存放输入自变量的数组指针. e- v; ?. L2 T1 \& J* r4 i; \

luINT ErrBegin,ErrEnd;        //表达式编译出错的初始位置和结束位置# K7 s, w& Q, j; b% r+ H

int ErrCode;                //错误代码 
, }7 I9 [  }( s9 X/ ?
        void *v;+ m/ s1 M) t0 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.]}";//字符串表达式，矩阵乘, {; u\\" m9 v; O! |

//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.]}";//字符串表达式，矩阵点乘# |. q! ~\\" j3 V/ ?: R

LuData Val; 
; x7 t- k$ S' }1 m! V& E5 s
        if(!InitLu()) return;        //初始化Lu* q/ ]' I) l; i$ E- x

while(LockKey(Matrix,DelMatrix,OpMatrix)){Matrix--;}        //锁定一个键，用于存储矩阵扩展类型 
0 z* n& v$ i! ?
6 t  \  W6 I) U

Val.BType=luStaData_int64; Val.VType=luStaData_int64; Val.x=Matrix;        //定义整数常量0 o& N3 m8 ?\\" n4 \7 e5 J& U

SetConst(L"matrix",&Val);        //设置整数常量 
7 @& ~& [5 T2 ]1 c  w
        InsertKey("\0\0\0\0",4,luPubKey_User,LuMessage,NULL,NULL,1,v); //使Lu运行时可输出函数信息% c: Y3 ^  R9 i  Y! A# y6 H' e: @- @

wcout.imbue(locale("chs"));        //设置输出的locale为中文3 M, Y! A/ p* ], Y6 o5 K2 w

/ J; e+ c. W; n6 x. N9 F
        ErrCode=LuCom(ForStr,0,0,0,hFor,nPara,pPara,ErrBegin,ErrEnd); //编译表达式 
2 i$ w$ U. E, B/ U+ E; i
        if(ErrCode) 
3 p$ \: i$ z$ j0 J
        { 
) `9 J\\" O! Z% R% V
                wcout<<L"表达式有错误！错误代码："<<ErrCode<<endl; 
+ j2 O* S4 O) \6 i0 F, J3 s
        } 
: t* Q, g4 G1 Q
        else 
% J! S: n4 Q4 t/ s9 r+ M\\" x
        { 
3 v  x+ a3 C; K; F/ e
                LuCal(hFor,pPara);        //计算表达式的值- I9 o: z! ^. |+ f# F/ P9 L5 Z: n

} 
* s# A, J* U6 e; S: t
        LockKey(Matrix,NULL,OpMatrix);//解锁键Matrix，本例中，该函数可以不用9 Y, H! B9 ?\\" A$ _+ x$ V: w

FreeLu();                        //释放Lu+ _' i. C& f2 J# `: E/ I4 V

}

习题：

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

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

main(:a,b,c,d,t,i)=
; H, C/ k+ e. ?2 G! @# N
a=new[matrix,2,2: 1.,2.,2.,1.],
5 L+ |' X. u# H0 \& b* w
b=new[matrix,2,2: 2.,1.,1.,2.],+ m' M* i) r8 V6 f) i
c=new[matrix,2,2: 2/3.,-1/3.,-1/3.,2/3.],
% N7 R% c- y7 I: |# Z: k4 ?- }: g
t=clock(),
% U& L6 L5 m1 ?7 h% F% \: Q0 ?
d=a*b, i=0, while{i<1000000, d=d*c*b, i++},6 C\" o3 Z, K0 z
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\"}";//字符串表达式

复制代码

结果：