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

查看: 8485|回复: 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>
1 N( s- h+ T! l. j k
#include <iostream>5 v i5 ?5 m; n Q+ r& [\\" g+ F
#include <math.h>5 z8 n& }' [2 ^- e\\" x
#include "lu32.h"
$ e- F\\" ^' J& q
#pragma comment( lib, "lu32.lib" )
+ ^ @$ T3 _\\" u! O/ _; v/ L8 R. O
using namespace std;2 u0 H( b6 I9 k' t5 B, G
//自定义矩阵3 M' A6 k2 d1 ~
class myMatrix
+ G. [3 F/ x* }' S
{- J) J2 l6 b1 s( J/ t
public:) `/ i. y2 h, Q3 B# @( f5 a
double *Array; //数据缓冲区+ E6 r, k$ t& }7 Y
luVOID ArrayLen; //数据缓冲区长度, @) v* |/ M, v) _: [6 Y8 a
luVOID Dim[2]; //矩阵维数
/ }' _) R3 R\\" p3 v. n
myMatrix(){Array=NULL; ArrayLen=0; Dim[0]=0; Dim[1]=0;}
4 T: J, X4 _- p1 q+ b- h
~myMatrix()
9 H m$ R- T+ {6 o4 l& Q0 [2 m
{
! o' j8 L6 `( ?+ w# G
if(Array) delete[] Array;
+ e! |1 U2 T* x
}
. \9 d- H: @, {\\" i1 o
};
5 |\\" U- r7 t4 @% R4 c
luKEY Matrix=-1000; //标识矩阵类型，最终的Matrix由LockKey决定, s3 s0 p. }' B+ F
void _stdcall LuMessage(wchar_t *pch)//输出动态库信息，该函数注册到Lu，由Lu二级函数调用
2 J% |! E\\" B3 A
{' ]2 B. H5 G# ^( P
wcout<<pch;
W$ V* L$ l* E$ ?2 }\\" o7 _
}
( D\\" J1 X3 c$ G
void _stdcall DelMatrix(void *me) //用于LockKey函数及InsertKey函数，使Lu能自动销毁myMatrix对象
9 w- G. A$ e$ S/ _0 a
{
2 Q: x1 T\\" n) e1 l
delete (myMatrix *)me;! A4 ^/ i% L2 {9 @9 J, l9 I
}\\" B5 L5 d/ U. L/ h
myMatrix * _stdcall NewMatrix(luVOID m,luVOID n) //生成一个myMatrix对象
2 N, Z1 G& o/ i0 ^9 x4 K
{9 e6 A9 [# {) M& T# B2 A\\" j; {/ y5 N
myMatrix *pMatrix;4 H4 j6 m( [4 e, `
luVOID k;
% U: o+ @1 l- P, D2 n9 e1 v M
double *pa;
) w; B# i4 u' w\\" }1 e0 K6 U
char keyname[sizeof(luVOID)];
( K5 I, S1 ]0 w9 g% M* W1 C- f: B
void *NowKey;+ r+ U; R. k+ w5 \; p: Q
k=m*n;
+ U, E7 P m9 o; N+ \% H, i
pMatrix=(myMatrix *)GetBufObj(Matrix,keyname);//先尝试从缓冲区中获取一个矩阵对象
) \: ^# R @; B# {; f3 x4 [
if(pMatrix)' y' @) m$ W$ t8 C& V\\" ~1 O( F
{
1 S5 U _$ ^$ J( e4 T
if(pMatrix->ArrayLen!=k) //重置矩阵的大小
# Q1 D1 f v! n
{, M# B\\" i: q, V, R
pa=new double[k];
. |9 ~# j0 `\\" ]8 l# h8 d
if(!pa)9 a& j+ u. v3 T2 i% Y
{$ n\\" T5 X4 K' a( }
DeleteKey(keyname,sizeof(luVOID),Matrix,DelMatrix,1); //将矩阵对象放回缓冲区
3 K7 w* ~6 g2 a; K' z& i; K* W
return NULL;& D& b6 ]+ Y. b' @) @! w1 l0 n- z
}
$ @5 j. M\\" q g% J3 \' a
delete[] pMatrix->Array;
4 ^% Z/ n3 E5 `
pMatrix->Array=pa;7 h0 ~* {& e2 c# i! w1 \2 @
}2 I: Y: N* Y7 `/ d2 W8 v; Z( d
}5 n' d% K. e9 [& Z+ ]1 x
else# b1 G1 E' ~: y. e8 C- I1 C8 F
{2 s! j& O$ w5 ^ h\\" i) O+ y/ U, o
pMatrix=new myMatrix; //创建矩阵对象
. f% x/ \' V# K- w3 W. T$ ^$ X
if(!pMatrix) return NULL;
1 J9 b1 i4 I; U$ R+ C- j0 H\\" i
pMatrix->Array=new double[k];4 V* O! c4 `3 R' ^$ ?9 ?
if(!pMatrix->Array), K, x( W# |5 e, k1 x% _2 \
{2 n) K0 p% P4 q6 p- \ I
delete pMatrix;# W, C$ u+ s- _/ u1 e5 a
return NULL;3 V) {& q s* M' X5 ^' `; y
}
4 z$ u. u7 T# W, _. E1 w
if(InsertKey((char *)&pMatrix,-1,Matrix,pMatrix,DelMatrix,NULL,0,NowKey)) //将矩阵对象注册到Lu
\\" J# h4 P# I$ }9 V1 \
{
; b( p: r3 v) `5 G! W
delete pMatrix;
6 A2 [9 m K6 {
return NULL;
9 J1 U. G) @) |5 n, }
}
. q( u% W: l\\" [+ n% y* b
}% B# s- b/ v7 m! g
pMatrix->ArrayLen=k; pMatrix->Dim[0]=m; pMatrix->Dim[1]=n;, T* w% y3 u+ y Q9 U5 X/ Y: I
return pMatrix;+ U7 d% \! w; P V/ E2 ?
}6 R+ B\\" j) C0 f* h- g/ A1 U4 ?3 K: u
LuData _stdcall OpMatrix(luINT mm,LuData *xx,void *hFor,int theOperator) //运算符重载函数，用于LockKey函数
! e% E+ T5 b) p' Y9 i6 a
{
' }\\" n, n/ p; j1 l, m
LuData a;$ l8 \9 Q9 r/ _, a2 f+ |
myMatrix *pMatrix1,*pMatrix2,*pMatrix3;
1 `' X2 \0 u1 r% l5 G, s& ~0 a* U
luVOID i,j,k,m,n,u,v;3 E9 w9 O5 S f% [0 |
double *pa,*pb,*pc;\\" G, q: E0 Y: c- ]# c6 K& N4 a
luMessage pMessage;7 t0 b9 p. s3 M\\" e/ V
wchar_t wchNum[32];
% t( z. |\\" _& A4 Y9 j+ F, m
char chNum[32];\\" x' J/ c9 |/ B
a.BType=luStaData_nil; a.VType=luStaData_nil; a.x=0;, M\\" a8 t. k; ?
switch(theOperator)) \; b; _' l1 m) K5 P l
{ B4 p: `+ j6 p- Y5 k
case 2: //重载运算符*
\\" X6 S( r$ C- F! l
pMatrix1=(myMatrix *)SearchKey((char *)&(xx->x),sizeof(luVOID),Matrix);* j\\" z X+ I- x5 o5 o8 [
pMatrix2=(myMatrix *)SearchKey((char *)&((xx+1)->x),sizeof(luVOID),Matrix);
8 P, @0 @\\" X# M7 ?2 I4 m
if(!pMatrix1 || !pMatrix2) break; //对象句柄无效，不是矩阵
/ s/ z% ?# R3 i% X' T& _/ r
if(pMatrix1->Dim[1]!=pMatrix2->Dim[0]) break; //维数不匹配
, z( |. h( I* R' Z2 q# Q* o8 n
pMatrix3=NewMatrix(pMatrix1->Dim[0],pMatrix2->Dim[1]); //生成新矩阵
7 M/ D5 d$ V: k9 N4 O- y5 F' k1 P
if(!pMatrix3) break;+ x) A/ X9 N6 P; q\\" m {! H( F
pa=pMatrix1->Array; pb=pMatrix2->Array; pc=pMatrix3->Array;' d& C8 w3 h8 B) K
m=pMatrix1->Dim[0]; n=pMatrix1->Dim[1]; k=pMatrix2->Dim[1];
+ a! ?& m- v; w9 d/ c
for(i=0; i<m; i++) //矩阵乘
, Y C. L; \6 W& g
{
w6 q* v7 |! I/ H: m
for(j=0; j<k; j++)! m4 {/ B1 u j. B3 Q+ I
{$ k, \* A9 @! O. Z; f4 T
u=i*k+j; pc[u]=0.0;* t8 b6 G8 i r' f( K0 c: |! d, i W T
for (v=0; v<n; v++): t. }7 t! S* e! U0 ~4 z
{7 e0 ]# [3 e; k( C# l& G2 e\\" {
pc[u]=pc[u]+pa[i*n+v]*pb[v*k+j];8 Y2 k% Y- `7 m0 f1 U
}; o/ ~2 q8 o5 X
}
7 I2 R( N\\" Q0 w+ h2 ]; g8 l
}! c4 Y9 c: G* `4 _, j ]: K
FunReObj(hFor); //告诉Lu，返回一个动态对象; v8 }6 _) S7 |
a.BType=Matrix; a.VType=Matrix; a.x=0; *(luVOID *)&(a.x)=(luVOID)pMatrix3;
) K6 U4 _0 V5 H) M8 g
break;# W+ o; |\\" Q: |- B* z9 f
case 25: //重载运算符.*
% U; }2 a. v, x. t( u% u
pMatrix1=(myMatrix *)SearchKey((char *)&(xx->x),sizeof(luVOID),Matrix);) w4 _) _# d( a7 `& }' C$ p y
pMatrix2=(myMatrix *)SearchKey((char *)&((xx+1)->x),sizeof(luVOID),Matrix);
* \$ M\\" A# a2 Q* S$ e' M
if(!pMatrix1 || !pMatrix2) break; //对象句柄无效，不是矩阵
0 R- z4 l$ i0 |- `( g
if(pMatrix1->Dim[0]!=pMatrix2->Dim[0] || pMatrix1->Dim[1]!=pMatrix2->Dim[1]) break; //维数不相同2 K\\" V- H E/ ^/ i) |# j
pMatrix3=NewMatrix(pMatrix1->Dim[0],pMatrix1->Dim[1]); //生成新矩阵
6 l$ I2 Z Q8 y
if(!pMatrix3) break;7 o5 D: z1 U8 p# s7 d
for(i=0;i<pMatrix1->ArrayLen;i++) pMatrix3->Array[i]=pMatrix1->Array[i]*pMatrix2->Array[i]; //矩阵点乘
, B: G3 {1 y# A9 J
FunReObj(hFor); //告诉Lu，返回一个动态对象6 V. |) O: T$ x; f6 k5 w& T' Y7 h3 Q
a.BType=Matrix; a.VType=Matrix; a.x=0; *(luVOID *)&(a.x)=(luVOID)pMatrix3;
0 I- ]* K6 L$ A5 `% N\\" ?
break;
# u! a9 [! U$ F% ?9 N
case 46: //重载函数new
1 a& y# Y. U\\" V1 V. Z, n @
if(mm<2) break;
W0 @' F/ a* O
if((xx+1)->x<1 || (xx+2)->x<1 || (xx+1)->BType!=luStaData_int64 || (xx+2)->BType!=luStaData_int64) break;
# B( f0 ?' Y7 K1 d
pMatrix3=NewMatrix((luVOID)(xx+1)->x,(luVOID)(xx+2)->x);//生成新矩阵
9 J# @& O. e1 q! `3 v
if(!pMatrix3) break;
u1 i; X0 L7 ^8 y1 K/ A6 W% y
for(j=0,i=3;i<=mm;i++,j++) //赋初值9 V\\" [+ N8 A: Q/ Z3 n3 u
{
3 w\\" I! @4 D4 ~# F5 v1 F6 j5 \
if(j>=pMatrix3->ArrayLen) break;
. [) ?+ p( M# S
if((xx+i)->BType!=luStaData_double) break; //只接受实数参数
2 `' |' @& `. P$ K) P
pMatrix3->Array[j]=*(double *)&((xx+i)->x);\\" K- l/ H7 I1 j4 v% X+ i
}( b1 t7 l% \1 [$ l
FunReObj(hFor); //告诉Lu，返回一个动态对象4 E, O/ J2 @* b. d6 ]5 ^
a.BType=Matrix; a.VType=Matrix; a.x=0; *(luVOID *)&(a.x)=(luVOID)pMatrix3;
- z; F' [; U( `+ X8 Z
break;
2 O/ S0 R/ E- Z) p; \6 x! M5 {6 S
case 49: //重载函数o\\" x6 y- @8 ?. x% b. H# v
pMessage=(luMessage)SearchKey("\0\0\0\0",sizeof(luVOID),luPubKey_User);
2 V3 h8 T: U7 s6 |5 Z$ ~# S
if(!pMessage) break;
7 t\\" Z/ \; M5 ~1 n1 q
pMatrix1=(myMatrix *)SearchKey((char *)&(xx->x),sizeof(luVOID),Matrix);
) k j/ q0 I2 t8 L4 s# W- y
if(!pMatrix1) break; //对象句柄无效，不是矩阵& X- g6 ]! F! J# r* ^3 I4 n
pa=pMatrix1->Array;
2 L# \! G: _8 q2 Z }3 @
m=pMatrix1->Dim[0]; n=pMatrix1->Dim[1]; k=0;
4 F$ M0 ^: C\\" w4 e( f
for(i=0; i<m; i++) //输出矩阵
* K: t9 P\\" Q, t& l
{5 p# u\\" ^* v$ S5 J8 ^
pMessage(L"\r\n"); k+=2;
- t$ c& r3 p3 I
for(j=0; j<n; j++)2 b+ C$ k s# J7 a8 }
{
. H3 b! q6 A& v+ O1 c* Z
_gcvt_s(chNum,pa[i*n+j],16);
5 S+ O4 Z\\" N# i# V- e4 K g7 i+ x
for(u=0;chNum[u];u++) {wchNum[u]=chNum[u]; k++;}. z3 s% [+ I, f
wchNum[u]='\0';; _- \\\" b2 f9 i\\" p
pMessage(wchNum); pMessage(L" "); k+=2;
- p- ?7 r) ?) G. y, v) E
}
3 |, T% ] X; ]; G0 i0 \$ j/ t
}
7 U- E5 X3 v* U4 {, K2 m' m. y! J& M
pMessage(L"\r\n"); k+=2;, E- D0 j% z d. `4 b, L
a.BType=luStaData_int64; a.VType=luStaData_int64; a.x=k; //按函数o的要求，返回输出的字符总数
, v8 a6 k: S: n4 q, m- Q/ {. \9 n
break;7 r; I* x2 S0 N0 P) j% s
default:
; K; y\\" ]2 M: [0 {' i% {
break;+ Z\\" n9 q; d) h- i+ e c5 J7 g7 a2 j9 T
}
4 N1 f# B\\" c- S( ^* t3 |. G9 }
return a;
/ {0 n% f4 K. m2 J
}' ?\\" c4 x; @$ g' P. \* [
void main(void)
4 @) }) c; Y! y/ s. q
{
! f! n; Q D$ I$ S4 U+ l+ c
void *hFor; //表达式句柄
$ w* M$ ?! C$ Y4 h* ]5 E
luINT nPara; //存放表达式的自变量个数
+ A9 B% U8 w2 a9 U
LuData *pPara; //存放输入自变量的数组指针
) T: y; A\\" Z, A9 F0 s& S
luINT ErrBegin,ErrEnd; //表达式编译出错的初始位置和结束位置; X6 V; M, F/ C2 e A& t
int ErrCode; //错误代码1 m7 E5 _9 {& L
void *v;/ K5 `& \6 ^9 I+ i* Y; _ C7 A
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.]}";//字符串表达式，矩阵乘
- F1 q& ]$ @% z- |+ F. 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.]}";//字符串表达式，矩阵点乘
0 q3 W+ _( Q- j. I$ l' C
LuData Val;2 {- O& J, W: f2 F: V2 ^/ u
if(!InitLu()) return; //初始化Lu. s9 h/ O5 C& j8 w& n\\" R7 |7 D
while(LockKey(Matrix,DelMatrix,OpMatrix)){Matrix--;} //锁定一个键，用于存储矩阵扩展类型0 `/ p ^& N5 f/ F* c9 m7 q
% d4 n$ I4 V; H1 r
Val.BType=luStaData_int64; Val.VType=luStaData_int64; Val.x=Matrix; //定义整数常量4 T2 }5 A9 j% g
SetConst(L"matrix",&Val); //设置整数常量
! ~# ^. l* o$ u( ~
InsertKey("\0\0\0\0",4,luPubKey_User,LuMessage,NULL,NULL,1,v); //使Lu运行时可输出函数信息, P1 _\\" U% g4 x5 y: L% S) [8 q
wcout.imbue(locale("chs")); //设置输出的locale为中文. c0 I% @ ?+ w! ~1 {% b! y5 @
, N& C* r9 |* }* k& P! c* q+ }- a
ErrCode=LuCom(ForStr,0,0,0,hFor,nPara,pPara,ErrBegin,ErrEnd); //编译表达式7 D1 ^\\" f0 w6 p I
if(ErrCode)4 Z# u) h! _! B3 k8 l4 A
{
% d4 n4 G F& l4 l
wcout<<L"表达式有错误！错误代码："<<ErrCode<<endl;/ `4 d\\" B7 v! l7 ]# A. J& M1 f
}
( d7 f3 D v0 d/ V0 @' I
else# l2 j' s% W1 v: a( L3 t2 W
{8 W$ b/ ~1 I; }2 n$ d
LuCal(hFor,pPara); //计算表达式的值8 H. n9 E) X4 u G; M& W
}
* r: K& M4 Y, p, ?
LockKey(Matrix,NULL,OpMatrix);//解锁键Matrix，本例中，该函数可以不用! B3 _0 R1 C0 Q/ k
FreeLu(); //释放Lu
* k( x, s+ A$ P; H8 o
}

#include <windows.h> 
1 N( s- h+ T! l. j  k
#include <iostream>5 v  i5 ?5 m; n  Q+ r& [\\" g+ F

#include <math.h>5 z8 n& }' [2 ^- e\\" x

#include "lu32.h" 
$ e- F\\" ^' J& q
#pragma comment( lib, "lu32.lib" ) 
+ ^  @$ T3 _\\" u! O/ _; v/ L8 R. O
using namespace std;2 u0 H( b6 I9 k' t5 B, G

//自定义矩阵3 M' A6 k2 d1 ~

class myMatrix 
+ G. [3 F/ x* }' S
{- J) J2 l6 b1 s( J/ t

public:) `/ i. y2 h, Q3 B# @( f5 a

double *Array;        //数据缓冲区+ E6 r, k$ t& }7 Y

luVOID ArrayLen;        //数据缓冲区长度, @) v* |/ M, v) _: [6 Y8 a

luVOID Dim[2];        //矩阵维数 
/ }' _) R3 R\\" p3 v. n
        myMatrix(){Array=NULL; ArrayLen=0; Dim[0]=0; Dim[1]=0;} 
4 T: J, X4 _- p1 q+ b- h
        ~myMatrix() 
9 H  m$ R- T+ {6 o4 l& Q0 [2 m
        { 
! o' j8 L6 `( ?+ w# G
                if(Array) delete[] Array; 
+ e! |1 U2 T* x
        } 
. \9 d- H: @, {\\" i1 o
}; 
5 |\\" U- r7 t4 @% R4 c
luKEY Matrix=-1000;        //标识矩阵类型，最终的Matrix由LockKey决定, s3 s0 p. }' B+ F

void _stdcall LuMessage(wchar_t *pch)//输出动态库信息，该函数注册到Lu，由Lu二级函数调用 
2 J% |! E\\" B3 A
{' ]2 B. H5 G# ^( P

wcout<<pch; 
  W$ V* L$ l* E$ ?2 }\\" o7 _
} 
( D\\" J1 X3 c$ G
void _stdcall DelMatrix(void *me)        //用于LockKey函数及InsertKey函数，使Lu能自动销毁myMatrix对象 
9 w- G. A$ e$ S/ _0 a
{ 
2 Q: x1 T\\" n) e1 l
        delete (myMatrix *)me;! A4 ^/ i% L2 {9 @9 J, l9 I

}\\" B5 L5 d/ U. L/ h

myMatrix * _stdcall NewMatrix(luVOID m,luVOID n)        //生成一个myMatrix对象 
2 N, Z1 G& o/ i0 ^9 x4 K
{9 e6 A9 [# {) M& T# B2 A\\" j; {/ y5 N

myMatrix *pMatrix;4 H4 j6 m( [4 e, `

luVOID k; 
% U: o+ @1 l- P, D2 n9 e1 v  M
        double *pa; 
) w; B# i4 u' w\\" }1 e0 K6 U
        char keyname[sizeof(luVOID)]; 
( K5 I, S1 ]0 w9 g% M* W1 C- f: B
        void *NowKey;+ r+ U; R. k+ w5 \; p: Q

k=m*n; 
+ U, E7 P  m9 o; N+ \% H, i
        pMatrix=(myMatrix *)GetBufObj(Matrix,keyname);//先尝试从缓冲区中获取一个矩阵对象 
) \: ^# R  @; B# {; f3 x4 [
        if(pMatrix)' y' @) m$ W$ t8 C& V\\" ~1 O( F

{ 
1 S5 U  _$ ^$ J( e4 T
                if(pMatrix->ArrayLen!=k)        //重置矩阵的大小 
# Q1 D1 f  v! n
                {, M# B\\" i: q, V, R

pa=new double[k]; 
. |9 ~# j0 `\\" ]8 l# h8 d
                        if(!pa)9 a& j+ u. v3 T2 i% Y

{$ n\\" T5 X4 K' a( }

DeleteKey(keyname,sizeof(luVOID),Matrix,DelMatrix,1);        //将矩阵对象放回缓冲区 
3 K7 w* ~6 g2 a; K' z& i; K* W
                                return NULL;& D& b6 ]+ Y. b' @) @! w1 l0 n- z

} 
$ @5 j. M\\" q  g% J3 \' a
                        delete[] pMatrix->Array; 
4 ^% Z/ n3 E5 `
                        pMatrix->Array=pa;7 h0 ~* {& e2 c# i! w1 \2 @

}2 I: Y: N* Y7 `/ d2 W8 v; Z( d

}5 n' d% K. e9 [& Z+ ]1 x

else# b1 G1 E' ~: y. e8 C- I1 C8 F

{2 s! j& O$ w5 ^  h\\" i) O+ y/ U, o

pMatrix=new myMatrix;        //创建矩阵对象 
. f% x/ \' V# K- w3 W. T$ ^$ X
                if(!pMatrix) return NULL; 
1 J9 b1 i4 I; U$ R+ C- j0 H\\" i
                pMatrix->Array=new double[k];4 V* O! c4 `3 R' ^$ ?9 ?

if(!pMatrix->Array), K, x( W# |5 e, k1 x% _2 \

{2 n) K0 p% P4 q6 p- \  I

delete pMatrix;# W, C$ u+ s- _/ u1 e5 a

return NULL;3 V) {& q  s* M' X5 ^' `; y

} 
4 z$ u. u7 T# W, _. E1 w
                if(InsertKey((char *)&pMatrix,-1,Matrix,pMatrix,DelMatrix,NULL,0,NowKey))        //将矩阵对象注册到Lu 
\\" J# h4 P# I$ }9 V1 \
                { 
; b( p: r3 v) `5 G! W
                        delete pMatrix; 
6 A2 [9 m  K6 {
                        return NULL; 
9 J1 U. G) @) |5 n, }
                } 
. q( u% W: l\\" [+ n% y* b
        }% B# s- b/ v7 m! g

pMatrix->ArrayLen=k; pMatrix->Dim[0]=m; pMatrix->Dim[1]=n;, T* w% y3 u+ y  Q9 U5 X/ Y: I

return pMatrix;+ U7 d% \! w; P  V/ E2 ?

}6 R+ B\\" j) C0 f* h- g/ A1 U4 ?3 K: u

LuData _stdcall OpMatrix(luINT mm,LuData *xx,void *hFor,int theOperator)        //运算符重载函数，用于LockKey函数 
! e% E+ T5 b) p' Y9 i6 a
{ 
' }\\" n, n/ p; j1 l, m
        LuData a;$ l8 \9 Q9 r/ _, a2 f+ |

myMatrix *pMatrix1,*pMatrix2,*pMatrix3; 
1 `' X2 \0 u1 r% l5 G, s& ~0 a* U
        luVOID i,j,k,m,n,u,v;3 E9 w9 O5 S  f% [0 |

double *pa,*pb,*pc;\\" G, q: E0 Y: c- ]# c6 K& N4 a

luMessage pMessage;7 t0 b9 p. s3 M\\" e/ V

wchar_t wchNum[32]; 
% t( z. |\\" _& A4 Y9 j+ F, m
        char chNum[32];\\" x' J/ c9 |/ B

a.BType=luStaData_nil; a.VType=luStaData_nil; a.x=0;, M\\" a8 t. k; ?

switch(theOperator)) \; b; _' l1 m) K5 P  l

{  B4 p: `+ j6 p- Y5 k

case 2:        //重载运算符* 
\\" X6 S( r$ C- F! l
                pMatrix1=(myMatrix *)SearchKey((char *)&(xx->x),sizeof(luVOID),Matrix);* j\\" z  X+ I- x5 o5 o8 [

pMatrix2=(myMatrix *)SearchKey((char *)&((xx+1)->x),sizeof(luVOID),Matrix); 
8 P, @0 @\\" X# M7 ?2 I4 m
                if(!pMatrix1 || !pMatrix2) break;        //对象句柄无效，不是矩阵 
/ s/ z% ?# R3 i% X' T& _/ r
                if(pMatrix1->Dim[1]!=pMatrix2->Dim[0]) break;        //维数不匹配 
, z( |. h( I* R' Z2 q# Q* o8 n
                pMatrix3=NewMatrix(pMatrix1->Dim[0],pMatrix2->Dim[1]);        //生成新矩阵 
7 M/ D5 d$ V: k9 N4 O- y5 F' k1 P
                if(!pMatrix3) break;+ x) A/ X9 N6 P; q\\" m  {! H( F

pa=pMatrix1->Array; pb=pMatrix2->Array; pc=pMatrix3->Array;' d& C8 w3 h8 B) K

m=pMatrix1->Dim[0]; n=pMatrix1->Dim[1]; k=pMatrix2->Dim[1]; 
+ a! ?& m- v; w9 d/ c
                for(i=0; i<m; i++)        //矩阵乘 
, Y  C. L; \6 W& g
                { 
  w6 q* v7 |! I/ H: m
                        for(j=0; j<k; j++)! m4 {/ B1 u  j. B3 Q+ I

{$ k, \* A9 @! O. Z; f4 T

u=i*k+j; pc[u]=0.0;* t8 b6 G8 i  r' f( K0 c: |! d, i  W  T

for (v=0; v<n; v++): t. }7 t! S* e! U0 ~4 z

{7 e0 ]# [3 e; k( C# l& G2 e\\" {

pc[u]=pc[u]+pa[i*n+v]*pb[v*k+j];8 Y2 k% Y- `7 m0 f1 U

}; o/ ~2 q8 o5 X

} 
7 I2 R( N\\" Q0 w+ h2 ]; g8 l
                }! c4 Y9 c: G* `4 _, j  ]: K

FunReObj(hFor);        //告诉Lu，返回一个动态对象; v8 }6 _) S7 |

a.BType=Matrix; a.VType=Matrix; a.x=0; *(luVOID *)&(a.x)=(luVOID)pMatrix3; 
) K6 U4 _0 V5 H) M8 g
                break;# W+ o; |\\" Q: |- B* z9 f

case 25:        //重载运算符.* 
% U; }2 a. v, x. t( u% u
                pMatrix1=(myMatrix *)SearchKey((char *)&(xx->x),sizeof(luVOID),Matrix);) w4 _) _# d( a7 `& }' C$ p  y

pMatrix2=(myMatrix *)SearchKey((char *)&((xx+1)->x),sizeof(luVOID),Matrix); 
* \$ M\\" A# a2 Q* S$ e' M
                if(!pMatrix1 || !pMatrix2) break;        //对象句柄无效，不是矩阵 
0 R- z4 l$ i0 |- `( g
                if(pMatrix1->Dim[0]!=pMatrix2->Dim[0] || pMatrix1->Dim[1]!=pMatrix2->Dim[1]) break;        //维数不相同2 K\\" V- H  E/ ^/ i) |# j

pMatrix3=NewMatrix(pMatrix1->Dim[0],pMatrix1->Dim[1]);        //生成新矩阵 
6 l$ I2 Z  Q8 y
                if(!pMatrix3) break;7 o5 D: z1 U8 p# s7 d

for(i=0;i<pMatrix1->ArrayLen;i++) pMatrix3->Array[i]=pMatrix1->Array[i]*pMatrix2->Array[i];        //矩阵点乘 
, B: G3 {1 y# A9 J
                FunReObj(hFor);        //告诉Lu，返回一个动态对象6 V. |) O: T$ x; f6 k5 w& T' Y7 h3 Q

a.BType=Matrix; a.VType=Matrix; a.x=0; *(luVOID *)&(a.x)=(luVOID)pMatrix3; 
0 I- ]* K6 L$ A5 `% N\\" ?
                break; 
# u! a9 [! U$ F% ?9 N
        case 46:        //重载函数new 
1 a& y# Y. U\\" V1 V. Z, n  @
                if(mm<2) break; 
  W0 @' F/ a* O
                if((xx+1)->x<1 || (xx+2)->x<1 || (xx+1)->BType!=luStaData_int64 || (xx+2)->BType!=luStaData_int64) break; 
# B( f0 ?' Y7 K1 d
                pMatrix3=NewMatrix((luVOID)(xx+1)->x,(luVOID)(xx+2)->x);//生成新矩阵 
9 J# @& O. e1 q! `3 v
                if(!pMatrix3) break; 
  u1 i; X0 L7 ^8 y1 K/ A6 W% y
                for(j=0,i=3;i<=mm;i++,j++)        //赋初值9 V\\" [+ N8 A: Q/ Z3 n3 u

{ 
3 w\\" I! @4 D4 ~# F5 v1 F6 j5 \
                        if(j>=pMatrix3->ArrayLen) break; 
. [) ?+ p( M# S
                        if((xx+i)->BType!=luStaData_double) break;        //只接受实数参数 
2 `' |' @& `. P$ K) P
                        pMatrix3->Array[j]=*(double *)&((xx+i)->x);\\" K- l/ H7 I1 j4 v% X+ i

}( b1 t7 l% \1 [$ l

FunReObj(hFor);        //告诉Lu，返回一个动态对象4 E, O/ J2 @* b. d6 ]5 ^

a.BType=Matrix; a.VType=Matrix; a.x=0; *(luVOID *)&(a.x)=(luVOID)pMatrix3; 
- z; F' [; U( `+ X8 Z
                break; 
2 O/ S0 R/ E- Z) p; \6 x! M5 {6 S
        case 49:        //重载函数o\\" x6 y- @8 ?. x% b. H# v

pMessage=(luMessage)SearchKey("\0\0\0\0",sizeof(luVOID),luPubKey_User); 
2 V3 h8 T: U7 s6 |5 Z$ ~# S
                if(!pMessage) break; 
7 t\\" Z/ \; M5 ~1 n1 q
                pMatrix1=(myMatrix *)SearchKey((char *)&(xx->x),sizeof(luVOID),Matrix); 
) k  j/ q0 I2 t8 L4 s# W- y
                if(!pMatrix1) break;        //对象句柄无效，不是矩阵& X- g6 ]! F! J# r* ^3 I4 n

pa=pMatrix1->Array; 
2 L# \! G: _8 q2 Z  }3 @
                m=pMatrix1->Dim[0]; n=pMatrix1->Dim[1]; k=0; 
4 F$ M0 ^: C\\" w4 e( f
                for(i=0; i<m; i++)        //输出矩阵 
* K: t9 P\\" Q, t& l
                {5 p# u\\" ^* v$ S5 J8 ^

pMessage(L"\r\n"); k+=2; 
- t$ c& r3 p3 I
                        for(j=0; j<n; j++)2 b+ C$ k  s# J7 a8 }

{ 
. H3 b! q6 A& v+ O1 c* Z
                                _gcvt_s(chNum,pa[i*n+j],16); 
5 S+ O4 Z\\" N# i# V- e4 K  g7 i+ x
                                for(u=0;chNum[u];u++) {wchNum[u]=chNum[u]; k++;}. z3 s% [+ I, f

wchNum[u]='\0';; _- \\\" b2 f9 i\\" p

pMessage(wchNum); pMessage(L"  "); k+=2; 
- p- ?7 r) ?) G. y, v) E
                        } 
3 |, T% ]  X; ]; G0 i0 \$ j/ t
                } 
7 U- E5 X3 v* U4 {, K2 m' m. y! J& M
                pMessage(L"\r\n"); k+=2;, E- D0 j% z  d. `4 b, L

a.BType=luStaData_int64; a.VType=luStaData_int64; a.x=k;        //按函数o的要求，返回输出的字符总数 
, v8 a6 k: S: n4 q, m- Q/ {. \9 n
                break;7 r; I* x2 S0 N0 P) j% s

default: 
; K; y\\" ]2 M: [0 {' i% {
                break;+ Z\\" n9 q; d) h- i+ e  c5 J7 g7 a2 j9 T

} 
4 N1 f# B\\" c- S( ^* t3 |. G9 }
        return a; 
/ {0 n% f4 K. m2 J
}' ?\\" c4 x; @$ g' P. \* [

void main(void) 
4 @) }) c; Y! y/ s. q
{ 
! f! n; Q  D$ I$ S4 U+ l+ c
        void *hFor;                //表达式句柄 
$ w* M$ ?! C$ Y4 h* ]5 E
        luINT nPara;                //存放表达式的自变量个数 
+ A9 B% U8 w2 a9 U
        LuData *pPara;                //存放输入自变量的数组指针 
) T: y; A\\" Z, A9 F0 s& S
        luINT ErrBegin,ErrEnd;        //表达式编译出错的初始位置和结束位置; X6 V; M, F/ C2 e  A& t

int ErrCode;                //错误代码1 m7 E5 _9 {& L

void *v;/ K5 `& \6 ^9 I+ i* Y; _  C7 A

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.]}";//字符串表达式，矩阵乘 
- F1 q& ]$ @% z- |+ F. 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.]}";//字符串表达式，矩阵点乘 
0 q3 W+ _( Q- j. I$ l' C
        LuData Val;2 {- O& J, W: f2 F: V2 ^/ u

if(!InitLu()) return;        //初始化Lu. s9 h/ O5 C& j8 w& n\\" R7 |7 D

while(LockKey(Matrix,DelMatrix,OpMatrix)){Matrix--;}        //锁定一个键，用于存储矩阵扩展类型0 `/ p  ^& N5 f/ F* c9 m7 q

% d4 n$ I4 V; H1 r
        Val.BType=luStaData_int64; Val.VType=luStaData_int64; Val.x=Matrix;        //定义整数常量4 T2 }5 A9 j% g

SetConst(L"matrix",&Val);        //设置整数常量 
! ~# ^. l* o$ u( ~
        InsertKey("\0\0\0\0",4,luPubKey_User,LuMessage,NULL,NULL,1,v); //使Lu运行时可输出函数信息, P1 _\\" U% g4 x5 y: L% S) [8 q

wcout.imbue(locale("chs"));        //设置输出的locale为中文. c0 I% @  ?+ w! ~1 {% b! y5 @

, N& C* r9 |* }* k& P! c* q+ }- a

ErrCode=LuCom(ForStr,0,0,0,hFor,nPara,pPara,ErrBegin,ErrEnd); //编译表达式7 D1 ^\\" f0 w6 p  I

if(ErrCode)4 Z# u) h! _! B3 k8 l4 A

{ 
% d4 n4 G  F& l4 l
                wcout<<L"表达式有错误！错误代码："<<ErrCode<<endl;/ `4 d\\" B7 v! l7 ]# A. J& M1 f

} 
( d7 f3 D  v0 d/ V0 @' I
        else# l2 j' s% W1 v: a( L3 t2 W

{8 W$ b/ ~1 I; }2 n$ d

LuCal(hFor,pPara);        //计算表达式的值8 H. n9 E) X4 u  G; M& W

} 
* r: K& M4 Y, p, ?
        LockKey(Matrix,NULL,OpMatrix);//解锁键Matrix，本例中，该函数可以不用! B3 _0 R1 C0 Q/ k

FreeLu();                        //释放Lu 
* k( x, s+ A$ P; H8 o
}

习题：

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

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

main(:a,b,c,d,t,i)=2 ~3 T+ c7 F1 N
a=new[matrix,2,2: 1.,2.,2.,1.],/ |$ ]& q% f( P q$ W
b=new[matrix,2,2: 2.,1.,1.,2.],
/ ^7 K! J0 l3 Y5 ]
c=new[matrix,2,2: 2/3.,-1/3.,-1/3.,2/3.],
* a. ~# _7 v, y$ v
t=clock(),# f4 M- _* j) I8 o9 K& Q
d=a*b, i=0, while{i<1000000, d=d*c*b, i++},
% V4 g( {! D$ D
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\"}";//字符串表达式

复制代码

结果：