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

查看: 8682|回复: 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>2 y6 ^5 ~9 S1 i# D6 m4 @2 W. }
#include <iostream># f% J5 L2 q& H6 A0 ]
#include <math.h>
. r' C+ U( ]4 a
#include "lu32.h"
9 L3 i. C7 u4 X* U* G7 ?( K
#pragma comment( lib, "lu32.lib" )0 X; E2 c' ?# z* e
using namespace std;
& ~0 W7 c$ ]\\" H$ g
//自定义矩阵/ h+ X0 D: {9 e0 Y9 D0 \. \
class myMatrix' t* z7 A+ v( u- z7 N! m2 v\\" x6 y5 C
{
4 ]* D7 x% _ d$ J! s
public:
! s1 l5 ~ g# K* ]1 U. |
double *Array; //数据缓冲区. w3 D! ?) n( E7 U
luVOID ArrayLen; //数据缓冲区长度9 K# B, o; k8 d- q! ?
luVOID Dim[2]; //矩阵维数8 v! {5 m8 m- B+ C( A' f
myMatrix(){Array=NULL; ArrayLen=0; Dim[0]=0; Dim[1]=0;}; d, Y* m- U/ [6 i+ u7 t
~myMatrix()
5 {: {+ u' ?9 q: Z: E! K. z
{3 f% U5 Y7 m* x9 S. k6 v% A. e
if(Array) delete[] Array;; d& `# _- { }3 _
}
2 x! w\\" K! {, A8 G
};* c% Y$ d4 R. o4 K
luKEY Matrix=-1000; //标识矩阵类型，最终的Matrix由LockKey决定
* B7 v. B, I4 Q, {
void _stdcall LuMessage(wchar_t *pch)//输出动态库信息，该函数注册到Lu，由Lu二级函数调用 ) {0 W5 V: T% x
{5 U\\" `2 H# u6 k
wcout<<pch;
+ Q: F6 W6 }\\" c! @& t/ P- d7 g
}7 X+ D& j0 P7 b; X6 D# G9 T
void _stdcall DelMatrix(void *me) //用于LockKey函数及InsertKey函数，使Lu能自动销毁myMatrix对象# y) j/ K8 Q: E( Q: a
{
9 E9 X+ z' n; |) ]- }* p( P+ e
delete (myMatrix *)me;
; D# o# V3 A1 L h
}/ U; o9 G P* i7 a* C
myMatrix * _stdcall NewMatrix(luVOID m,luVOID n) //生成一个myMatrix对象
$ b5 r' ]- x; T- {' G7 E0 o
{9 E5 \5 q+ G1 K- ]7 `
myMatrix *pMatrix;) c, }8 F4 u& \# J. A8 Z
luVOID k;
* k+ z+ y9 {$ _5 \; Z
double *pa;
2 b: c1 z, B' ^& o' a
char keyname[sizeof(luVOID)];; R' c) \! \# N0 V
void *NowKey;7 Z' h( w$ s+ P( h9 {
k=m*n;/ R/ V! ?3 O' I% @7 X6 Z/ l
pMatrix=(myMatrix *)GetBufObj(Matrix,keyname);//先尝试从缓冲区中获取一个矩阵对象
- d/ S% N/ I# ~: u
if(pMatrix)
0 {3 p& H* l ~: A; s
{
$ U2 a, H6 L; L1 _
if(pMatrix->ArrayLen!=k) //重置矩阵的大小
8 [2 m8 i* l$ r7 z* I
{, }6 o* t) F, g' n- u' \2 W/ I8 D
pa=new double[k];
; ?* w# }, G( D2 `7 h* O9 W- V
if(!pa)2 Z, i& _1 {$ \! W4 x0 S5 i9 J, z, D
{
# l) ?( b+ ]! g& \: S! l7 X
DeleteKey(keyname,sizeof(luVOID),Matrix,DelMatrix,1); //将矩阵对象放回缓冲区
: f/ W. k3 `3 s# y: p7 x
return NULL;3 A9 K( f0 |0 f5 I1 O3 M) V! i
}
5 w8 Q, `/ V& ` D& ~* J
delete[] pMatrix->Array;& g1 V/ v$ j2 _& A& e
pMatrix->Array=pa;9 ?( U) ~, \\\" r7 f
}$ I# l' Q/ ~2 z% A
}
! w- a# q9 r$ ?2 _1 l
else* o7 l2 j9 B9 N% ]& h
{
\\" i! n2 l8 f. T0 ]% N6 ]' s
pMatrix=new myMatrix; //创建矩阵对象6 h+ p( p& k4 o; d) j$ N
if(!pMatrix) return NULL;6 r! b$ c9 F( F$ `# h\\" _, l
pMatrix->Array=new double[k];; C) y6 x1 V9 n- X9 O
if(!pMatrix->Array)
0 J5 e J' F9 H0 K, ?
{. f/ `/ E- h, \( ?
delete pMatrix;6 e\\" @2 X1 N/ `+ C4 u# ?7 R
return NULL;4 z, c0 U3 q$ T
}
8 u4 Y* K. x V7 Y8 w: A4 N
if(InsertKey((char *)&pMatrix,-1,Matrix,pMatrix,DelMatrix,NULL,0,NowKey)) //将矩阵对象注册到Lu
* O2 i0 v5 [% E
{
4 y$ o) H/ B0 C7 I/ f+ {% Q% M
delete pMatrix;
& s/ p5 U* a\\" d; f\\" D
return NULL;
7 }9 h- ]$ H. q) O# z\\" n
}
+ J6 Z\\" m4 T4 R b) y7 `
}
( t& z- N, J$ [6 k, a
pMatrix->ArrayLen=k; pMatrix->Dim[0]=m; pMatrix->Dim[1]=n;
o7 d1 m/ J7 O
return pMatrix;
' N( _+ Q0 G% \% ^) M
}
' |) E7 U. C9 X1 @: a7 V7 b
LuData _stdcall OpMatrix(luINT mm,LuData *xx,void *hFor,int theOperator) //运算符重载函数，用于LockKey函数
6 i) l3 H7 Y. E$ O: A1 S! i
{
$ e. y+ n. h! w% g& ~ M
LuData a;
' }, z, T; _* \2 }) F4 n\\" x
myMatrix *pMatrix1,*pMatrix2,*pMatrix3;
5 g+ \# A1 X' M L1 T! u% w2 g
luVOID i,j,k,m,n,u,v;* v: [4 K/ J: I
double *pa,*pb,*pc;) j+ v7 F4 q8 {2 u% x7 w
luMessage pMessage;
/ R' h: i, _6 M
wchar_t wchNum[32];
\\" z\\" _: n' f% ]+ q8 O
char chNum[32];
7 u# B1 E) Z/ f9 I0 C+ J5 K( c9 t
a.BType=luStaData_nil; a.VType=luStaData_nil; a.x=0;
5 L3 T: A5 x\\" e\\" k( _8 j R: o
switch(theOperator)1 n1 w2 v3 M ]+ Y T# B5 F
{/ z; {8 z+ r; g; o- E) {/ i
case 2: //重载运算符*
- `) b6 A5 D# p3 G# n\\" R, G
pMatrix1=(myMatrix *)SearchKey((char *)&(xx->x),sizeof(luVOID),Matrix);
! x$ F# t' \ T1 e) S7 b4 U' c
pMatrix2=(myMatrix *)SearchKey((char *)&((xx+1)->x),sizeof(luVOID),Matrix); U& \% j% S2 l2 [9 }
if(!pMatrix1 || !pMatrix2) break; //对象句柄无效，不是矩阵/ V' ^8 d\\" W( C' w
if(pMatrix1->Dim[1]!=pMatrix2->Dim[0]) break; //维数不匹配
% ^; }; ]0 I6 }
pMatrix3=NewMatrix(pMatrix1->Dim[0],pMatrix2->Dim[1]); //生成新矩阵
- C; b+ l& Z, [6 {# k
if(!pMatrix3) break;0 ~8 q' A7 y3 J1 _, p6 C
pa=pMatrix1->Array; pb=pMatrix2->Array; pc=pMatrix3->Array;7 Q! J, n. u A$ E& d\\" G
m=pMatrix1->Dim[0]; n=pMatrix1->Dim[1]; k=pMatrix2->Dim[1];9 j6 t+ N/ E% b\\" e+ t
for(i=0; i<m; i++) //矩阵乘4 R4 L3 M7 p, p0 O8 U\\" Q% u
{
: s7 Q$ B, c0 j3 K0 I
for(j=0; j<k; j++)
$ \* y4 M) J% f1 G
{
. T. p; {& L# M1 b
u=i*k+j; pc[u]=0.0;- G' M; b+ C' P5 N3 a3 r
for (v=0; v<n; v++)
: T' Y% N2 z& S\\" W, D9 ^$ L
{
: g$ X/ t& Q' L+ {( n/ F8 g' U- e
pc[u]=pc[u]+pa[i*n+v]*pb[v*k+j];
% V6 f$ ^8 [ |6 q! _
}
' ^0 Y: }8 _6 }1 Q H
}: v# ~# G. T$ m) Z! [5 s
}% y4 a; |0 A; x& ]5 T- ^- E
FunReObj(hFor); //告诉Lu，返回一个动态对象3 O0 F* U\\" ~6 q; z/ U7 F6 u
a.BType=Matrix; a.VType=Matrix; a.x=0; *(luVOID *)&(a.x)=(luVOID)pMatrix3;
6 ~% Z$ X8 m% H: _3 l) I
break;+ T9 K2 v0 m9 l% a$ ], k
case 25: //重载运算符.*
6 Q/ \2 d9 x3 R5 O# V
pMatrix1=(myMatrix *)SearchKey((char *)&(xx->x),sizeof(luVOID),Matrix);, i9 P; k2 s' R2 H
pMatrix2=(myMatrix *)SearchKey((char *)&((xx+1)->x),sizeof(luVOID),Matrix);5 `- R6 c% Q/ v/ Y
if(!pMatrix1 || !pMatrix2) break; //对象句柄无效，不是矩阵1 g3 z: p7 ^# Y& E, G
if(pMatrix1->Dim[0]!=pMatrix2->Dim[0] || pMatrix1->Dim[1]!=pMatrix2->Dim[1]) break; //维数不相同
\\" \, j9 H F- h% H% ^9 T. O- j. x
pMatrix3=NewMatrix(pMatrix1->Dim[0],pMatrix1->Dim[1]); //生成新矩阵/ q5 R, k1 r% G
if(!pMatrix3) break;, D$ ?: f5 ]4 ?' _
for(i=0;i<pMatrix1->ArrayLen;i++) pMatrix3->Array[i]=pMatrix1->Array[i]*pMatrix2->Array[i]; //矩阵点乘; d6 A: E/ H z5 n
FunReObj(hFor); //告诉Lu，返回一个动态对象
' V& q; Q2 i2 P7 p2 q3 N) J( t
a.BType=Matrix; a.VType=Matrix; a.x=0; *(luVOID *)&(a.x)=(luVOID)pMatrix3;. ~$ F& O T. F e' K
break;
4 i- o0 N7 k2 u8 n\\" _& M- J+ i
case 46: //重载函数new7 E: x6 A) p O W; o
if(mm<2) break;4 y1 @: m! L: a+ [0 P. I6 O
if((xx+1)->x<1 || (xx+2)->x<1 || (xx+1)->BType!=luStaData_int64 || (xx+2)->BType!=luStaData_int64) break;
! X9 Z5 O9 h2 M
pMatrix3=NewMatrix((luVOID)(xx+1)->x,(luVOID)(xx+2)->x);//生成新矩阵
6 u3 m# Z8 _- [3 E
if(!pMatrix3) break;
\\" J! K b& F! A0 s8 E
for(j=0,i=3;i<=mm;i++,j++) //赋初值' M, @) f8 ^% @5 W0 o9 h/ ?- k
{
1 B8 x! p\\" i: W9 y* U d7 Y
if(j>=pMatrix3->ArrayLen) break;
; S8 K7 ~, E) I5 ^, d. M: j: s o! q
if((xx+i)->BType!=luStaData_double) break; //只接受实数参数
4 d; `. [! S. G5 {7 s3 `% O& \( n6 d
pMatrix3->Array[j]=*(double *)&((xx+i)->x);
# R6 I9 e, n0 I( S! V
}1 {! U1 A$ x3 y, w: t) V\\" E
FunReObj(hFor); //告诉Lu，返回一个动态对象
( [$ C; I& ~5 T4 B6 W5 A& m, q
a.BType=Matrix; a.VType=Matrix; a.x=0; *(luVOID *)&(a.x)=(luVOID)pMatrix3;. o3 B& J% L- V
break;
- Q! t- Q. t- n, |# R0 Y
case 49: //重载函数o( b8 w9 n2 E' B- w1 F% o; e; C
pMessage=(luMessage)SearchKey("\0\0\0\0",sizeof(luVOID),luPubKey_User);
9 e$ b3 R8 p, ]4 ?- ]- f
if(!pMessage) break;
3 h\\" @6 i$ v# |* b2 }' B9 G% ^! ^, M
pMatrix1=(myMatrix *)SearchKey((char *)&(xx->x),sizeof(luVOID),Matrix);# u8 J4 r: u+ M0 w; ^3 r; {5 q) i( \! S
if(!pMatrix1) break; //对象句柄无效，不是矩阵
( y8 F8 u/ H1 K* f: ~\\" p
pa=pMatrix1->Array;$ f6 F. V2 }4 j4 A8 B+ V! r
m=pMatrix1->Dim[0]; n=pMatrix1->Dim[1]; k=0;
* {. C' j8 I7 }7 P: } r\\" }5 ^
for(i=0; i<m; i++) //输出矩阵
# C; B6 C) Z$ i/ t; j
{
7 W( P\\" i. `5 c\\" r
pMessage(L"\r\n"); k+=2;; M$ M- O$ I( Z: a* f3 Y
for(j=0; j<n; j++)2 |2 U z8 r- W8 E# F* I: l, d& V
{- K1 D/ x# }9 y2 S6 v3 g( A
_gcvt_s(chNum,pa[i*n+j],16);
# ^! g\\" U0 A6 j+ Z5 k
for(u=0;chNum[u];u++) {wchNum[u]=chNum[u]; k++;}
# ` N1 G/ Y' {( W8 d5 W* J
wchNum[u]='\0';
: l5 k% D& b( b
pMessage(wchNum); pMessage(L" "); k+=2;
( U. t/ f1 o8 O( ~) k+ H
}8 r: y3 d$ f/ n0 X\\" U; r
}
; | K; H0 t* a, z
pMessage(L"\r\n"); k+=2;
* U4 y5 O; n: c) c3 T: }0 F
a.BType=luStaData_int64; a.VType=luStaData_int64; a.x=k; //按函数o的要求，返回输出的字符总数
' h' ]) u9 ~, U5 w7 E0 e
break;
: S) {1 p7 @, v/ Y7 n7 ~
default:
* U, j* E8 M' \6 J& f
break;
5 [9 T+ X ^! o' T' A7 W2 V
}
\\" A5 {# J\\" i9 m5 N5 D2 e$ D
return a;
$ J+ Y& f2 u4 ^
}) c V }! D0 G: [
void main(void)
9 I+ N3 m$ W# h- W4 i+ q9 D
{& A4 e& |' H/ {
void *hFor; //表达式句柄
) R, g5 @* p/ c, t
luINT nPara; //存放表达式的自变量个数
/ _4 `) {, K0 Y) x
LuData *pPara; //存放输入自变量的数组指针
( @4 j8 m1 Z' `$ @2 Y
luINT ErrBegin,ErrEnd; //表达式编译出错的初始位置和结束位置 i2 @$ B3 Z2 }/ r3 _. d: r
int ErrCode; //错误代码: d% o2 i W% [( h1 V3 r
void *v; i3 B! U0 D! G7 n! Y) \# P
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.]}";//字符串表达式，矩阵乘7 c9 I2 [6 O L
//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.]}";//字符串表达式，矩阵点乘7 t0 f6 |, x\\" l9 @: b+ Y% z! E
LuData Val;
4 I; C+ Y( t' w. y4 p9 ?! Q
if(!InitLu()) return; //初始化Lu
+ K0 ^$ H0 a$ l- [$ t- u3 D8 F
while(LockKey(Matrix,DelMatrix,OpMatrix)){Matrix--;} //锁定一个键，用于存储矩阵扩展类型
# }0 O; o9 q# ~0 ?
0 @! C1 d& p' N. f2 ?- L
Val.BType=luStaData_int64; Val.VType=luStaData_int64; Val.x=Matrix; //定义整数常量: @: [( `8 ~, U- ^\\" ~
SetConst(L"matrix",&Val); //设置整数常量
) N! v- ^\\" J6 d+ i2 n
InsertKey("\0\0\0\0",4,luPubKey_User,LuMessage,NULL,NULL,1,v); //使Lu运行时可输出函数信息
9 W* l\\" \9 E7 a( Y9 C7 k% J
wcout.imbue(locale("chs")); //设置输出的locale为中文 p0 W9 _1 S- b# w
! r2 t& T8 y# P( u$ ]1 l
ErrCode=LuCom(ForStr,0,0,0,hFor,nPara,pPara,ErrBegin,ErrEnd); //编译表达式* O, `# I- i5 Z/ f1 ]
if(ErrCode)' {6 F7 C; }- G+ t ^- r D9 }3 `; `
{3 a) q; M2 p! w$ c5 \2 P5 X4 X2 q J
wcout<<L"表达式有错误！错误代码："<<ErrCode<<endl;6 @0 t1 U# H n9 R
}
% c! }9 p1 C6 G/ i1 n6 ~
else
\\" P+ x0 X0 P+ ]6 O @
{. |, N' M' j\\" d5 m
LuCal(hFor,pPara); //计算表达式的值
8 `) [4 ?. w! }: d3 T5 t
}/ \6 I; e: Q+ F X0 L# V b4 l
LockKey(Matrix,NULL,OpMatrix);//解锁键Matrix，本例中，该函数可以不用, c, v) ^( D# f' [
FreeLu(); //释放Lu
$ j7 x7 B$ t- R# W
}

#include <windows.h>2 y6 ^5 ~9 S1 i# D6 m4 @2 W. }

#include <iostream># f% J5 L2 q& H6 A0 ]

#include <math.h> 
. r' C+ U( ]4 a
#include "lu32.h" 
9 L3 i. C7 u4 X* U* G7 ?( K
#pragma comment( lib, "lu32.lib" )0 X; E2 c' ?# z* e

using namespace std; 
& ~0 W7 c$ ]\\" H$ g
//自定义矩阵/ h+ X0 D: {9 e0 Y9 D0 \. \

class myMatrix' t* z7 A+ v( u- z7 N! m2 v\\" x6 y5 C

{ 
4 ]* D7 x% _  d$ J! s
public: 
! s1 l5 ~  g# K* ]1 U. |
        double *Array;        //数据缓冲区. w3 D! ?) n( E7 U

luVOID ArrayLen;        //数据缓冲区长度9 K# B, o; k8 d- q! ?

luVOID Dim[2];        //矩阵维数8 v! {5 m8 m- B+ C( A' f

myMatrix(){Array=NULL; ArrayLen=0; Dim[0]=0; Dim[1]=0;}; d, Y* m- U/ [6 i+ u7 t

~myMatrix() 
5 {: {+ u' ?9 q: Z: E! K. z
        {3 f% U5 Y7 m* x9 S. k6 v% A. e

if(Array) delete[] Array;; d& `# _- {  }3 _

} 
2 x! w\\" K! {, A8 G
};* c% Y$ d4 R. o4 K

luKEY Matrix=-1000;        //标识矩阵类型，最终的Matrix由LockKey决定 
* B7 v. B, I4 Q, {
void _stdcall LuMessage(wchar_t *pch)//输出动态库信息，该函数注册到Lu，由Lu二级函数调用 ) {0 W5 V: T% x

{5 U\\" `2 H# u6 k

wcout<<pch; 
+ Q: F6 W6 }\\" c! @& t/ P- d7 g
}7 X+ D& j0 P7 b; X6 D# G9 T

void _stdcall DelMatrix(void *me)        //用于LockKey函数及InsertKey函数，使Lu能自动销毁myMatrix对象# y) j/ K8 Q: E( Q: a

{ 
9 E9 X+ z' n; |) ]- }* p( P+ e
        delete (myMatrix *)me; 
; D# o# V3 A1 L  h
}/ U; o9 G  P* i7 a* C

myMatrix * _stdcall NewMatrix(luVOID m,luVOID n)        //生成一个myMatrix对象 
$ b5 r' ]- x; T- {' G7 E0 o
{9 E5 \5 q+ G1 K- ]7 `

myMatrix *pMatrix;) c, }8 F4 u& \# J. A8 Z

luVOID k; 
* k+ z+ y9 {$ _5 \; Z
        double *pa; 
2 b: c1 z, B' ^& o' a
        char keyname[sizeof(luVOID)];; R' c) \! \# N0 V

void *NowKey;7 Z' h( w$ s+ P( h9 {

k=m*n;/ R/ V! ?3 O' I% @7 X6 Z/ l

pMatrix=(myMatrix *)GetBufObj(Matrix,keyname);//先尝试从缓冲区中获取一个矩阵对象 
- d/ S% N/ I# ~: u
        if(pMatrix) 
0 {3 p& H* l  ~: A; s
        { 
$ U2 a, H6 L; L1 _
                if(pMatrix->ArrayLen!=k)        //重置矩阵的大小 
8 [2 m8 i* l$ r7 z* I
                {, }6 o* t) F, g' n- u' \2 W/ I8 D

pa=new double[k]; 
; ?* w# }, G( D2 `7 h* O9 W- V
                        if(!pa)2 Z, i& _1 {$ \! W4 x0 S5 i9 J, z, D

{ 
# l) ?( b+ ]! g& \: S! l7 X
                                DeleteKey(keyname,sizeof(luVOID),Matrix,DelMatrix,1);        //将矩阵对象放回缓冲区 
: f/ W. k3 `3 s# y: p7 x
                                return NULL;3 A9 K( f0 |0 f5 I1 O3 M) V! i

} 
5 w8 Q, `/ V& `  D& ~* J
                        delete[] pMatrix->Array;& g1 V/ v$ j2 _& A& e

pMatrix->Array=pa;9 ?( U) ~, \\\" r7 f

}$ I# l' Q/ ~2 z% A

} 
! w- a# q9 r$ ?2 _1 l
        else* o7 l2 j9 B9 N% ]& h

{ 
\\" i! n2 l8 f. T0 ]% N6 ]' s
                pMatrix=new myMatrix;        //创建矩阵对象6 h+ p( p& k4 o; d) j$ N

if(!pMatrix) return NULL;6 r! b$ c9 F( F$ `# h\\" _, l

pMatrix->Array=new double[k];; C) y6 x1 V9 n- X9 O

if(!pMatrix->Array) 
0 J5 e  J' F9 H0 K, ?
                {. f/ `/ E- h, \( ?

delete pMatrix;6 e\\" @2 X1 N/ `+ C4 u# ?7 R

return NULL;4 z, c0 U3 q$ T

} 
8 u4 Y* K. x  V7 Y8 w: A4 N
                if(InsertKey((char *)&pMatrix,-1,Matrix,pMatrix,DelMatrix,NULL,0,NowKey))        //将矩阵对象注册到Lu 
* O2 i0 v5 [% E
                { 
4 y$ o) H/ B0 C7 I/ f+ {% Q% M
                        delete pMatrix; 
& s/ p5 U* a\\" d; f\\" D
                        return NULL; 
7 }9 h- ]$ H. q) O# z\\" n
                } 
+ J6 Z\\" m4 T4 R  b) y7 `
        } 
( t& z- N, J$ [6 k, a
        pMatrix->ArrayLen=k; pMatrix->Dim[0]=m; pMatrix->Dim[1]=n; 
  o7 d1 m/ J7 O
        return pMatrix; 
' N( _+ Q0 G% \% ^) M
} 
' |) E7 U. C9 X1 @: a7 V7 b
LuData _stdcall OpMatrix(luINT mm,LuData *xx,void *hFor,int theOperator)        //运算符重载函数，用于LockKey函数 
6 i) l3 H7 Y. E$ O: A1 S! i
{ 
$ e. y+ n. h! w% g& ~  M
        LuData a; 
' }, z, T; _* \2 }) F4 n\\" x
        myMatrix *pMatrix1,*pMatrix2,*pMatrix3; 
5 g+ \# A1 X' M  L1 T! u% w2 g
        luVOID i,j,k,m,n,u,v;* v: [4 K/ J: I

double *pa,*pb,*pc;) j+ v7 F4 q8 {2 u% x7 w

luMessage pMessage; 
/ R' h: i, _6 M
        wchar_t wchNum[32]; 
\\" z\\" _: n' f% ]+ q8 O
        char chNum[32]; 
7 u# B1 E) Z/ f9 I0 C+ J5 K( c9 t
        a.BType=luStaData_nil; a.VType=luStaData_nil; a.x=0; 
5 L3 T: A5 x\\" e\\" k( _8 j  R: o
        switch(theOperator)1 n1 w2 v3 M  ]+ Y  T# B5 F

{/ z; {8 z+ r; g; o- E) {/ i

case 2:        //重载运算符* 
- `) b6 A5 D# p3 G# n\\" R, G
                pMatrix1=(myMatrix *)SearchKey((char *)&(xx->x),sizeof(luVOID),Matrix); 
! x$ F# t' \  T1 e) S7 b4 U' c
                pMatrix2=(myMatrix *)SearchKey((char *)&((xx+1)->x),sizeof(luVOID),Matrix);  U& \% j% S2 l2 [9 }

if(!pMatrix1 || !pMatrix2) break;        //对象句柄无效，不是矩阵/ V' ^8 d\\" W( C' w

if(pMatrix1->Dim[1]!=pMatrix2->Dim[0]) break;        //维数不匹配 
% ^; }; ]0 I6 }
                pMatrix3=NewMatrix(pMatrix1->Dim[0],pMatrix2->Dim[1]);        //生成新矩阵 
- C; b+ l& Z, [6 {# k
                if(!pMatrix3) break;0 ~8 q' A7 y3 J1 _, p6 C

pa=pMatrix1->Array; pb=pMatrix2->Array; pc=pMatrix3->Array;7 Q! J, n. u  A$ E& d\\" G

m=pMatrix1->Dim[0]; n=pMatrix1->Dim[1]; k=pMatrix2->Dim[1];9 j6 t+ N/ E% b\\" e+ t

for(i=0; i<m; i++)        //矩阵乘4 R4 L3 M7 p, p0 O8 U\\" Q% u

{ 
: s7 Q$ B, c0 j3 K0 I
                        for(j=0; j<k; j++) 
$ \* y4 M) J% f1 G
                        { 
. T. p; {& L# M1 b
                                u=i*k+j; pc[u]=0.0;- G' M; b+ C' P5 N3 a3 r

for (v=0; v<n; v++) 
: T' Y% N2 z& S\\" W, D9 ^$ L
                                { 
: g$ X/ t& Q' L+ {( n/ F8 g' U- e
                                        pc[u]=pc[u]+pa[i*n+v]*pb[v*k+j]; 
% V6 f$ ^8 [  |6 q! _
                                } 
' ^0 Y: }8 _6 }1 Q  H
                        }: v# ~# G. T$ m) Z! [5 s

}% y4 a; |0 A; x& ]5 T- ^- E

FunReObj(hFor);        //告诉Lu，返回一个动态对象3 O0 F* U\\" ~6 q; z/ U7 F6 u

a.BType=Matrix; a.VType=Matrix; a.x=0; *(luVOID *)&(a.x)=(luVOID)pMatrix3; 
6 ~% Z$ X8 m% H: _3 l) I
                break;+ T9 K2 v0 m9 l% a$ ], k

case 25:        //重载运算符.* 
6 Q/ \2 d9 x3 R5 O# V
                pMatrix1=(myMatrix *)SearchKey((char *)&(xx->x),sizeof(luVOID),Matrix);, i9 P; k2 s' R2 H

pMatrix2=(myMatrix *)SearchKey((char *)&((xx+1)->x),sizeof(luVOID),Matrix);5 `- R6 c% Q/ v/ Y

if(!pMatrix1 || !pMatrix2) break;        //对象句柄无效，不是矩阵1 g3 z: p7 ^# Y& E, G

if(pMatrix1->Dim[0]!=pMatrix2->Dim[0] || pMatrix1->Dim[1]!=pMatrix2->Dim[1]) break;        //维数不相同 
\\" \, j9 H  F- h% H% ^9 T. O- j. x
                pMatrix3=NewMatrix(pMatrix1->Dim[0],pMatrix1->Dim[1]);        //生成新矩阵/ q5 R, k1 r% G

if(!pMatrix3) break;, D$ ?: f5 ]4 ?' _

for(i=0;i<pMatrix1->ArrayLen;i++) pMatrix3->Array[i]=pMatrix1->Array[i]*pMatrix2->Array[i];        //矩阵点乘; d6 A: E/ H  z5 n

FunReObj(hFor);        //告诉Lu，返回一个动态对象 
' V& q; Q2 i2 P7 p2 q3 N) J( t
                a.BType=Matrix; a.VType=Matrix; a.x=0; *(luVOID *)&(a.x)=(luVOID)pMatrix3;. ~$ F& O  T. F  e' K

break; 
4 i- o0 N7 k2 u8 n\\" _& M- J+ i
        case 46:        //重载函数new7 E: x6 A) p  O  W; o

if(mm<2) break;4 y1 @: m! L: a+ [0 P. I6 O

if((xx+1)->x<1 || (xx+2)->x<1 || (xx+1)->BType!=luStaData_int64 || (xx+2)->BType!=luStaData_int64) break; 
! X9 Z5 O9 h2 M
                pMatrix3=NewMatrix((luVOID)(xx+1)->x,(luVOID)(xx+2)->x);//生成新矩阵 
6 u3 m# Z8 _- [3 E
                if(!pMatrix3) break; 
\\" J! K  b& F! A0 s8 E
                for(j=0,i=3;i<=mm;i++,j++)        //赋初值' M, @) f8 ^% @5 W0 o9 h/ ?- k

{ 
1 B8 x! p\\" i: W9 y* U  d7 Y
                        if(j>=pMatrix3->ArrayLen) break; 
; S8 K7 ~, E) I5 ^, d. M: j: s  o! q
                        if((xx+i)->BType!=luStaData_double) break;        //只接受实数参数 
4 d; `. [! S. G5 {7 s3 `% O& \( n6 d
                        pMatrix3->Array[j]=*(double *)&((xx+i)->x); 
# R6 I9 e, n0 I( S! V
                }1 {! U1 A$ x3 y, w: t) V\\" E

FunReObj(hFor);        //告诉Lu，返回一个动态对象 
( [$ C; I& ~5 T4 B6 W5 A& m, q
                a.BType=Matrix; a.VType=Matrix; a.x=0; *(luVOID *)&(a.x)=(luVOID)pMatrix3;. o3 B& J% L- V

break; 
- Q! t- Q. t- n, |# R0 Y
        case 49:        //重载函数o( b8 w9 n2 E' B- w1 F% o; e; C

pMessage=(luMessage)SearchKey("\0\0\0\0",sizeof(luVOID),luPubKey_User); 
9 e$ b3 R8 p, ]4 ?- ]- f
                if(!pMessage) break; 
3 h\\" @6 i$ v# |* b2 }' B9 G% ^! ^, M
                pMatrix1=(myMatrix *)SearchKey((char *)&(xx->x),sizeof(luVOID),Matrix);# u8 J4 r: u+ M0 w; ^3 r; {5 q) i( \! S

if(!pMatrix1) break;        //对象句柄无效，不是矩阵 
( y8 F8 u/ H1 K* f: ~\\" p
                pa=pMatrix1->Array;$ f6 F. V2 }4 j4 A8 B+ V! r

m=pMatrix1->Dim[0]; n=pMatrix1->Dim[1]; k=0; 
* {. C' j8 I7 }7 P: }  r\\" }5 ^
                for(i=0; i<m; i++)        //输出矩阵 
# C; B6 C) Z$ i/ t; j
                { 
7 W( P\\" i. `5 c\\" r
                        pMessage(L"\r\n"); k+=2;; M$ M- O$ I( Z: a* f3 Y

for(j=0; j<n; j++)2 |2 U  z8 r- W8 E# F* I: l, d& V

{- K1 D/ x# }9 y2 S6 v3 g( A

_gcvt_s(chNum,pa[i*n+j],16); 
# ^! g\\" U0 A6 j+ Z5 k
                                for(u=0;chNum[u];u++) {wchNum[u]=chNum[u]; k++;} 
# `  N1 G/ Y' {( W8 d5 W* J
                                wchNum[u]='\0'; 
: l5 k% D& b( b
                                pMessage(wchNum); pMessage(L"  "); k+=2; 
( U. t/ f1 o8 O( ~) k+ H
                        }8 r: y3 d$ f/ n0 X\\" U; r

} 
; |  K; H0 t* a, z
                pMessage(L"\r\n"); k+=2; 
* U4 y5 O; n: c) c3 T: }0 F
                a.BType=luStaData_int64; a.VType=luStaData_int64; a.x=k;        //按函数o的要求，返回输出的字符总数 
' h' ]) u9 ~, U5 w7 E0 e
                break; 
: S) {1 p7 @, v/ Y7 n7 ~
        default: 
* U, j* E8 M' \6 J& f
                break; 
5 [9 T+ X  ^! o' T' A7 W2 V
        } 
\\" A5 {# J\\" i9 m5 N5 D2 e$ D
        return a; 
$ J+ Y& f2 u4 ^
}) c  V  }! D0 G: [

void main(void) 
9 I+ N3 m$ W# h- W4 i+ q9 D
{& A4 e& |' H/ {

void *hFor;                //表达式句柄 
) R, g5 @* p/ c, t
        luINT nPara;                //存放表达式的自变量个数 
/ _4 `) {, K0 Y) x
        LuData *pPara;                //存放输入自变量的数组指针 
( @4 j8 m1 Z' `$ @2 Y
        luINT ErrBegin,ErrEnd;        //表达式编译出错的初始位置和结束位置  i2 @$ B3 Z2 }/ r3 _. d: r

int ErrCode;                //错误代码: d% o2 i  W% [( h1 V3 r

void *v;  i3 B! U0 D! G7 n! Y) \# P

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.]}";//字符串表达式，矩阵乘7 c9 I2 [6 O  L

//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.]}";//字符串表达式，矩阵点乘7 t0 f6 |, x\\" l9 @: b+ Y% z! E

LuData Val; 
4 I; C+ Y( t' w. y4 p9 ?! Q
        if(!InitLu()) return;        //初始化Lu 
+ K0 ^$ H0 a$ l- [$ t- u3 D8 F
        while(LockKey(Matrix,DelMatrix,OpMatrix)){Matrix--;}        //锁定一个键，用于存储矩阵扩展类型 
# }0 O; o9 q# ~0 ?
0 @! C1 d& p' N. f2 ?- L

Val.BType=luStaData_int64; Val.VType=luStaData_int64; Val.x=Matrix;        //定义整数常量: @: [( `8 ~, U- ^\\" ~

SetConst(L"matrix",&Val);        //设置整数常量 
) N! v- ^\\" J6 d+ i2 n
        InsertKey("\0\0\0\0",4,luPubKey_User,LuMessage,NULL,NULL,1,v); //使Lu运行时可输出函数信息 
9 W* l\\" \9 E7 a( Y9 C7 k% J
        wcout.imbue(locale("chs"));        //设置输出的locale为中文  p0 W9 _1 S- b# w

! r2 t& T8 y# P( u$ ]1 l
        ErrCode=LuCom(ForStr,0,0,0,hFor,nPara,pPara,ErrBegin,ErrEnd); //编译表达式* O, `# I- i5 Z/ f1 ]

if(ErrCode)' {6 F7 C; }- G+ t  ^- r  D9 }3 `; `

{3 a) q; M2 p! w$ c5 \2 P5 X4 X2 q  J

wcout<<L"表达式有错误！错误代码："<<ErrCode<<endl;6 @0 t1 U# H  n9 R

} 
% c! }9 p1 C6 G/ i1 n6 ~
        else 
\\" P+ x0 X0 P+ ]6 O  @
        {. |, N' M' j\\" d5 m

LuCal(hFor,pPara);        //计算表达式的值 
8 `) [4 ?. w! }: d3 T5 t
        }/ \6 I; e: Q+ F  X0 L# V  b4 l

LockKey(Matrix,NULL,OpMatrix);//解锁键Matrix，本例中，该函数可以不用, c, v) ^( D# f' [

FreeLu();                        //释放Lu 
$ j7 x7 B$ t- R# W
}

习题：

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

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

main(:a,b,c,d,t,i)=
2 x: D0 c; e4 A6 r5 P2 x% W
a=new[matrix,2,2: 1.,2.,2.,1.],
4 Z8 e# ]& ^* D) g) e
b=new[matrix,2,2: 2.,1.,1.,2.],
\" c$ d: k( l- y# I
c=new[matrix,2,2: 2/3.,-1/3.,-1/3.,2/3.],' y$ s& k4 {- Q) q( |1 W
t=clock(),
[8 ?, z3 K8 _! t# m$ O* K
d=a*b, i=0, while{i<1000000, d=d*c*b, i++},
; @( c4 _# p% p1 f: G- A% x9 {
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\"}";//字符串表达式

复制代码

结果：