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

查看: 7778|回复: 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>
9 I( Y/ o\\" ?2 {: M
#include <iostream>) b2 g5 Z4 Q/ ]. N; ]
#include <math.h>/ S\\" `; |' a5 V7 c
#include "lu32.h"
% h) n) @# T/ s# w
#pragma comment( lib, "lu32.lib" )+ W9 e0 {& r& A7 H
using namespace std;' ^) Q( U) l) W O5 ]; Y2 O/ F; {
//自定义矩阵, [1 G7 ^* g) h- F2 F9 W2 X
class myMatrix. Q& E/ q4 n! l3 T7 D/ c! d
{
* ?1 ~0 s; X* E l8 z
public:
- Z3 A, ~8 n4 O& K% L: R/ o. f; N
double *Array; //数据缓冲区
, U8 r. F% f8 ]
luVOID ArrayLen; //数据缓冲区长度 u) A) _- P1 S# h0 h
luVOID Dim[2]; //矩阵维数# R8 {: u A) s& D S/ V
myMatrix(){Array=NULL; ArrayLen=0; Dim[0]=0; Dim[1]=0;}
' G6 J& O! c* `# g% y
~myMatrix()' l7 ^0 t; g& \- L( k\\" x6 Y* J5 B
{7 w6 O8 D5 S( U3 e2 i( ~
if(Array) delete[] Array;
# G\\" x# F1 e\\" F) J. @8 @9 N
}
# W3 j& [* y& T$ T G5 E7 o6 ^
};
+ o. [8 j( E% a5 {% K
luKEY Matrix=-1000; //标识矩阵类型，最终的Matrix由LockKey决定
\\" i K7 {( Y8 P- }; r( u# A
void _stdcall LuMessage(wchar_t *pch)//输出动态库信息，该函数注册到Lu，由Lu二级函数调用
3 d6 \7 T0 b5 R) u: _ z
{9 c* Y3 k. W j3 z6 L! m
wcout<<pch;- _4 ?& i# w2 c6 D( s\\" x
}
3 c ~! ^: f4 N# y0 H. v. o/ j
void _stdcall DelMatrix(void *me) //用于LockKey函数及InsertKey函数，使Lu能自动销毁myMatrix对象
- L7 c4 n b [$ u* i
{
: X( e4 f1 d0 X7 D3 |+ w' o5 c
delete (myMatrix *)me;2 q& Z- B2 U1 L( f Q; c
}
7 u. V4 Q' L# n+ K% u( U C
myMatrix * _stdcall NewMatrix(luVOID m,luVOID n) //生成一个myMatrix对象
- c: f, ]8 `6 V# }0 q
{5 m$ Q' s8 h- Y }( N$ c
myMatrix *pMatrix;
7 k& I. f( C- ], @
luVOID k;' ?9 H- M7 Z; X/ _7 P5 f. ?
double *pa;1 _) t$ U5 w* ~\\" r2 Q' W
char keyname[sizeof(luVOID)];4 H- V6 p; Z: p$ Y! W+ r
void *NowKey;
% P) X1 g9 L) [& a
k=m*n;
5 L4 ?7 n: ^, |4 P3 F! k; \\\" Q% f
pMatrix=(myMatrix *)GetBufObj(Matrix,keyname);//先尝试从缓冲区中获取一个矩阵对象
% K$ M7 G ]/ q0 O, s
if(pMatrix)
$ j5 d0 v* P) B8 F% R- }
{
$ b. ?! V7 t0 |. S+ W
if(pMatrix->ArrayLen!=k) //重置矩阵的大小
/ W4 n1 C6 B, C
{
1 S$ X$ h1 C' ^6 B
pa=new double[k];; U0 t. {+ O; f( N
if(!pa)
3 ^% ]8 G4 `4 ]
{1 K1 H7 Z2 J, \) l% U7 Z ~
DeleteKey(keyname,sizeof(luVOID),Matrix,DelMatrix,1); //将矩阵对象放回缓冲区. L+ x3 o1 J' t# x9 V4 I
return NULL;
. a' a5 e) I' l- i) ~- C; S
}
, G2 a& E& S# w/ F$ T4 ?5 f
delete[] pMatrix->Array;! V\\" R/ J2 _6 g2 u
pMatrix->Array=pa;
1 ~' h1 T z( {4 ]# t! a' ^4 P
}
3 g( R% @6 v% @( x
}8 L+ u* G; s) f! z
else- s1 V5 ~ c' c8 k
{
, u* N+ W4 J8 J: w' h8 F
pMatrix=new myMatrix; //创建矩阵对象# ~$ w- }: \( A0 C' e
if(!pMatrix) return NULL;
) t1 N\\" X* N: Y3 F% ^8 C2 {
pMatrix->Array=new double[k];
) ]8 g7 G; ?- } J* S9 j' Y
if(!pMatrix->Array)6 Q- F7 l* A; y* o( W$ f) f
{9 c5 R7 _& c5 R& @. h2 A
delete pMatrix;
5 ~/ X% U2 p' z8 M6 x
return NULL;
@+ W7 E/ O& N; t) q
}
+ d2 o\\" u. }) A8 o
if(InsertKey((char *)&pMatrix,-1,Matrix,pMatrix,DelMatrix,NULL,0,NowKey)) //将矩阵对象注册到Lu
$ k: d6 a$ Q9 L& W2 ]2 V
{- U- g# B0 z0 f: H
delete pMatrix;
( h: q! U( ]4 K9 g; g; B
return NULL;9 y6 V) K, z# @, z: I! {
}& e q7 m1 u+ ^& j3 k4 d% k+ v
}
\\" h2 q% n8 \& Q1 B0 E
pMatrix->ArrayLen=k; pMatrix->Dim[0]=m; pMatrix->Dim[1]=n;$ g, X+ P9 ?% q0 G9 G9 S
return pMatrix; |! |1 I* N\\" z3 v9 Q; Q9 l/ J) u9 {
}, j- G# P% [0 }% j
LuData _stdcall OpMatrix(luINT mm,LuData *xx,void *hFor,int theOperator) //运算符重载函数，用于LockKey函数
( ]! b+ V3 V\\" v6 q/ `' V+ Y
{
8 A/ t7 I9 l ^2 I$ {+ l7 j/ k
LuData a;
5 y8 ]9 d# T0 K) u
myMatrix *pMatrix1,*pMatrix2,*pMatrix3;
# {\\" D2 c0 B. e/ w2 w. ~1 m, C
luVOID i,j,k,m,n,u,v;* `7 ], ^5 D\\" y3 {7 N9 I/ N
double *pa,*pb,*pc;9 {4 }7 ]$ F7 ^2 ?5 a; [+ g9 ?
luMessage pMessage;
: v E# W5 h3 f* K1 F3 G
wchar_t wchNum[32];
9 R- }$ C2 N- \+ v
char chNum[32];1 V/ Y' q\\" J7 m8 A
a.BType=luStaData_nil; a.VType=luStaData_nil; a.x=0;/ l' z0 `7 g+ v8 |3 s4 E! ]& w
switch(theOperator)1 O9 ]9 G5 \4 t7 j& A4 X\\" ]$ c
{
5 [1 U7 J- m( X3 P3 r, E
case 2: //重载运算符*4 I; f8 K& F+ ~/ ^\\" ^4 M
pMatrix1=(myMatrix *)SearchKey((char *)&(xx->x),sizeof(luVOID),Matrix);
2 F) X& e9 b5 e4 x& M
pMatrix2=(myMatrix *)SearchKey((char *)&((xx+1)->x),sizeof(luVOID),Matrix);
1 W( Q4 T! _2 g
if(!pMatrix1 || !pMatrix2) break; //对象句柄无效，不是矩阵
% u( w0 P3 f6 F; m+ m7 @7 I$ F
if(pMatrix1->Dim[1]!=pMatrix2->Dim[0]) break; //维数不匹配
3 }2 f\\" X D- P1 S2 T8 l3 F, F
pMatrix3=NewMatrix(pMatrix1->Dim[0],pMatrix2->Dim[1]); //生成新矩阵6 y* A( b8 ]1 E( d0 p
if(!pMatrix3) break;9 C4 [8 t# k) [
pa=pMatrix1->Array; pb=pMatrix2->Array; pc=pMatrix3->Array;
9 ~) P, q9 \) t/ p& A4 n1 f+ b$ v
m=pMatrix1->Dim[0]; n=pMatrix1->Dim[1]; k=pMatrix2->Dim[1];\\" M. C: K+ ]. y m& j
for(i=0; i<m; i++) //矩阵乘- L/ P- q# d0 ?% j9 w
{
* C6 j& [2 d/ G: D9 e
for(j=0; j<k; j++)
0 x6 X6 p# L8 Z8 Z8 Q
{7 Q& b! S1 p) F( u\\" @! G: l2 e
u=i*k+j; pc[u]=0.0;+ D, l! S/ q5 C+ y a
for (v=0; v<n; v++)
* ^# B% z0 X/ X
{0 d; I9 Y: p4 R( `1 @) _8 W
pc[u]=pc[u]+pa[i*n+v]*pb[v*k+j];/ F* x8 i( G. s x0 @2 p; G
}# f. Z, i3 N5 n5 t. l- H# w y
}4 w) @8 f- {8 S, Q
}! t5 O$ ^% `$ U
FunReObj(hFor); //告诉Lu，返回一个动态对象
s% l c0 O) [3 \0 H% a
a.BType=Matrix; a.VType=Matrix; a.x=0; *(luVOID *)&(a.x)=(luVOID)pMatrix3;* |9 o6 M5 t/ L# L7 _$ [ A
break;+ x1 @* ^- L4 o* e7 w: J( h3 U
case 25: //重载运算符.*\\" M7 q& U\\" @, U9 b. ?
pMatrix1=(myMatrix *)SearchKey((char *)&(xx->x),sizeof(luVOID),Matrix);
/ M4 H\\" r7 J4 a) }# C
pMatrix2=(myMatrix *)SearchKey((char *)&((xx+1)->x),sizeof(luVOID),Matrix);3 N4 c$ F' s, K, k/ D+ Z
if(!pMatrix1 || !pMatrix2) break; //对象句柄无效，不是矩阵9 N& ]4 j\\" c; c+ K& z! C# ~! \
if(pMatrix1->Dim[0]!=pMatrix2->Dim[0] || pMatrix1->Dim[1]!=pMatrix2->Dim[1]) break; //维数不相同3 T% {4 I6 p$ n
pMatrix3=NewMatrix(pMatrix1->Dim[0],pMatrix1->Dim[1]); //生成新矩阵
8 t& u4 d: r( \9 a- y4 t* ]\\" j! `
if(!pMatrix3) break;
. d \4 X+ S3 ]4 g
for(i=0;i<pMatrix1->ArrayLen;i++) pMatrix3->Array[i]=pMatrix1->Array[i]*pMatrix2->Array[i]; //矩阵点乘
8 ?( q% ^: C( l
FunReObj(hFor); //告诉Lu，返回一个动态对象' H% n0 W+ s, ? \: s5 z. K8 {
a.BType=Matrix; a.VType=Matrix; a.x=0; *(luVOID *)&(a.x)=(luVOID)pMatrix3;0 R$ _. D: _2 x( [
break;+ Q$ T- _- x& C
case 46: //重载函数new
9 P4 G/ |( N8 D
if(mm<2) break;
6 c. T3 C7 w P& `+ W1 \
if((xx+1)->x<1 || (xx+2)->x<1 || (xx+1)->BType!=luStaData_int64 || (xx+2)->BType!=luStaData_int64) break;
\\" x2 v+ ?) X& T7 V
pMatrix3=NewMatrix((luVOID)(xx+1)->x,(luVOID)(xx+2)->x);//生成新矩阵
1 i\\" W1 F$ N8 y9 X* H- y& y1 L
if(!pMatrix3) break;& ]' Y& d! {) j6 g2 n' R2 Z
for(j=0,i=3;i<=mm;i++,j++) //赋初值# O- N* _$ w- w) h9 b\\" P\\" @' c+ V
{2 s& V1 b$ {& g+ q4 E! ?
if(j>=pMatrix3->ArrayLen) break;
( P5 ?0 |& S/ p, r
if((xx+i)->BType!=luStaData_double) break; //只接受实数参数# t' G% [) D8 ~ ?7 ~5 o' V4 p
pMatrix3->Array[j]=*(double *)&((xx+i)->x);8 Y8 X$ }( P) e7 n! M% e
}
1 S% r; U6 Z+ m. a5 W+ T3 f
FunReObj(hFor); //告诉Lu，返回一个动态对象
: S( _ P& j: Q' R% N* D
a.BType=Matrix; a.VType=Matrix; a.x=0; *(luVOID *)&(a.x)=(luVOID)pMatrix3;% A; s. z1 Y% Y7 w5 @7 ]: c \
break;
( |! p6 S' W5 Q
case 49: //重载函数o- z5 t6 H r& j
pMessage=(luMessage)SearchKey("\0\0\0\0",sizeof(luVOID),luPubKey_User);# P# O! |; E\\" \! I% O$ G I
if(!pMessage) break;
4 O; M1 V9 B$ G F6 m9 d4 C. f
pMatrix1=(myMatrix *)SearchKey((char *)&(xx->x),sizeof(luVOID),Matrix);
7 V+ P) H. z: t1 {( a
if(!pMatrix1) break; //对象句柄无效，不是矩阵4 U% ^7 h, N w% o9 | V
pa=pMatrix1->Array;% X4 {: n' t: v
m=pMatrix1->Dim[0]; n=pMatrix1->Dim[1]; k=0;
8 e& U' m- P+ y6 ~3 ] E\\" J, W( N
for(i=0; i<m; i++) //输出矩阵
- P' Z5 c# y9 m6 Y/ C2 U) z# @
{
3 O$ a _1 A. T7 a- S# e4 J8 W
pMessage(L"\r\n"); k+=2;
0 |4 f1 N6 u9 l4 F& N8 y
for(j=0; j<n; j++)
# {4 r, b+ ?# k0 l! {) Y
{% e\\" P% X/ | S/ \3 v. c' d/ z
_gcvt_s(chNum,pa[i*n+j],16);
1 T# }\\" {7 h3 M @
for(u=0;chNum[u];u++) {wchNum[u]=chNum[u]; k++;}
8 I5 M& C8 O! i N( S/ ?7 t
wchNum[u]='\0';! l( \6 |$ k. ^: K
pMessage(wchNum); pMessage(L" "); k+=2;! J' d; U4 G% o
}; y\\" @8 T4 [! q7 R: u! F
}1 j5 s$ D2 u$ P: z* m
pMessage(L"\r\n"); k+=2;
, u' x5 o1 S3 \2 Y2 F; N\\" ?7 _' C
a.BType=luStaData_int64; a.VType=luStaData_int64; a.x=k; //按函数o的要求，返回输出的字符总数0 c, `; z2 S% J7 ^# G
break;
8 c- u0 l5 o r. d\\" S, G' l! B
default:
4 b( I# e\\" @2 Y9 r
break;
5 ]' Q\\" G' P: m5 G* R y9 Z
}5 T7 F: K! v0 v7 n' [& Z- M4 \
return a;
3 u5 Z q( Y% M; c1 P
}
8 Q' A. c\\" H: U! V% H1 J1 c1 ~' Y+ Z
void main(void)3 p8 C& {1 D; v: f4 ~
{, ]) y' X. e/ q9 l0 e
void *hFor; //表达式句柄
) o5 o* i- Q, R |; Z* J6 y
luINT nPara; //存放表达式的自变量个数
' H' X' F8 o; x! ^ L\\" ?$ L
LuData *pPara; //存放输入自变量的数组指针
! g* p, \5 N6 m
luINT ErrBegin,ErrEnd; //表达式编译出错的初始位置和结束位置: @! M+ O- O6 S3 o( Q6 T
int ErrCode; //错误代码
) f- S# C, {3 ]% k A& o
void *v;4 C\\" }$ h) a3 P- m! c$ g
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.]}";//字符串表达式，矩阵乘! [+ B\\" s: _- B\\" Q( n+ K! ]\\" r
//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.]}";//字符串表达式，矩阵点乘
LuData Val;- x: \' F# _. q- g9 b- q
if(!InitLu()) return; //初始化Lu\\" B( f/ C8 W: H8 {/ y' n8 W
while(LockKey(Matrix,DelMatrix,OpMatrix)){Matrix--;} //锁定一个键，用于存储矩阵扩展类型
2 S& p+ q3 u O
( E: v\\" U/ L4 y* x
Val.BType=luStaData_int64; Val.VType=luStaData_int64; Val.x=Matrix; //定义整数常量
0 \% R l, v: ?/ h, A( D
SetConst(L"matrix",&Val); //设置整数常量- ?; _# T+ `( V2 \) x. l: t- g b
InsertKey("\0\0\0\0",4,luPubKey_User,LuMessage,NULL,NULL,1,v); //使Lu运行时可输出函数信息
% I- C1 ^5 y0 ]; v/ B+ e2 o
wcout.imbue(locale("chs")); //设置输出的locale为中文
: i4 H5 k# x# F3 u- |8 h
: Q7 F( |- [1 q\\" I8 R9 `
ErrCode=LuCom(ForStr,0,0,0,hFor,nPara,pPara,ErrBegin,ErrEnd); //编译表达式
7 j( x ^8 J# w$ T- {' Q0 v
if(ErrCode)8 s$ X$ }& [8 ?7 c7 q- n7 P
{& U9 b! `' x& R9 n! F
wcout<<L"表达式有错误！错误代码："<<ErrCode<<endl;- c# L) m+ Y9 e5 Y
}
% }0 O# N. D6 {. S7 v. w3 |. d e
else
* T+ s- t' K. y7 Y% V; V
{' b5 \) }2 a$ [2 y* h
LuCal(hFor,pPara); //计算表达式的值4 {! S2 z/ t) ^7 x
}
1 e! a( `* A: t v. s5 T
LockKey(Matrix,NULL,OpMatrix);//解锁键Matrix，本例中，该函数可以不用* X9 X/ z$ b0 i
FreeLu(); //释放Lu
2 ^! l/ [6 I+ U# x( Q: h
}

#include <windows.h> 
9 I( Y/ o\\" ?2 {: M
#include <iostream>) b2 g5 Z4 Q/ ]. N; ]

#include <math.h>/ S\\" `; |' a5 V7 c

#include "lu32.h" 
% h) n) @# T/ s# w
#pragma comment( lib, "lu32.lib" )+ W9 e0 {& r& A7 H

using namespace std;' ^) Q( U) l) W  O5 ]; Y2 O/ F; {

//自定义矩阵, [1 G7 ^* g) h- F2 F9 W2 X

class myMatrix. Q& E/ q4 n! l3 T7 D/ c! d

{ 
* ?1 ~0 s; X* E  l8 z
public: 
- Z3 A, ~8 n4 O& K% L: R/ o. f; N
        double *Array;        //数据缓冲区 
, U8 r. F% f8 ]
        luVOID ArrayLen;        //数据缓冲区长度  u) A) _- P1 S# h0 h

luVOID Dim[2];        //矩阵维数# R8 {: u  A) s& D  S/ V

myMatrix(){Array=NULL; ArrayLen=0; Dim[0]=0; Dim[1]=0;} 
' G6 J& O! c* `# g% y
        ~myMatrix()' l7 ^0 t; g& \- L( k\\" x6 Y* J5 B

{7 w6 O8 D5 S( U3 e2 i( ~

if(Array) delete[] Array; 
# G\\" x# F1 e\\" F) J. @8 @9 N
        } 
# W3 j& [* y& T$ T  G5 E7 o6 ^
}; 
+ o. [8 j( E% a5 {% K
luKEY Matrix=-1000;        //标识矩阵类型，最终的Matrix由LockKey决定 
\\" i  K7 {( Y8 P- }; r( u# A
void _stdcall LuMessage(wchar_t *pch)//输出动态库信息，该函数注册到Lu，由Lu二级函数调用 
3 d6 \7 T0 b5 R) u: _  z
{9 c* Y3 k. W  j3 z6 L! m

wcout<<pch;- _4 ?& i# w2 c6 D( s\\" x

} 
3 c  ~! ^: f4 N# y0 H. v. o/ j
void _stdcall DelMatrix(void *me)        //用于LockKey函数及InsertKey函数，使Lu能自动销毁myMatrix对象 
- L7 c4 n  b  [$ u* i
{ 
: X( e4 f1 d0 X7 D3 |+ w' o5 c
        delete (myMatrix *)me;2 q& Z- B2 U1 L( f  Q; c

} 
7 u. V4 Q' L# n+ K% u( U  C
myMatrix * _stdcall NewMatrix(luVOID m,luVOID n)        //生成一个myMatrix对象 
- c: f, ]8 `6 V# }0 q
{5 m$ Q' s8 h- Y  }( N$ c

myMatrix *pMatrix; 
7 k& I. f( C- ], @
        luVOID k;' ?9 H- M7 Z; X/ _7 P5 f. ?

double *pa;1 _) t$ U5 w* ~\\" r2 Q' W

char keyname[sizeof(luVOID)];4 H- V6 p; Z: p$ Y! W+ r

void *NowKey; 
% P) X1 g9 L) [& a
        k=m*n; 
5 L4 ?7 n: ^, |4 P3 F! k; \\\" Q% f
        pMatrix=(myMatrix *)GetBufObj(Matrix,keyname);//先尝试从缓冲区中获取一个矩阵对象 
% K$ M7 G  ]/ q0 O, s
        if(pMatrix) 
$ j5 d0 v* P) B8 F% R- }
        { 
$ b. ?! V7 t0 |. S+ W
                if(pMatrix->ArrayLen!=k)        //重置矩阵的大小 
/ W4 n1 C6 B, C
                { 
1 S$ X$ h1 C' ^6 B
                        pa=new double[k];; U0 t. {+ O; f( N

if(!pa) 
3 ^% ]8 G4 `4 ]
                        {1 K1 H7 Z2 J, \) l% U7 Z  ~

DeleteKey(keyname,sizeof(luVOID),Matrix,DelMatrix,1);        //将矩阵对象放回缓冲区. L+ x3 o1 J' t# x9 V4 I

return NULL; 
. a' a5 e) I' l- i) ~- C; S
                        } 
, G2 a& E& S# w/ F$ T4 ?5 f
                        delete[] pMatrix->Array;! V\\" R/ J2 _6 g2 u

pMatrix->Array=pa; 
1 ~' h1 T  z( {4 ]# t! a' ^4 P
                } 
3 g( R% @6 v% @( x
        }8 L+ u* G; s) f! z

else- s1 V5 ~  c' c8 k

{ 
, u* N+ W4 J8 J: w' h8 F
                pMatrix=new myMatrix;        //创建矩阵对象# ~$ w- }: \( A0 C' e

if(!pMatrix) return NULL; 
) t1 N\\" X* N: Y3 F% ^8 C2 {
                pMatrix->Array=new double[k]; 
) ]8 g7 G; ?- }  J* S9 j' Y
                if(!pMatrix->Array)6 Q- F7 l* A; y* o( W$ f) f

{9 c5 R7 _& c5 R& @. h2 A

delete pMatrix; 
5 ~/ X% U2 p' z8 M6 x
                        return NULL; 
  @+ W7 E/ O& N; t) q
                } 
+ d2 o\\" u. }) A8 o
                if(InsertKey((char *)&pMatrix,-1,Matrix,pMatrix,DelMatrix,NULL,0,NowKey))        //将矩阵对象注册到Lu 
$ k: d6 a$ Q9 L& W2 ]2 V
                {- U- g# B0 z0 f: H

delete pMatrix; 
( h: q! U( ]4 K9 g; g; B
                        return NULL;9 y6 V) K, z# @, z: I! {

}& e  q7 m1 u+ ^& j3 k4 d% k+ v

} 
\\" h2 q% n8 \& Q1 B0 E
        pMatrix->ArrayLen=k; pMatrix->Dim[0]=m; pMatrix->Dim[1]=n;$ g, X+ P9 ?% q0 G9 G9 S

return pMatrix;  |! |1 I* N\\" z3 v9 Q; Q9 l/ J) u9 {

}, j- G# P% [0 }% j

LuData _stdcall OpMatrix(luINT mm,LuData *xx,void *hFor,int theOperator)        //运算符重载函数，用于LockKey函数 
( ]! b+ V3 V\\" v6 q/ `' V+ Y
{ 
8 A/ t7 I9 l  ^2 I$ {+ l7 j/ k
        LuData a; 
5 y8 ]9 d# T0 K) u
        myMatrix *pMatrix1,*pMatrix2,*pMatrix3; 
# {\\" D2 c0 B. e/ w2 w. ~1 m, C
        luVOID i,j,k,m,n,u,v;* `7 ], ^5 D\\" y3 {7 N9 I/ N

double *pa,*pb,*pc;9 {4 }7 ]$ F7 ^2 ?5 a; [+ g9 ?

luMessage pMessage; 
: v  E# W5 h3 f* K1 F3 G
        wchar_t wchNum[32]; 
9 R- }$ C2 N- \+ v
        char chNum[32];1 V/ Y' q\\" J7 m8 A

a.BType=luStaData_nil; a.VType=luStaData_nil; a.x=0;/ l' z0 `7 g+ v8 |3 s4 E! ]& w

switch(theOperator)1 O9 ]9 G5 \4 t7 j& A4 X\\" ]$ c

{ 
5 [1 U7 J- m( X3 P3 r, E
        case 2:        //重载运算符*4 I; f8 K& F+ ~/ ^\\" ^4 M

pMatrix1=(myMatrix *)SearchKey((char *)&(xx->x),sizeof(luVOID),Matrix); 
2 F) X& e9 b5 e4 x& M
                pMatrix2=(myMatrix *)SearchKey((char *)&((xx+1)->x),sizeof(luVOID),Matrix); 
1 W( Q4 T! _2 g
                if(!pMatrix1 || !pMatrix2) break;        //对象句柄无效，不是矩阵 
% u( w0 P3 f6 F; m+ m7 @7 I$ F
                if(pMatrix1->Dim[1]!=pMatrix2->Dim[0]) break;        //维数不匹配 
3 }2 f\\" X  D- P1 S2 T8 l3 F, F
                pMatrix3=NewMatrix(pMatrix1->Dim[0],pMatrix2->Dim[1]);        //生成新矩阵6 y* A( b8 ]1 E( d0 p

if(!pMatrix3) break;9 C4 [8 t# k) [

pa=pMatrix1->Array; pb=pMatrix2->Array; pc=pMatrix3->Array; 
9 ~) P, q9 \) t/ p& A4 n1 f+ b$ v
                m=pMatrix1->Dim[0]; n=pMatrix1->Dim[1]; k=pMatrix2->Dim[1];\\" M. C: K+ ]. y  m& j

for(i=0; i<m; i++)        //矩阵乘- L/ P- q# d0 ?% j9 w

{ 
* C6 j& [2 d/ G: D9 e
                        for(j=0; j<k; j++) 
0 x6 X6 p# L8 Z8 Z8 Q
                        {7 Q& b! S1 p) F( u\\" @! G: l2 e

u=i*k+j; pc[u]=0.0;+ D, l! S/ q5 C+ y  a

for (v=0; v<n; v++) 
* ^# B% z0 X/ X
                                {0 d; I9 Y: p4 R( `1 @) _8 W

pc[u]=pc[u]+pa[i*n+v]*pb[v*k+j];/ F* x8 i( G. s  x0 @2 p; G

}# f. Z, i3 N5 n5 t. l- H# w  y

}4 w) @8 f- {8 S, Q

}! t5 O$ ^% `$ U

FunReObj(hFor);        //告诉Lu，返回一个动态对象 
  s% l  c0 O) [3 \0 H% a
                a.BType=Matrix; a.VType=Matrix; a.x=0; *(luVOID *)&(a.x)=(luVOID)pMatrix3;* |9 o6 M5 t/ L# L7 _$ [  A

break;+ x1 @* ^- L4 o* e7 w: J( h3 U

case 25:        //重载运算符.*\\" M7 q& U\\" @, U9 b. ?

pMatrix1=(myMatrix *)SearchKey((char *)&(xx->x),sizeof(luVOID),Matrix); 
/ M4 H\\" r7 J4 a) }# C
                pMatrix2=(myMatrix *)SearchKey((char *)&((xx+1)->x),sizeof(luVOID),Matrix);3 N4 c$ F' s, K, k/ D+ Z

if(!pMatrix1 || !pMatrix2) break;        //对象句柄无效，不是矩阵9 N& ]4 j\\" c; c+ K& z! C# ~! \

if(pMatrix1->Dim[0]!=pMatrix2->Dim[0] || pMatrix1->Dim[1]!=pMatrix2->Dim[1]) break;        //维数不相同3 T% {4 I6 p$ n

pMatrix3=NewMatrix(pMatrix1->Dim[0],pMatrix1->Dim[1]);        //生成新矩阵 
8 t& u4 d: r( \9 a- y4 t* ]\\" j! `
                if(!pMatrix3) break; 
. d  \4 X+ S3 ]4 g
                for(i=0;i<pMatrix1->ArrayLen;i++) pMatrix3->Array[i]=pMatrix1->Array[i]*pMatrix2->Array[i];        //矩阵点乘 
8 ?( q% ^: C( l
                FunReObj(hFor);        //告诉Lu，返回一个动态对象' H% n0 W+ s, ?  \: s5 z. K8 {

a.BType=Matrix; a.VType=Matrix; a.x=0; *(luVOID *)&(a.x)=(luVOID)pMatrix3;0 R$ _. D: _2 x( [

break;+ Q$ T- _- x& C

case 46:        //重载函数new 
9 P4 G/ |( N8 D
                if(mm<2) break; 
6 c. T3 C7 w  P& `+ W1 \
                if((xx+1)->x<1 || (xx+2)->x<1 || (xx+1)->BType!=luStaData_int64 || (xx+2)->BType!=luStaData_int64) break; 
\\" x2 v+ ?) X& T7 V
                pMatrix3=NewMatrix((luVOID)(xx+1)->x,(luVOID)(xx+2)->x);//生成新矩阵 
1 i\\" W1 F$ N8 y9 X* H- y& y1 L
                if(!pMatrix3) break;& ]' Y& d! {) j6 g2 n' R2 Z

for(j=0,i=3;i<=mm;i++,j++)        //赋初值# O- N* _$ w- w) h9 b\\" P\\" @' c+ V

{2 s& V1 b$ {& g+ q4 E! ?

if(j>=pMatrix3->ArrayLen) break; 
( P5 ?0 |& S/ p, r
                        if((xx+i)->BType!=luStaData_double) break;        //只接受实数参数# t' G% [) D8 ~  ?7 ~5 o' V4 p

pMatrix3->Array[j]=*(double *)&((xx+i)->x);8 Y8 X$ }( P) e7 n! M% e

} 
1 S% r; U6 Z+ m. a5 W+ T3 f
                FunReObj(hFor);        //告诉Lu，返回一个动态对象 
: S( _  P& j: Q' R% N* D
                a.BType=Matrix; a.VType=Matrix; a.x=0; *(luVOID *)&(a.x)=(luVOID)pMatrix3;% A; s. z1 Y% Y7 w5 @7 ]: c  \

break; 
( |! p6 S' W5 Q
        case 49:        //重载函数o- z5 t6 H  r& j

pMessage=(luMessage)SearchKey("\0\0\0\0",sizeof(luVOID),luPubKey_User);# P# O! |; E\\" \! I% O$ G  I

if(!pMessage) break; 
4 O; M1 V9 B$ G  F6 m9 d4 C. f
                pMatrix1=(myMatrix *)SearchKey((char *)&(xx->x),sizeof(luVOID),Matrix); 
7 V+ P) H. z: t1 {( a
                if(!pMatrix1) break;        //对象句柄无效，不是矩阵4 U% ^7 h, N  w% o9 |  V

pa=pMatrix1->Array;% X4 {: n' t: v

m=pMatrix1->Dim[0]; n=pMatrix1->Dim[1]; k=0; 
8 e& U' m- P+ y6 ~3 ]  E\\" J, W( N
                for(i=0; i<m; i++)        //输出矩阵 
- P' Z5 c# y9 m6 Y/ C2 U) z# @
                { 
3 O$ a  _1 A. T7 a- S# e4 J8 W
                        pMessage(L"\r\n"); k+=2; 
0 |4 f1 N6 u9 l4 F& N8 y
                        for(j=0; j<n; j++) 
# {4 r, b+ ?# k0 l! {) Y
                        {% e\\" P% X/ |  S/ \3 v. c' d/ z

_gcvt_s(chNum,pa[i*n+j],16); 
1 T# }\\" {7 h3 M  @
                                for(u=0;chNum[u];u++) {wchNum[u]=chNum[u]; k++;} 
8 I5 M& C8 O! i  N( S/ ?7 t
                                wchNum[u]='\0';! l( \6 |$ k. ^: K

pMessage(wchNum); pMessage(L"  "); k+=2;! J' d; U4 G% o

}; y\\" @8 T4 [! q7 R: u! F

}1 j5 s$ D2 u$ P: z* m

pMessage(L"\r\n"); k+=2; 
, u' x5 o1 S3 \2 Y2 F; N\\" ?7 _' C
                a.BType=luStaData_int64; a.VType=luStaData_int64; a.x=k;        //按函数o的要求，返回输出的字符总数0 c, `; z2 S% J7 ^# G

break; 
8 c- u0 l5 o  r. d\\" S, G' l! B
        default: 
4 b( I# e\\" @2 Y9 r
                break; 
5 ]' Q\\" G' P: m5 G* R  y9 Z
        }5 T7 F: K! v0 v7 n' [& Z- M4 \

return a; 
3 u5 Z  q( Y% M; c1 P
} 
8 Q' A. c\\" H: U! V% H1 J1 c1 ~' Y+ Z
void main(void)3 p8 C& {1 D; v: f4 ~

{, ]) y' X. e/ q9 l0 e

void *hFor;                //表达式句柄 
) o5 o* i- Q, R  |; Z* J6 y
        luINT nPara;                //存放表达式的自变量个数 
' H' X' F8 o; x! ^  L\\" ?$ L
        LuData *pPara;                //存放输入自变量的数组指针 
! g* p, \5 N6 m
        luINT ErrBegin,ErrEnd;        //表达式编译出错的初始位置和结束位置: @! M+ O- O6 S3 o( Q6 T

int ErrCode;                //错误代码 
) f- S# C, {3 ]% k  A& o
        void *v;4 C\\" }$ h) a3 P- m! c$ g

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.]}";//字符串表达式，矩阵乘! [+ B\\" s: _- B\\" Q( n+ K! ]\\" r

//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.]}";//字符串表达式，矩阵点乘 
) u7 N% v& v. Y! y7 z\\" B8 ^\\" q* |1 D
        LuData Val;- x: \' F# _. q- g9 b- q

if(!InitLu()) return;        //初始化Lu\\" B( f/ C8 W: H8 {/ y' n8 W

while(LockKey(Matrix,DelMatrix,OpMatrix)){Matrix--;}        //锁定一个键，用于存储矩阵扩展类型 
2 S& p+ q3 u  O
 
( E: v\\" U/ L4 y* x
        Val.BType=luStaData_int64; Val.VType=luStaData_int64; Val.x=Matrix;        //定义整数常量 
0 \% R  l, v: ?/ h, A( D
        SetConst(L"matrix",&Val);        //设置整数常量- ?; _# T+ `( V2 \) x. l: t- g  b

InsertKey("\0\0\0\0",4,luPubKey_User,LuMessage,NULL,NULL,1,v); //使Lu运行时可输出函数信息 
% I- C1 ^5 y0 ]; v/ B+ e2 o
        wcout.imbue(locale("chs"));        //设置输出的locale为中文 
: i4 H5 k# x# F3 u- |8 h
  : Q7 F( |- [1 q\\" I8 R9 `

ErrCode=LuCom(ForStr,0,0,0,hFor,nPara,pPara,ErrBegin,ErrEnd); //编译表达式 
7 j( x  ^8 J# w$ T- {' Q0 v
        if(ErrCode)8 s$ X$ }& [8 ?7 c7 q- n7 P

{& U9 b! `' x& R9 n! F

wcout<<L"表达式有错误！错误代码："<<ErrCode<<endl;- c# L) m+ Y9 e5 Y

} 
% }0 O# N. D6 {. S7 v. w3 |. d  e
        else 
* T+ s- t' K. y7 Y% V; V
        {' b5 \) }2 a$ [2 y* h

LuCal(hFor,pPara);        //计算表达式的值4 {! S2 z/ t) ^7 x

} 
1 e! a( `* A: t  v. s5 T
        LockKey(Matrix,NULL,OpMatrix);//解锁键Matrix，本例中，该函数可以不用* X9 X/ z$ b0 i

FreeLu();                        //释放Lu 
2 ^! l/ [6 I+ U# x( Q: h
}

习题：

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

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

main(:a,b,c,d,t,i)=
/ W8 Z* F4 r h1 t
a=new[matrix,2,2: 1.,2.,2.,1.],
, j, i Z; _/ c; r
b=new[matrix,2,2: 2.,1.,1.,2.],
c=new[matrix,2,2: 2/3.,-1/3.,-1/3.,2/3.], t1 ~6 N& w/ g6 O
t=clock(),
5 t/ c' @. a8 G0 e4 N7 E\" @
d=a*b, i=0, while{i<1000000, d=d*c*b, i++},
+ H s8 n \) K+ C3 c
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\"}";//字符串表达式

复制代码

结果：