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

查看: 8673|回复: 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>
$ n u% [+ p' k0 b7 M, A
#include <iostream>
+ @\\" x) z# F2 A) ]9 x) v/ W
#include <math.h>
! h$ q2 D( Z( U0 u: {
#include "lu32.h"; V* q( ~3 _! z\\" ]4 n
#pragma comment( lib, "lu32.lib" )
2 U& ?6 O$ Z0 V( c\\" W
using namespace std;7 Z8 S m; M. J; o- ?1 S
//自定义矩阵
1 ^# F5 Q( q' B4 J2 k2 E
class myMatrix
$ E% R# q/ V) G [; e& Z
{\\" c( s2 ~& z8 V+ k0 N
public:, u% \/ S( C2 `
double *Array; //数据缓冲区! w2 t5 w7 O4 \* }3 Q
luVOID ArrayLen; //数据缓冲区长度+ z+ H1 V7 ^$ A% _
luVOID Dim[2]; //矩阵维数
$ f, L4 e; b7 P
myMatrix(){Array=NULL; ArrayLen=0; Dim[0]=0; Dim[1]=0;}
5 T' q: v+ H. z5 n K1 d: z P
~myMatrix()
. D9 s4 w' y) d3 h' u
{7 j1 a) L\\" O- R* Q- i- c. z; ]
if(Array) delete[] Array;; }4 p: r( X; P1 a# P9 O
}
l2 Y6 u4 b1 c5 _4 P7 G; U
};
x( Z e6 Y9 c: m3 O- R
luKEY Matrix=-1000; //标识矩阵类型，最终的Matrix由LockKey决定! \0 i7 y8 H) h/ o0 M4 c
void _stdcall LuMessage(wchar_t *pch)//输出动态库信息，该函数注册到Lu，由Lu二级函数调用 5 H/ b) V7 X# ^2 c; l. k
{ V& I7 n2 U- U' U7 i! t
wcout<<pch;
: O: ^' ^1 x! h7 j$ I9 i- F
}
; ^6 {5 k1 K/ `
void _stdcall DelMatrix(void *me) //用于LockKey函数及InsertKey函数，使Lu能自动销毁myMatrix对象
% J( b# s/ J& p! _\\" v
{
4 I A$ v, w2 a3 m* o6 {
delete (myMatrix *)me;6 z# V( t, l. g' F3 L7 Z
}) z8 f) K2 B! J& }/ m4 v
myMatrix * _stdcall NewMatrix(luVOID m,luVOID n) //生成一个myMatrix对象
3 R# u6 ]$ Z! M# A5 l0 |
{2 P/ t) G2 x$ H4 U
myMatrix *pMatrix;
& h$ {4 n3 M# x' H
luVOID k;% Q( s0 A: H$ L. d
double *pa;
1 j* W _& H' B' v
char keyname[sizeof(luVOID)];! g# F& o. s\\" g3 ~' P8 b4 m
void *NowKey;
2 K( O+ F% ~: x
k=m*n;
& G. P6 c3 B' ~. p2 c
pMatrix=(myMatrix *)GetBufObj(Matrix,keyname);//先尝试从缓冲区中获取一个矩阵对象2 O5 _1 H+ c4 Z: q1 p K* z
if(pMatrix)\\" R% P$ ?! I0 T& n D4 E4 i
{
/ ^; L) p; C7 g3 J- e* D- J
if(pMatrix->ArrayLen!=k) //重置矩阵的大小
1 O0 g6 V# X F- ], k/ |
{
- e+ ?0 M8 m: E0 I9 H& g
pa=new double[k];/ M* K4 x4 ?6 B8 k8 U/ f
if(!pa)
& Z% ]! \! v# a5 I5 I' X6 B
{3 o: J6 R% H8 ~( m8 W; c
DeleteKey(keyname,sizeof(luVOID),Matrix,DelMatrix,1); //将矩阵对象放回缓冲区' R! w* |9 \* F! D! \, w, _
return NULL;
. f' A5 O, E! f% R
}2 [, J ~% j A: `+ E4 a
delete[] pMatrix->Array;
0 ?5 C; _8 C; d+ W, G1 _
pMatrix->Array=pa;
' q\\" p; q8 h& y2 h# u
}4 k; w% C/ e# m* o; I8 J
}
% g9 k3 ?& M9 B( e
else, a' |$ f) F( {7 J N
{
( L7 N& G/ Z, \0 z\\" E
pMatrix=new myMatrix; //创建矩阵对象' n! `& x8 b' ~1 ~. C3 s
if(!pMatrix) return NULL;
- s/ N }- \& p9 `9 z
pMatrix->Array=new double[k];' n. S3 v8 ^# D! k, ^3 j/ g# }, D
if(!pMatrix->Array)5 J! J- A5 v% d8 T& d* h; g
{
, U2 j# E& C: C) }2 a1 p7 I, {* I
delete pMatrix;0 ^& x, g/ V* U4 ~
return NULL;
' _0 d9 e2 a7 |! A9 c/ O# [1 H* s; h
}1 x; ?% k1 ^$ b* ~# Y. X: I( ^
if(InsertKey((char *)&pMatrix,-1,Matrix,pMatrix,DelMatrix,NULL,0,NowKey)) //将矩阵对象注册到Lu
2 {( ~& p! i0 j6 C: S8 i; U
{% ^\\" j: }: Q7 @' q
delete pMatrix;8 U% m& U; L% m/ m+ h
return NULL;
. L\\" |5 T5 R$ {+ U2 M
}$ d# r; A5 G3 d. Y% T' ^
}
: `' }: f3 s, z# ] m7 S+ i
pMatrix->ArrayLen=k; pMatrix->Dim[0]=m; pMatrix->Dim[1]=n;* Z: E1 f3 |. H: r$ Y
return pMatrix;% }' P4 r0 P: _) b* o& Z/ Y
}
% _+ e\\" D( L) i8 T a
LuData _stdcall OpMatrix(luINT mm,LuData *xx,void *hFor,int theOperator) //运算符重载函数，用于LockKey函数! E Q4 T0 x( W4 S* n
{% P; P\\" o% C' i( k' R2 _
LuData a;
5 t3 G$ T+ m7 I% U) L
myMatrix *pMatrix1,*pMatrix2,*pMatrix3;
6 c1 y. q( F4 P3 I g2 n! A
luVOID i,j,k,m,n,u,v;
' D. i$ Y6 @; N. V- R1 d7 h
double *pa,*pb,*pc;/ Z9 K1 Q: [! }8 h6 W
luMessage pMessage;
s' U$ P\\" q! u& N
wchar_t wchNum[32];4 T& b9 F& |4 f
char chNum[32];
( |7 ~# o s7 l0 U4 r1 v
a.BType=luStaData_nil; a.VType=luStaData_nil; a.x=0;: \# z0 M5 g& b
switch(theOperator)
* F1 ?! Z( p, O$ d
{\\" |7 C\\" K! J8 s5 _; m6 w: j5 S
case 2: //重载运算符** y. a\\" E- k9 ?/ ~/ N* o* I
pMatrix1=(myMatrix *)SearchKey((char *)&(xx->x),sizeof(luVOID),Matrix);
5 g$ c- N* K' Z1 S7 c) S\\" O3 T
pMatrix2=(myMatrix *)SearchKey((char *)&((xx+1)->x),sizeof(luVOID),Matrix);/ p6 ?! _8 p% T3 M' l
if(!pMatrix1 || !pMatrix2) break; //对象句柄无效，不是矩阵. m% |7 W& A; A- Y\\" {- T- W
if(pMatrix1->Dim[1]!=pMatrix2->Dim[0]) break; //维数不匹配) x) p6 _' e2 d/ @
pMatrix3=NewMatrix(pMatrix1->Dim[0],pMatrix2->Dim[1]); //生成新矩阵! l& s3 |$ Z& x4 ^3 L7 L$ t
if(!pMatrix3) break;
' V\\" Y/ @ K3 S# f& }' c
pa=pMatrix1->Array; pb=pMatrix2->Array; pc=pMatrix3->Array;
2 q4 q9 U7 D; c- n6 E D/ s
m=pMatrix1->Dim[0]; n=pMatrix1->Dim[1]; k=pMatrix2->Dim[1];
; f2 X% f! g3 J% z
for(i=0; i<m; i++) //矩阵乘& m6 N; ~- Z0 E5 X5 C
{
* @' m% `1 {# j( J! N
for(j=0; j<k; j++)6 K. k2 H0 h\\" Q7 Y! y
{
- F* f/ G1 U d0 N, a\\" a# z( K
u=i*k+j; pc[u]=0.0;
7 ]) _2 K/ |4 y. k% P
for (v=0; v<n; v++)
- t! A3 s% K5 r* q ?4 f
{- \+ D\\" `3 c/ K# ]
pc[u]=pc[u]+pa[i*n+v]*pb[v*k+j];. z# e7 { T8 H7 |, {
}# f, i {9 H: [0 @. f A. E
}
4 e L\\" v' A5 z
}
\\" g9 h& @\\" _+ }% t
FunReObj(hFor); //告诉Lu，返回一个动态对象
, g- i/ e3 H6 W5 z. M4 `
a.BType=Matrix; a.VType=Matrix; a.x=0; *(luVOID *)&(a.x)=(luVOID)pMatrix3; l4 a }1 o4 R. e/ d0 `( Y\\" S
break;/ F1 S7 }. D' o/ y! [
case 25: //重载运算符.*8 z# B3 n1 |! z0 [. Y1 I# w' q
pMatrix1=(myMatrix *)SearchKey((char *)&(xx->x),sizeof(luVOID),Matrix);
' T0 K- x# J% E+ n$ _% M$ Q6 M
pMatrix2=(myMatrix *)SearchKey((char *)&((xx+1)->x),sizeof(luVOID),Matrix); c) z) t, r+ ^. ?4 D0 \; Y- z5 D
if(!pMatrix1 || !pMatrix2) break; //对象句柄无效，不是矩阵8 F2 X& s* D+ n# s1 g: G2 |
if(pMatrix1->Dim[0]!=pMatrix2->Dim[0] || pMatrix1->Dim[1]!=pMatrix2->Dim[1]) break; //维数不相同% g: Y+ N1 R2 t6 c+ `
pMatrix3=NewMatrix(pMatrix1->Dim[0],pMatrix1->Dim[1]); //生成新矩阵
* n\\" }! I; @) H7 m5 z: |5 ~/ ^
if(!pMatrix3) break;0 W. t: ^( U* q* R+ P- U5 C
for(i=0;i<pMatrix1->ArrayLen;i++) pMatrix3->Array[i]=pMatrix1->Array[i]*pMatrix2->Array[i]; //矩阵点乘, m' V\\" E! @* F\\" h- C* d7 v9 n
FunReObj(hFor); //告诉Lu，返回一个动态对象' f4 H\\" _, F7 A2 Q+ P+ u
a.BType=Matrix; a.VType=Matrix; a.x=0; *(luVOID *)&(a.x)=(luVOID)pMatrix3;! P3 A8 S) b5 [$ c
break;4 t2 W9 Y4 D- m; y; F
case 46: //重载函数new+ E2 f: ~7 b w& X$ G) b
if(mm<2) break;5 a+ n& _5 c: }4 O. q
if((xx+1)->x<1 || (xx+2)->x<1 || (xx+1)->BType!=luStaData_int64 || (xx+2)->BType!=luStaData_int64) break;
$ W* [0 q% ^* P% [2 g( U
pMatrix3=NewMatrix((luVOID)(xx+1)->x,(luVOID)(xx+2)->x);//生成新矩阵\\" C8 A( p6 J4 w# T
if(!pMatrix3) break;0 I) |0 M2 @0 I! Z
for(j=0,i=3;i<=mm;i++,j++) //赋初值
- A% M3 }! P, y* j/ ]
{
7 K) A6 g+ U% U5 v3 l
if(j>=pMatrix3->ArrayLen) break;
# M* s0 G4 k+ E
if((xx+i)->BType!=luStaData_double) break; //只接受实数参数
, {. a' i- o( M& h! I
pMatrix3->Array[j]=*(double *)&((xx+i)->x);
& k$ @4 f9 K6 A. G$ J
}
: r; V: z( K7 q( i( C4 O$ W: }
FunReObj(hFor); //告诉Lu，返回一个动态对象: y$ e# {( d/ ^9 Z, q6 P l4 R
a.BType=Matrix; a.VType=Matrix; a.x=0; *(luVOID *)&(a.x)=(luVOID)pMatrix3;. E9 @( {& W' O2 r
break;
+ m& \, R3 E+ c2 i; J, i8 L* P
case 49: //重载函数o+ `* X7 I% r3 W. n4 ~
pMessage=(luMessage)SearchKey("\0\0\0\0",sizeof(luVOID),luPubKey_User);- s ~ x) b7 ^, J$ a* L6 W
if(!pMessage) break;( ^4 e2 q0 R! G/ B/ e) k
pMatrix1=(myMatrix *)SearchKey((char *)&(xx->x),sizeof(luVOID),Matrix);
) X' l. b& _! J, I* X
if(!pMatrix1) break; //对象句柄无效，不是矩阵
) C5 O' ]& E- y0 n
pa=pMatrix1->Array;& s5 K3 Z* ]# [7 z4 U1 J
m=pMatrix1->Dim[0]; n=pMatrix1->Dim[1]; k=0;! I+ @1 E: J/ {5 ~4 O% X
for(i=0; i<m; i++) //输出矩阵
. `2 y# a* J% E8 f9 A
{5 X% M8 h2 x/ o; A
pMessage(L"\r\n"); k+=2;
+ ^' t/ ^' w0 [
for(j=0; j<n; j++)7 n' ?$ w' X$ c p a1 k
{
% t0 n% Q6 `; J, p8 J2 [6 K% Y
_gcvt_s(chNum,pa[i*n+j],16);0 A7 L! f9 A. n8 z! ~
for(u=0;chNum[u];u++) {wchNum[u]=chNum[u]; k++;}
4 |# l$ k) ?4 o& n( B+ {
wchNum[u]='\0';
' m- x+ i$ ]8 Z) X$ }/ P- ?
pMessage(wchNum); pMessage(L" "); k+=2;- C* m0 n3 }& o2 r
}
2 V- `$ l3 o8 q3 A- N
}
6 v: w* T3 T C: R
pMessage(L"\r\n"); k+=2;
2 d$ l s1 |: g; f4 }& ^/ {! l) z
a.BType=luStaData_int64; a.VType=luStaData_int64; a.x=k; //按函数o的要求，返回输出的字符总数1 `; ]% u: B3 {4 L6 T6 M9 |1 c9 O
break;- h) R( Q; d( R: p/ I: w
default:
\\" R: p1 _( g- ?5 O; @( B- J
break;( j: f9 S; i' f. j6 {$ o) T `1 O @
}
J8 S* e) l+ L) z( ~ ~/ y
return a;
0 p1 z: r, Z+ k2 M! m\\" V
}
. s2 x! U2 L% Y( o
void main(void)& f* F( ?/ L+ R: S, z* q
{
) M( k+ ~2 Q! E7 L\\" `2 r
void *hFor; //表达式句柄/ Z( U' O3 f# ~) U2 {6 c) g, V
luINT nPara; //存放表达式的自变量个数
3 }! _1 L6 `# H( Z2 X
LuData *pPara; //存放输入自变量的数组指针
( y& f$ `4 E% M+ _# J- y
luINT ErrBegin,ErrEnd; //表达式编译出错的初始位置和结束位置
* M }, e, g; k
int ErrCode; //错误代码
3 q* r* H2 I8 r% F9 v- ]4 [
void *v;\\" Q+ E% f* \1 [) h
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.]}";//字符串表达式，矩阵乘
6 n0 y8 F: G; {- n6 T; X
//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.]}";//字符串表达式，矩阵点乘
5 D# T5 O! w+ @# b6 N, c
LuData Val;/ K7 x0 m: u% J! b1 y$ x- s
if(!InitLu()) return; //初始化Lu. c1 B. u& Z+ I1 J
while(LockKey(Matrix,DelMatrix,OpMatrix)){Matrix--;} //锁定一个键，用于存储矩阵扩展类型
8 z\\" S! k) }2 `1 f5 |4 v# }% F
! ]0 r: W! o, d3 }
Val.BType=luStaData_int64; Val.VType=luStaData_int64; Val.x=Matrix; //定义整数常量$ | h8 e6 J5 o8 \
SetConst(L"matrix",&Val); //设置整数常量: n: E1 g) }7 ^! w3 e; W( `! `
InsertKey("\0\0\0\0",4,luPubKey_User,LuMessage,NULL,NULL,1,v); //使Lu运行时可输出函数信息: l$ v. R4 ?! H' s9 E! ]/ Y
wcout.imbue(locale("chs")); //设置输出的locale为中文
# [1 o) c4 I7 f2 s: b$ H% x$ A/ i% |
5 _ l3 k& B0 M* h* e
ErrCode=LuCom(ForStr,0,0,0,hFor,nPara,pPara,ErrBegin,ErrEnd); //编译表达式* |/ {8 x+ E. B% C8 ~) C H ?
if(ErrCode)
J$ _. l, A: i
{
6 \ K8 ]7 [5 j. r$ n\\" _ g. k
wcout<<L"表达式有错误！错误代码："<<ErrCode<<endl;9 j5 v# [+ y' D3 z: x7 B0 g
}
2 Y7 O8 t1 a& V
else4 Y\\" L0 u\\" C+ O- g( c$ D* y
{5 \* J; b* T, `* w: R9 @! [
LuCal(hFor,pPara); //计算表达式的值
5 p! o3 y( W! m( q' E
}
' k, } H3 S- ` D4 Q) [6 q& ]\\" C
LockKey(Matrix,NULL,OpMatrix);//解锁键Matrix，本例中，该函数可以不用% a% N% Y, U+ U
FreeLu(); //释放Lu1 ?) p\\" \* x2 w( l
}

#include <windows.h> 
$ n  u% [+ p' k0 b7 M, A
#include <iostream> 
+ @\\" x) z# F2 A) ]9 x) v/ W
#include <math.h> 
! h$ q2 D( Z( U0 u: {
#include "lu32.h"; V* q( ~3 _! z\\" ]4 n

#pragma comment( lib, "lu32.lib" ) 
2 U& ?6 O$ Z0 V( c\\" W
using namespace std;7 Z8 S  m; M. J; o- ?1 S

//自定义矩阵 
1 ^# F5 Q( q' B4 J2 k2 E
class myMatrix 
$ E% R# q/ V) G  [; e& Z
{\\" c( s2 ~& z8 V+ k0 N

public:, u% \/ S( C2 `

double *Array;        //数据缓冲区! w2 t5 w7 O4 \* }3 Q

luVOID ArrayLen;        //数据缓冲区长度+ z+ H1 V7 ^$ A% _

luVOID Dim[2];        //矩阵维数 
$ f, L4 e; b7 P
        myMatrix(){Array=NULL; ArrayLen=0; Dim[0]=0; Dim[1]=0;} 
5 T' q: v+ H. z5 n  K1 d: z  P
        ~myMatrix() 
. D9 s4 w' y) d3 h' u
        {7 j1 a) L\\" O- R* Q- i- c. z; ]

if(Array) delete[] Array;; }4 p: r( X; P1 a# P9 O

} 
  l2 Y6 u4 b1 c5 _4 P7 G; U
}; 
  x( Z  e6 Y9 c: m3 O- R
luKEY Matrix=-1000;        //标识矩阵类型，最终的Matrix由LockKey决定! \0 i7 y8 H) h/ o0 M4 c

void _stdcall LuMessage(wchar_t *pch)//输出动态库信息，该函数注册到Lu，由Lu二级函数调用 5 H/ b) V7 X# ^2 c; l. k

{  V& I7 n2 U- U' U7 i! t

wcout<<pch; 
: O: ^' ^1 x! h7 j$ I9 i- F
} 
; ^6 {5 k1 K/ `
void _stdcall DelMatrix(void *me)        //用于LockKey函数及InsertKey函数，使Lu能自动销毁myMatrix对象 
% J( b# s/ J& p! _\\" v
{ 
4 I  A$ v, w2 a3 m* o6 {
        delete (myMatrix *)me;6 z# V( t, l. g' F3 L7 Z

}) z8 f) K2 B! J& }/ m4 v

myMatrix * _stdcall NewMatrix(luVOID m,luVOID n)        //生成一个myMatrix对象 
3 R# u6 ]$ Z! M# A5 l0 |
{2 P/ t) G2 x$ H4 U

myMatrix *pMatrix; 
& h$ {4 n3 M# x' H
        luVOID k;% Q( s0 A: H$ L. d

double *pa; 
1 j* W  _& H' B' v
        char keyname[sizeof(luVOID)];! g# F& o. s\\" g3 ~' P8 b4 m

void *NowKey; 
2 K( O+ F% ~: x
        k=m*n; 
& G. P6 c3 B' ~. p2 c
        pMatrix=(myMatrix *)GetBufObj(Matrix,keyname);//先尝试从缓冲区中获取一个矩阵对象2 O5 _1 H+ c4 Z: q1 p  K* z

if(pMatrix)\\" R% P$ ?! I0 T& n  D4 E4 i

{ 
/ ^; L) p; C7 g3 J- e* D- J
                if(pMatrix->ArrayLen!=k)        //重置矩阵的大小 
1 O0 g6 V# X  F- ], k/ |
                { 
- e+ ?0 M8 m: E0 I9 H& g
                        pa=new double[k];/ M* K4 x4 ?6 B8 k8 U/ f

if(!pa) 
& Z% ]! \! v# a5 I5 I' X6 B
                        {3 o: J6 R% H8 ~( m8 W; c

DeleteKey(keyname,sizeof(luVOID),Matrix,DelMatrix,1);        //将矩阵对象放回缓冲区' R! w* |9 \* F! D! \, w, _

return NULL; 
. f' A5 O, E! f% R
                        }2 [, J  ~% j  A: `+ E4 a

delete[] pMatrix->Array; 
0 ?5 C; _8 C; d+ W, G1 _
                        pMatrix->Array=pa; 
' q\\" p; q8 h& y2 h# u
                }4 k; w% C/ e# m* o; I8 J

} 
% g9 k3 ?& M9 B( e
        else, a' |$ f) F( {7 J  N

{ 
( L7 N& G/ Z, \0 z\\" E
                pMatrix=new myMatrix;        //创建矩阵对象' n! `& x8 b' ~1 ~. C3 s

if(!pMatrix) return NULL; 
- s/ N  }- \& p9 `9 z
                pMatrix->Array=new double[k];' n. S3 v8 ^# D! k, ^3 j/ g# }, D

if(!pMatrix->Array)5 J! J- A5 v% d8 T& d* h; g

{ 
, U2 j# E& C: C) }2 a1 p7 I, {* I
                        delete pMatrix;0 ^& x, g/ V* U4 ~

return NULL; 
' _0 d9 e2 a7 |! A9 c/ O# [1 H* s; h
                }1 x; ?% k1 ^$ b* ~# Y. X: I( ^

if(InsertKey((char *)&pMatrix,-1,Matrix,pMatrix,DelMatrix,NULL,0,NowKey))        //将矩阵对象注册到Lu 
2 {( ~& p! i0 j6 C: S8 i; U
                {% ^\\" j: }: Q7 @' q

delete pMatrix;8 U% m& U; L% m/ m+ h

return NULL; 
. L\\" |5 T5 R$ {+ U2 M
                }$ d# r; A5 G3 d. Y% T' ^

} 
: `' }: f3 s, z# ]  m7 S+ i
        pMatrix->ArrayLen=k; pMatrix->Dim[0]=m; pMatrix->Dim[1]=n;* Z: E1 f3 |. H: r$ Y

return pMatrix;% }' P4 r0 P: _) b* o& Z/ Y

} 
% _+ e\\" D( L) i8 T  a
LuData _stdcall OpMatrix(luINT mm,LuData *xx,void *hFor,int theOperator)        //运算符重载函数，用于LockKey函数! E  Q4 T0 x( W4 S* n

{% P; P\\" o% C' i( k' R2 _

LuData a; 
5 t3 G$ T+ m7 I% U) L
        myMatrix *pMatrix1,*pMatrix2,*pMatrix3; 
6 c1 y. q( F4 P3 I  g2 n! A
        luVOID i,j,k,m,n,u,v; 
' D. i$ Y6 @; N. V- R1 d7 h
        double *pa,*pb,*pc;/ Z9 K1 Q: [! }8 h6 W

luMessage pMessage; 
  s' U$ P\\" q! u& N
        wchar_t wchNum[32];4 T& b9 F& |4 f

char chNum[32]; 
( |7 ~# o  s7 l0 U4 r1 v
        a.BType=luStaData_nil; a.VType=luStaData_nil; a.x=0;: \# z0 M5 g& b

switch(theOperator) 
* F1 ?! Z( p, O$ d
        {\\" |7 C\\" K! J8 s5 _; m6 w: j5 S

case 2:        //重载运算符** y. a\\" E- k9 ?/ ~/ N* o* I

pMatrix1=(myMatrix *)SearchKey((char *)&(xx->x),sizeof(luVOID),Matrix); 
5 g$ c- N* K' Z1 S7 c) S\\" O3 T
                pMatrix2=(myMatrix *)SearchKey((char *)&((xx+1)->x),sizeof(luVOID),Matrix);/ p6 ?! _8 p% T3 M' l

if(!pMatrix1 || !pMatrix2) break;        //对象句柄无效，不是矩阵. m% |7 W& A; A- Y\\" {- T- W

if(pMatrix1->Dim[1]!=pMatrix2->Dim[0]) break;        //维数不匹配) x) p6 _' e2 d/ @

pMatrix3=NewMatrix(pMatrix1->Dim[0],pMatrix2->Dim[1]);        //生成新矩阵! l& s3 |$ Z& x4 ^3 L7 L$ t

if(!pMatrix3) break; 
' V\\" Y/ @  K3 S# f& }' c
                pa=pMatrix1->Array; pb=pMatrix2->Array; pc=pMatrix3->Array; 
2 q4 q9 U7 D; c- n6 E  D/ s
                m=pMatrix1->Dim[0]; n=pMatrix1->Dim[1]; k=pMatrix2->Dim[1]; 
; f2 X% f! g3 J% z
                for(i=0; i<m; i++)        //矩阵乘& m6 N; ~- Z0 E5 X5 C

{ 
* @' m% `1 {# j( J! N
                        for(j=0; j<k; j++)6 K. k2 H0 h\\" Q7 Y! y

{ 
- F* f/ G1 U  d0 N, a\\" a# z( K
                                u=i*k+j; pc[u]=0.0; 
7 ]) _2 K/ |4 y. k% P
                                for (v=0; v<n; v++) 
- t! A3 s% K5 r* q  ?4 f
                                {- \+ D\\" `3 c/ K# ]

pc[u]=pc[u]+pa[i*n+v]*pb[v*k+j];. z# e7 {  T8 H7 |, {

}# f, i  {9 H: [0 @. f  A. E

} 
4 e  L\\" v' A5 z
                } 
\\" g9 h& @\\" _+ }% t
                FunReObj(hFor);        //告诉Lu，返回一个动态对象 
, g- i/ e3 H6 W5 z. M4 `
                a.BType=Matrix; a.VType=Matrix; a.x=0; *(luVOID *)&(a.x)=(luVOID)pMatrix3;  l4 a  }1 o4 R. e/ d0 `( Y\\" S

break;/ F1 S7 }. D' o/ y! [

case 25:        //重载运算符.*8 z# B3 n1 |! z0 [. Y1 I# w' q

pMatrix1=(myMatrix *)SearchKey((char *)&(xx->x),sizeof(luVOID),Matrix); 
' T0 K- x# J% E+ n$ _% M$ Q6 M
                pMatrix2=(myMatrix *)SearchKey((char *)&((xx+1)->x),sizeof(luVOID),Matrix);  c) z) t, r+ ^. ?4 D0 \; Y- z5 D

if(!pMatrix1 || !pMatrix2) break;        //对象句柄无效，不是矩阵8 F2 X& s* D+ n# s1 g: G2 |

if(pMatrix1->Dim[0]!=pMatrix2->Dim[0] || pMatrix1->Dim[1]!=pMatrix2->Dim[1]) break;        //维数不相同% g: Y+ N1 R2 t6 c+ `

pMatrix3=NewMatrix(pMatrix1->Dim[0],pMatrix1->Dim[1]);        //生成新矩阵 
* n\\" }! I; @) H7 m5 z: |5 ~/ ^
                if(!pMatrix3) break;0 W. t: ^( U* q* R+ P- U5 C

for(i=0;i<pMatrix1->ArrayLen;i++) pMatrix3->Array[i]=pMatrix1->Array[i]*pMatrix2->Array[i];        //矩阵点乘, m' V\\" E! @* F\\" h- C* d7 v9 n

FunReObj(hFor);        //告诉Lu，返回一个动态对象' f4 H\\" _, F7 A2 Q+ P+ u

a.BType=Matrix; a.VType=Matrix; a.x=0; *(luVOID *)&(a.x)=(luVOID)pMatrix3;! P3 A8 S) b5 [$ c

break;4 t2 W9 Y4 D- m; y; F

case 46:        //重载函数new+ E2 f: ~7 b  w& X$ G) b

if(mm<2) break;5 a+ n& _5 c: }4 O. q

if((xx+1)->x<1 || (xx+2)->x<1 || (xx+1)->BType!=luStaData_int64 || (xx+2)->BType!=luStaData_int64) break; 
$ W* [0 q% ^* P% [2 g( U
                pMatrix3=NewMatrix((luVOID)(xx+1)->x,(luVOID)(xx+2)->x);//生成新矩阵\\" C8 A( p6 J4 w# T

if(!pMatrix3) break;0 I) |0 M2 @0 I! Z

for(j=0,i=3;i<=mm;i++,j++)        //赋初值 
- A% M3 }! P, y* j/ ]
                { 
7 K) A6 g+ U% U5 v3 l
                        if(j>=pMatrix3->ArrayLen) break; 
# M* s0 G4 k+ E
                        if((xx+i)->BType!=luStaData_double) break;        //只接受实数参数 
, {. a' i- o( M& h! I
                        pMatrix3->Array[j]=*(double *)&((xx+i)->x); 
& k$ @4 f9 K6 A. G$ J
                } 
: r; V: z( K7 q( i( C4 O$ W: }
                FunReObj(hFor);        //告诉Lu，返回一个动态对象: y$ e# {( d/ ^9 Z, q6 P  l4 R

a.BType=Matrix; a.VType=Matrix; a.x=0; *(luVOID *)&(a.x)=(luVOID)pMatrix3;. E9 @( {& W' O2 r

break; 
+ m& \, R3 E+ c2 i; J, i8 L* P
        case 49:        //重载函数o+ `* X7 I% r3 W. n4 ~

pMessage=(luMessage)SearchKey("\0\0\0\0",sizeof(luVOID),luPubKey_User);- s  ~  x) b7 ^, J$ a* L6 W

if(!pMessage) break;( ^4 e2 q0 R! G/ B/ e) k

pMatrix1=(myMatrix *)SearchKey((char *)&(xx->x),sizeof(luVOID),Matrix); 
) X' l. b& _! J, I* X
                if(!pMatrix1) break;        //对象句柄无效，不是矩阵 
) C5 O' ]& E- y0 n
                pa=pMatrix1->Array;& s5 K3 Z* ]# [7 z4 U1 J

m=pMatrix1->Dim[0]; n=pMatrix1->Dim[1]; k=0;! I+ @1 E: J/ {5 ~4 O% X

for(i=0; i<m; i++)        //输出矩阵 
. `2 y# a* J% E8 f9 A
                {5 X% M8 h2 x/ o; A

pMessage(L"\r\n"); k+=2; 
+ ^' t/ ^' w0 [
                        for(j=0; j<n; j++)7 n' ?$ w' X$ c  p  a1 k

{ 
% t0 n% Q6 `; J, p8 J2 [6 K% Y
                                _gcvt_s(chNum,pa[i*n+j],16);0 A7 L! f9 A. n8 z! ~

for(u=0;chNum[u];u++) {wchNum[u]=chNum[u]; k++;} 
4 |# l$ k) ?4 o& n( B+ {
                                wchNum[u]='\0'; 
' m- x+ i$ ]8 Z) X$ }/ P- ?
                                pMessage(wchNum); pMessage(L"  "); k+=2;- C* m0 n3 }& o2 r

} 
2 V- `$ l3 o8 q3 A- N
                } 
6 v: w* T3 T  C: R
                pMessage(L"\r\n"); k+=2; 
2 d$ l  s1 |: g; f4 }& ^/ {! l) z
                a.BType=luStaData_int64; a.VType=luStaData_int64; a.x=k;        //按函数o的要求，返回输出的字符总数1 `; ]% u: B3 {4 L6 T6 M9 |1 c9 O

break;- h) R( Q; d( R: p/ I: w

default: 
\\" R: p1 _( g- ?5 O; @( B- J
                break;( j: f9 S; i' f. j6 {$ o) T  `1 O  @

} 
  J8 S* e) l+ L) z( ~  ~/ y
        return a; 
0 p1 z: r, Z+ k2 M! m\\" V
} 
. s2 x! U2 L% Y( o
void main(void)& f* F( ?/ L+ R: S, z* q

{ 
) M( k+ ~2 Q! E7 L\\" `2 r
        void *hFor;                //表达式句柄/ Z( U' O3 f# ~) U2 {6 c) g, V

luINT nPara;                //存放表达式的自变量个数 
3 }! _1 L6 `# H( Z2 X
        LuData *pPara;                //存放输入自变量的数组指针 
( y& f$ `4 E% M+ _# J- y
        luINT ErrBegin,ErrEnd;        //表达式编译出错的初始位置和结束位置 
* M  }, e, g; k
        int ErrCode;                //错误代码 
3 q* r* H2 I8 r% F9 v- ]4 [
        void *v;\\" Q+ E% f* \1 [) h

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.]}";//字符串表达式，矩阵乘 
6 n0 y8 F: G; {- n6 T; X
        //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.]}";//字符串表达式，矩阵点乘 
5 D# T5 O! w+ @# b6 N, c
        LuData Val;/ K7 x0 m: u% J! b1 y$ x- s

if(!InitLu()) return;        //初始化Lu. c1 B. u& Z+ I1 J

while(LockKey(Matrix,DelMatrix,OpMatrix)){Matrix--;}        //锁定一个键，用于存储矩阵扩展类型 
8 z\\" S! k) }2 `1 f5 |4 v# }% F
! ]0 r: W! o, d3 }

Val.BType=luStaData_int64; Val.VType=luStaData_int64; Val.x=Matrix;        //定义整数常量$ |  h8 e6 J5 o8 \

SetConst(L"matrix",&Val);        //设置整数常量: n: E1 g) }7 ^! w3 e; W( `! `

InsertKey("\0\0\0\0",4,luPubKey_User,LuMessage,NULL,NULL,1,v); //使Lu运行时可输出函数信息: l$ v. R4 ?! H' s9 E! ]/ Y

wcout.imbue(locale("chs"));        //设置输出的locale为中文 
# [1 o) c4 I7 f2 s: b$ H% x$ A/ i% |
   
5 _  l3 k& B0 M* h* e
        ErrCode=LuCom(ForStr,0,0,0,hFor,nPara,pPara,ErrBegin,ErrEnd); //编译表达式* |/ {8 x+ E. B% C8 ~) C  H  ?

if(ErrCode) 
  J$ _. l, A: i
        { 
6 \  K8 ]7 [5 j. r$ n\\" _  g. k
                wcout<<L"表达式有错误！错误代码："<<ErrCode<<endl;9 j5 v# [+ y' D3 z: x7 B0 g

} 
2 Y7 O8 t1 a& V
        else4 Y\\" L0 u\\" C+ O- g( c$ D* y

{5 \* J; b* T, `* w: R9 @! [

LuCal(hFor,pPara);        //计算表达式的值 
5 p! o3 y( W! m( q' E
        } 
' k, }  H3 S- `  D4 Q) [6 q& ]\\" C
        LockKey(Matrix,NULL,OpMatrix);//解锁键Matrix，本例中，该函数可以不用% a% N% Y, U+ U

FreeLu();                        //释放Lu1 ?) p\\" \* x2 w( l

}

习题：

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

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

main(:a,b,c,d,t,i)=; T6 L# ^% `, n4 Z1 q W
a=new[matrix,2,2: 1.,2.,2.,1.],\" J8 g8 b6 a3 X& s; G: r
b=new[matrix,2,2: 2.,1.,1.,2.],
6 N! _. u9 Y) Y& J5 g/ l
c=new[matrix,2,2: 2/3.,-1/3.,-1/3.,2/3.],
: \3 J( _0 H; S\" [
t=clock(),* z* ?% B3 y& x5 L
d=a*b, i=0, while{i<1000000, d=d*c*b, i++},
5 G) l( `& S& A\" ~7 b3 ?& A( w/ t1 L
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\"}";//字符串表达式

复制代码

结果：