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

查看: 8674|回复: 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>& d\\" X. ~( ~( P8 J
#include <iostream>. o8 p7 s( H% m$ d
#include <math.h># i D7 d7 W9 `! w: j
#include "lu32.h"
4 j8 a5 E# f6 U( a: X
#pragma comment( lib, "lu32.lib" )* I& C5 ?4 A: t) T4 o1 x- t
using namespace std;
' O) t$ d9 N% n2 d e1 g4 l
//自定义矩阵
& c7 T) H1 N+ p, i4 ]6 P
class myMatrix
) C% g W( f( w1 c7 P
{
5 M1 v% o3 r2 e7 L; e1 L4 F5 Z
public:
# m6 K% c; r+ X3 B2 N$ J
double *Array; //数据缓冲区
- i7 h7 k9 N! t5 G8 L1 X
luVOID ArrayLen; //数据缓冲区长度. F* }) d) \& j+ |! ]+ P2 S9 h0 U
luVOID Dim[2]; //矩阵维数# t, y8 B$ u2 Z, ?4 P9 n
myMatrix(){Array=NULL; ArrayLen=0; Dim[0]=0; Dim[1]=0;}( o+ c* I( _/ E# @\\" v
~myMatrix()
: f; M0 `2 s- Z, b8 ^' [8 ]1 a
{
: I+ i+ c0 E' f2 a! i
if(Array) delete[] Array;
, _. f+ _; ^( n' I/ o! e! @0 v# f$ y
}# I: m\\" `1 K) k) m) [( `( T4 c
};
2 G+ E! A5 L. W5 e, R: t' e
luKEY Matrix=-1000; //标识矩阵类型，最终的Matrix由LockKey决定
4 D; k, E4 ]- f3 O2 U% _
void _stdcall LuMessage(wchar_t *pch)//输出动态库信息，该函数注册到Lu，由Lu二级函数调用 5 I( l4 j; a4 } {7 [4 b! |9 d
{
9 x# l+ U% j' {
wcout<<pch;% g: z, `2 v/ \0 O
}( a0 f9 Y, D0 b! D
void _stdcall DelMatrix(void *me) //用于LockKey函数及InsertKey函数，使Lu能自动销毁myMatrix对象7 J4 Z! }- a4 g1 [* ~
{
8 a: A; W: X5 U m
delete (myMatrix *)me;9 P/ R' z! s7 C+ S I* a\\" Q
}+ D& [3 {) m/ E& N! S: {2 l# D; ]
myMatrix * _stdcall NewMatrix(luVOID m,luVOID n) //生成一个myMatrix对象% w+ a, L, J7 Y. `
{ i8 B9 Z; p; t7 a( w
myMatrix *pMatrix;! \1 Q$ g! G. U7 K+ b6 Y
luVOID k;6 y\\" H: `. B z# h, C. C8 j/ P
double *pa;+ g. e8 r\\" S8 W\\" E8 f4 ], z
char keyname[sizeof(luVOID)];
7 m p: b+ }\\" Q4 {0 j# b
void *NowKey;, Y% Z7 l- p# T( E
k=m*n;2 N+ B# @8 H* `3 z8 r; d4 _
pMatrix=(myMatrix *)GetBufObj(Matrix,keyname);//先尝试从缓冲区中获取一个矩阵对象# T. [: h l6 i+ S
if(pMatrix)
1 e\\" E) K* S# {\\" p; [9 r, o! p
{
9 @4 F- X) e# X% {9 E& P
if(pMatrix->ArrayLen!=k) //重置矩阵的大小
9 r& x; W' i4 ~! E. r* ^3 b
{/ Y8 y8 s5 S! P' d% b: j+ \. X
pa=new double[k];) R' i+ A/ ^3 x/ U4 K
if(!pa)
. a( Q- }, M, P1 r2 J: A5 Q( t: j) ?2 X
{4 j) Z1 y/ B0 l% P5 N0 i
DeleteKey(keyname,sizeof(luVOID),Matrix,DelMatrix,1); //将矩阵对象放回缓冲区; g: X6 Y) m1 j& `0 h2 Y
return NULL;4 ^4 f* |; \- C8 m6 E; p! I- x
}3 Y2 g# A' U+ r7 c
delete[] pMatrix->Array;2 y& n, ]' R; O+ j* A/ |
pMatrix->Array=pa;7 J* |% j$ y+ p$ p& y
}
/ e% i# D* n8 d- t2 o
}' G8 G3 z4 A' S) @% F! o
else+ }\\" e) l2 B\\" J- I
{3 m5 s% _1 T5 M: I
pMatrix=new myMatrix; //创建矩阵对象
( _! E X- J\\" |1 D; p/ m6 G+ Z6 R
if(!pMatrix) return NULL;
5 _0 [; Q1 c: X+ e1 ~- L
pMatrix->Array=new double[k];
( z9 p7 c\\" t5 a\\" Q: ~- p- v
if(!pMatrix->Array)5 ]. s% n# G; ?6 `
{
) N! m! Q. I\\" `) z' p6 p\\" x
delete pMatrix;\\" j( c* n, l/ h. E\\" w5 l
return NULL;0 F) K' c1 ? R+ M, l
}# `! y2 } A, r) t
if(InsertKey((char *)&pMatrix,-1,Matrix,pMatrix,DelMatrix,NULL,0,NowKey)) //将矩阵对象注册到Lu2 P) k/ d9 l' ^# R5 t. r
{
& x% g0 f7 ^) a) ]3 k7 C
delete pMatrix;
- }4 V7 E1 P5 U
return NULL;5 U* G6 l6 N7 m0 E
}, ~) p, i! o8 T0 Y. m
}# l1 x* M: s9 y6 h; x T8 z
pMatrix->ArrayLen=k; pMatrix->Dim[0]=m; pMatrix->Dim[1]=n;
% m N9 c5 n; G7 u! R1 j\\" s; z9 m
return pMatrix;
. `6 k# V& x; I* b% h K B8 J# Y
}
( Q$ W+ R) e; s5 U: O3 [
LuData _stdcall OpMatrix(luINT mm,LuData *xx,void *hFor,int theOperator) //运算符重载函数，用于LockKey函数
) K+ z3 ?& X7 ]7 }. T- K- {
{
/ U\\" G6 |& f' f* I& m) o4 Y
LuData a;0 r3 c! l9 {6 u: _
myMatrix *pMatrix1,*pMatrix2,*pMatrix3;
- O. w2 { I% m9 H
luVOID i,j,k,m,n,u,v;
# A7 D3 u( I( j0 h* p6 r
double *pa,*pb,*pc;( b/ \4 f7 |, ~6 n; {2 Z7 L+ z
luMessage pMessage;
3 h. b( B5 F$ I( b. u
wchar_t wchNum[32];
$ W8 M1 X) g+ ^! n
char chNum[32];
* {& L/ K$ I! F! S6 `9 w* f
a.BType=luStaData_nil; a.VType=luStaData_nil; a.x=0;( }2 j9 H( t; k# D! m
switch(theOperator)3 U1 H! H& Q! R
{
$ B) }* d\\" h2 P
case 2: //重载运算符*
# W9 A8 {5 g\\" R7 t& S
pMatrix1=(myMatrix *)SearchKey((char *)&(xx->x),sizeof(luVOID),Matrix);
2 s9 b7 l7 G4 b! F/ L4 q4 @
pMatrix2=(myMatrix *)SearchKey((char *)&((xx+1)->x),sizeof(luVOID),Matrix);+ I# A' n( S- z\\" T$ M: Q2 I9 d' K8 {
if(!pMatrix1 || !pMatrix2) break; //对象句柄无效，不是矩阵1 j4 L7 Q# m3 q4 _! h. y% b
if(pMatrix1->Dim[1]!=pMatrix2->Dim[0]) break; //维数不匹配
, ]0 p# v+ X& n% f8 Z+ Z$ @
pMatrix3=NewMatrix(pMatrix1->Dim[0],pMatrix2->Dim[1]); //生成新矩阵3 L& J a( I$ ~0 Z U( [) j7 P a
if(!pMatrix3) break;
9 a7 ~, r% C1 w: T+ K2 V
pa=pMatrix1->Array; pb=pMatrix2->Array; pc=pMatrix3->Array;
% X; u$ v3 x+ H- {) C' c
m=pMatrix1->Dim[0]; n=pMatrix1->Dim[1]; k=pMatrix2->Dim[1];
8 Q- [5 \( @/ P% d1 U: m
for(i=0; i<m; i++) //矩阵乘! F) ], u4 J. y+ |\\" s% L& C
{, G\\" P/ Q- @2 g+ a3 m4 f
for(j=0; j<k; j++)
: c2 |& G5 F- s3 C6 A$ U! h c
{5 H8 g m6 H+ E1 X
u=i*k+j; pc[u]=0.0;
' N. r3 H$ t. n2 N1 f
for (v=0; v<n; v++)2 P\\" t! [& n; f$ @3 ~
{
* j\\" {. R3 Q\\" I, ^/ R, l
pc[u]=pc[u]+pa[i*n+v]*pb[v*k+j];
1 M! A' h. c7 W3 z) }8 d/ I E
}
# p4 J7 v1 q. z0 ?4 N! M+ ^/ m
}
, J$ K; h* h3 r& M$ u7 B
}
4 b& V4 U\\" Y7 H; z
FunReObj(hFor); //告诉Lu，返回一个动态对象
( K: {/ s6 e. q. t- s5 @
a.BType=Matrix; a.VType=Matrix; a.x=0; *(luVOID *)&(a.x)=(luVOID)pMatrix3;7 c) }; x% j; M& F/ ?9 @2 u7 Q% O
break;% G0 L' H; p6 o+ l. y
case 25: //重载运算符.*5 p8 H0 q7 M4 T- J( z9 x
pMatrix1=(myMatrix *)SearchKey((char *)&(xx->x),sizeof(luVOID),Matrix);; I: }4 C# M$ c6 ]
pMatrix2=(myMatrix *)SearchKey((char *)&((xx+1)->x),sizeof(luVOID),Matrix);8 j, Y ~( @6 c3 U) G\\" D# ?( o
if(!pMatrix1 || !pMatrix2) break; //对象句柄无效，不是矩阵\\" i1 I8 P! V. Y
if(pMatrix1->Dim[0]!=pMatrix2->Dim[0] || pMatrix1->Dim[1]!=pMatrix2->Dim[1]) break; //维数不相同5 ^\\" i1 H( s3 O7 i2 n
pMatrix3=NewMatrix(pMatrix1->Dim[0],pMatrix1->Dim[1]); //生成新矩阵$ s' _3 Q N ^: e& n
if(!pMatrix3) break;( w* {1 c1 q7 ~% ?8 O A3 p
for(i=0;i<pMatrix1->ArrayLen;i++) pMatrix3->Array[i]=pMatrix1->Array[i]*pMatrix2->Array[i]; //矩阵点乘
# ^& v* ]6 e3 l9 }# M2 |% |: Q9 w
FunReObj(hFor); //告诉Lu，返回一个动态对象
/ A; L3 f\\" k+ [% @) S; w
a.BType=Matrix; a.VType=Matrix; a.x=0; *(luVOID *)&(a.x)=(luVOID)pMatrix3;+ ^, f\\" ~% b6 U6 W
break;
7 u6 y% L* }\\" j
case 46: //重载函数new- K3 t3 K4 w3 P2 M: ~
if(mm<2) break;: \' U5 Y' z. f* F- e5 ^2 y
if((xx+1)->x<1 || (xx+2)->x<1 || (xx+1)->BType!=luStaData_int64 || (xx+2)->BType!=luStaData_int64) break;+ K9 {+ B! U$ @- g
pMatrix3=NewMatrix((luVOID)(xx+1)->x,(luVOID)(xx+2)->x);//生成新矩阵
# b+ B# G$ P/ M* A. z
if(!pMatrix3) break;
2 M7 X) \1 C& @ m/ A0 W
for(j=0,i=3;i<=mm;i++,j++) //赋初值; j$ g7 y) C1 J: q- F1 `7 H
{
- w N/ K* F3 `# y5 W3 T
if(j>=pMatrix3->ArrayLen) break;
% F5 I0 x2 l; p9 ~! _# y' u
if((xx+i)->BType!=luStaData_double) break; //只接受实数参数
; W( i& l2 j* |- q/ P
pMatrix3->Array[j]=*(double *)&((xx+i)->x);
- y E4 E7 j. E( \ U9 _4 }' l
}
( `5 H5 }& a; x: X9 F$ {
FunReObj(hFor); //告诉Lu，返回一个动态对象 B/ k, B9 A. S4 C% l: y+ k
a.BType=Matrix; a.VType=Matrix; a.x=0; *(luVOID *)&(a.x)=(luVOID)pMatrix3;
+ {) A\\" e2 ^+ ]) t! k
break;
* v+ c7 `) j9 f\\" J+ B7 Y
case 49: //重载函数o. [# k. m; n' X! W8 n/ r8 k5 ]/ U) g
pMessage=(luMessage)SearchKey("\0\0\0\0",sizeof(luVOID),luPubKey_User);
. f1 L2 b6 D; q. y1 Z L
if(!pMessage) break;
' u6 e9 f- a9 r6 O5 a7 N8 {: H
pMatrix1=(myMatrix *)SearchKey((char *)&(xx->x),sizeof(luVOID),Matrix);
: j' b- `2 {0 p0 Q1 l0 q
if(!pMatrix1) break; //对象句柄无效，不是矩阵
; s& Q- e B0 D# f0 t) i6 i4 v
pa=pMatrix1->Array;' T\\" `6 d' ?' \5 ]
m=pMatrix1->Dim[0]; n=pMatrix1->Dim[1]; k=0;* t4 U/ @0 B! ]3 q/ s$ Z
for(i=0; i<m; i++) //输出矩阵
! R+ w$ R' @) L3 c/ G. v2 J
{
6 x+ _( Z9 O4 D! o; f
pMessage(L"\r\n"); k+=2;
) p$ P/ {' r, n; \
for(j=0; j<n; j++)
' |: T& [$ P# D6 P5 R$ d
{
: Y9 J- k\\" y& ^3 l' }& {
_gcvt_s(chNum,pa[i*n+j],16);
( U* D( i' C& u4 }4 n' V
for(u=0;chNum[u];u++) {wchNum[u]=chNum[u]; k++;}
+ u\\" [\\" f( M% e! y5 C
wchNum[u]='\0';9 ?\\" ~$ R, `4 \\\" u+ K
pMessage(wchNum); pMessage(L" "); k+=2;. \' Q1 V6 s. x/ v
}
1 J$ H5 i n/ i, n S' l+ F5 H [
}6 }( u( {) H& U+ m$ \( r4 s, z. X4 ^
pMessage(L"\r\n"); k+=2;4 s: x: j8 Z( q0 y) ]
a.BType=luStaData_int64; a.VType=luStaData_int64; a.x=k; //按函数o的要求，返回输出的字符总数9 c8 S; s3 |! M% b/ _1 _9 A* |
break;' n) l, |# g# W- d
default:6 a3 N3 `( b3 h+ w, p& @
break;' d1 r- A9 I- U- y! `
}+ a8 X2 x. V3 V+ ^5 p: c2 r
return a;8 `* q) k, f' I' s' A; L# P
}2 G: s' J! ^0 M' ?( m) c
void main(void)2 d\\" r0 p* {& \2 O\\" M
{
\\" f# @' }; k; i u
void *hFor; //表达式句柄1 v0 s9 X9 g4 g9 Y! y# ~9 i+ h, _% n
luINT nPara; //存放表达式的自变量个数
2 Y/ q) u$ k\\" H& J3 L/ ]# ^: ]
LuData *pPara; //存放输入自变量的数组指针7 O- j& E/ I2 H: |! D- w4 H9 J8 c\\" [
luINT ErrBegin,ErrEnd; //表达式编译出错的初始位置和结束位置* M6 N\\" {, b/ E; U
int ErrCode; //错误代码
3 x& D+ a\\" ~- P( v5 c
void *v;; e0 A: }+ [! d4 [# Z/ ~
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.]}";//字符串表达式，矩阵乘& a. |5 Z0 e\\" k
//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.]}";//字符串表达式，矩阵点乘9 B) y% ^% v0 K! i; T( o+ H% [ T
LuData Val;3 u9 t; V, q- t- N# i
if(!InitLu()) return; //初始化Lu6 K\\" c; F- }/ D7 h% Y2 J) d
while(LockKey(Matrix,DelMatrix,OpMatrix)){Matrix--;} //锁定一个键，用于存储矩阵扩展类型
* P! w/ f( g& f\\" N5 J
0 ?+ e; p j* `
Val.BType=luStaData_int64; Val.VType=luStaData_int64; Val.x=Matrix; //定义整数常量+ a1 L* q, x, ]1 Z R
SetConst(L"matrix",&Val); //设置整数常量
! v7 {. G\\" {3 X2 T( N& |& Q
InsertKey("\0\0\0\0",4,luPubKey_User,LuMessage,NULL,NULL,1,v); //使Lu运行时可输出函数信息. V. S; M1 C, H\\" m: z4 p
wcout.imbue(locale("chs")); //设置输出的locale为中文, Z1 j0 K8 ^7 U- O- E' Q- r
* ] q ^3 \0 r4 X8 ?( I# O( [
ErrCode=LuCom(ForStr,0,0,0,hFor,nPara,pPara,ErrBegin,ErrEnd); //编译表达式
) {\\" ^, h& I+ i+ N9 ]0 D
if(ErrCode)5 m$ ]& ^6 _, r/ ?
{, K$ G0 ]) L$ I
wcout<<L"表达式有错误！错误代码："<<ErrCode<<endl;
) w' E9 ?# g9 W/ d
}
9 C% g Z; X5 {, u
else
9 n8 ]/ H+ v! O& Q# n) I
{. j5 D, T! }/ u, y; y6 S3 @
LuCal(hFor,pPara); //计算表达式的值- E\\" }* \' d# m, M% l; |$ q
}
3 ~; u\\" G- i8 [# @) s
LockKey(Matrix,NULL,OpMatrix);//解锁键Matrix，本例中，该函数可以不用
7 @* H! ?6 a0 C- |( P
FreeLu(); //释放Lu
1 c( d: U/ s* f9 M3 f. Q8 V! n
}

#include <windows.h>& d\\" X. ~( ~( P8 J

#include <iostream>. o8 p7 s( H% m$ d

#include <math.h># i  D7 d7 W9 `! w: j

#include "lu32.h" 
4 j8 a5 E# f6 U( a: X
#pragma comment( lib, "lu32.lib" )* I& C5 ?4 A: t) T4 o1 x- t

using namespace std; 
' O) t$ d9 N% n2 d  e1 g4 l
//自定义矩阵 
& c7 T) H1 N+ p, i4 ]6 P
class myMatrix 
) C% g  W( f( w1 c7 P
{ 
5 M1 v% o3 r2 e7 L; e1 L4 F5 Z
public: 
# m6 K% c; r+ X3 B2 N$ J
        double *Array;        //数据缓冲区 
- i7 h7 k9 N! t5 G8 L1 X
        luVOID ArrayLen;        //数据缓冲区长度. F* }) d) \& j+ |! ]+ P2 S9 h0 U

luVOID Dim[2];        //矩阵维数# t, y8 B$ u2 Z, ?4 P9 n

myMatrix(){Array=NULL; ArrayLen=0; Dim[0]=0; Dim[1]=0;}( o+ c* I( _/ E# @\\" v

~myMatrix() 
: f; M0 `2 s- Z, b8 ^' [8 ]1 a
        { 
: I+ i+ c0 E' f2 a! i
                if(Array) delete[] Array; 
, _. f+ _; ^( n' I/ o! e! @0 v# f$ y
        }# I: m\\" `1 K) k) m) [( `( T4 c

}; 
2 G+ E! A5 L. W5 e, R: t' e
luKEY Matrix=-1000;        //标识矩阵类型，最终的Matrix由LockKey决定 
4 D; k, E4 ]- f3 O2 U% _
void _stdcall LuMessage(wchar_t *pch)//输出动态库信息，该函数注册到Lu，由Lu二级函数调用 5 I( l4 j; a4 }  {7 [4 b! |9 d

{ 
9 x# l+ U% j' {
        wcout<<pch;% g: z, `2 v/ \0 O

}( a0 f9 Y, D0 b! D

void _stdcall DelMatrix(void *me)        //用于LockKey函数及InsertKey函数，使Lu能自动销毁myMatrix对象7 J4 Z! }- a4 g1 [* ~

{ 
8 a: A; W: X5 U  m
        delete (myMatrix *)me;9 P/ R' z! s7 C+ S  I* a\\" Q

}+ D& [3 {) m/ E& N! S: {2 l# D; ]

myMatrix * _stdcall NewMatrix(luVOID m,luVOID n)        //生成一个myMatrix对象% w+ a, L, J7 Y. `

{  i8 B9 Z; p; t7 a( w

myMatrix *pMatrix;! \1 Q$ g! G. U7 K+ b6 Y

luVOID k;6 y\\" H: `. B  z# h, C. C8 j/ P

double *pa;+ g. e8 r\\" S8 W\\" E8 f4 ], z

char keyname[sizeof(luVOID)]; 
7 m  p: b+ }\\" Q4 {0 j# b
        void *NowKey;, Y% Z7 l- p# T( E

k=m*n;2 N+ B# @8 H* `3 z8 r; d4 _

pMatrix=(myMatrix *)GetBufObj(Matrix,keyname);//先尝试从缓冲区中获取一个矩阵对象# T. [: h  l6 i+ S

if(pMatrix) 
1 e\\" E) K* S# {\\" p; [9 r, o! p
        { 
9 @4 F- X) e# X% {9 E& P
                if(pMatrix->ArrayLen!=k)        //重置矩阵的大小 
9 r& x; W' i4 ~! E. r* ^3 b
                {/ Y8 y8 s5 S! P' d% b: j+ \. X

pa=new double[k];) R' i+ A/ ^3 x/ U4 K

if(!pa) 
. a( Q- }, M, P1 r2 J: A5 Q( t: j) ?2 X
                        {4 j) Z1 y/ B0 l% P5 N0 i

DeleteKey(keyname,sizeof(luVOID),Matrix,DelMatrix,1);        //将矩阵对象放回缓冲区; g: X6 Y) m1 j& `0 h2 Y

return NULL;4 ^4 f* |; \- C8 m6 E; p! I- x

}3 Y2 g# A' U+ r7 c

delete[] pMatrix->Array;2 y& n, ]' R; O+ j* A/ |

pMatrix->Array=pa;7 J* |% j$ y+ p$ p& y

} 
/ e% i# D* n8 d- t2 o
        }' G8 G3 z4 A' S) @% F! o

else+ }\\" e) l2 B\\" J- I

{3 m5 s% _1 T5 M: I

pMatrix=new myMatrix;        //创建矩阵对象 
( _! E  X- J\\" |1 D; p/ m6 G+ Z6 R
                if(!pMatrix) return NULL; 
5 _0 [; Q1 c: X+ e1 ~- L
                pMatrix->Array=new double[k]; 
( z9 p7 c\\" t5 a\\" Q: ~- p- v
                if(!pMatrix->Array)5 ]. s% n# G; ?6 `

{ 
) N! m! Q. I\\" `) z' p6 p\\" x
                        delete pMatrix;\\" j( c* n, l/ h. E\\" w5 l

return NULL;0 F) K' c1 ?  R+ M, l

}# `! y2 }  A, r) t

if(InsertKey((char *)&pMatrix,-1,Matrix,pMatrix,DelMatrix,NULL,0,NowKey))        //将矩阵对象注册到Lu2 P) k/ d9 l' ^# R5 t. r

{ 
& x% g0 f7 ^) a) ]3 k7 C
                        delete pMatrix; 
- }4 V7 E1 P5 U
                        return NULL;5 U* G6 l6 N7 m0 E

}, ~) p, i! o8 T0 Y. m

}# l1 x* M: s9 y6 h; x  T8 z

pMatrix->ArrayLen=k; pMatrix->Dim[0]=m; pMatrix->Dim[1]=n; 
% m  N9 c5 n; G7 u! R1 j\\" s; z9 m
        return pMatrix; 
. `6 k# V& x; I* b% h  K  B8 J# Y
} 
( Q$ W+ R) e; s5 U: O3 [
LuData _stdcall OpMatrix(luINT mm,LuData *xx,void *hFor,int theOperator)        //运算符重载函数，用于LockKey函数 
) K+ z3 ?& X7 ]7 }. T- K- {
{ 
/ U\\" G6 |& f' f* I& m) o4 Y
        LuData a;0 r3 c! l9 {6 u: _

myMatrix *pMatrix1,*pMatrix2,*pMatrix3; 
- O. w2 {  I% m9 H
        luVOID i,j,k,m,n,u,v; 
# A7 D3 u( I( j0 h* p6 r
        double *pa,*pb,*pc;( b/ \4 f7 |, ~6 n; {2 Z7 L+ z

luMessage pMessage; 
3 h. b( B5 F$ I( b. u
        wchar_t wchNum[32]; 
$ W8 M1 X) g+ ^! n
        char chNum[32]; 
* {& L/ K$ I! F! S6 `9 w* f
        a.BType=luStaData_nil; a.VType=luStaData_nil; a.x=0;( }2 j9 H( t; k# D! m

switch(theOperator)3 U1 H! H& Q! R

{ 
$ B) }* d\\" h2 P
        case 2:        //重载运算符* 
# W9 A8 {5 g\\" R7 t& S
                pMatrix1=(myMatrix *)SearchKey((char *)&(xx->x),sizeof(luVOID),Matrix); 
2 s9 b7 l7 G4 b! F/ L4 q4 @
                pMatrix2=(myMatrix *)SearchKey((char *)&((xx+1)->x),sizeof(luVOID),Matrix);+ I# A' n( S- z\\" T$ M: Q2 I9 d' K8 {

if(!pMatrix1 || !pMatrix2) break;        //对象句柄无效，不是矩阵1 j4 L7 Q# m3 q4 _! h. y% b

if(pMatrix1->Dim[1]!=pMatrix2->Dim[0]) break;        //维数不匹配 
, ]0 p# v+ X& n% f8 Z+ Z$ @
                pMatrix3=NewMatrix(pMatrix1->Dim[0],pMatrix2->Dim[1]);        //生成新矩阵3 L& J  a( I$ ~0 Z  U( [) j7 P  a

if(!pMatrix3) break; 
9 a7 ~, r% C1 w: T+ K2 V
                pa=pMatrix1->Array; pb=pMatrix2->Array; pc=pMatrix3->Array; 
% X; u$ v3 x+ H- {) C' c
                m=pMatrix1->Dim[0]; n=pMatrix1->Dim[1]; k=pMatrix2->Dim[1]; 
8 Q- [5 \( @/ P% d1 U: m
                for(i=0; i<m; i++)        //矩阵乘! F) ], u4 J. y+ |\\" s% L& C

{, G\\" P/ Q- @2 g+ a3 m4 f

for(j=0; j<k; j++) 
: c2 |& G5 F- s3 C6 A$ U! h  c
                        {5 H8 g  m6 H+ E1 X

u=i*k+j; pc[u]=0.0; 
' N. r3 H$ t. n2 N1 f
                                for (v=0; v<n; v++)2 P\\" t! [& n; f$ @3 ~

{ 
* j\\" {. R3 Q\\" I, ^/ R, l
                                        pc[u]=pc[u]+pa[i*n+v]*pb[v*k+j]; 
1 M! A' h. c7 W3 z) }8 d/ I  E
                                } 
# p4 J7 v1 q. z0 ?4 N! M+ ^/ m
                        } 
, J$ K; h* h3 r& M$ u7 B
                } 
4 b& V4 U\\" Y7 H; z
                FunReObj(hFor);        //告诉Lu，返回一个动态对象 
( K: {/ s6 e. q. t- s5 @
                a.BType=Matrix; a.VType=Matrix; a.x=0; *(luVOID *)&(a.x)=(luVOID)pMatrix3;7 c) }; x% j; M& F/ ?9 @2 u7 Q% O

break;% G0 L' H; p6 o+ l. y

case 25:        //重载运算符.*5 p8 H0 q7 M4 T- J( z9 x

pMatrix1=(myMatrix *)SearchKey((char *)&(xx->x),sizeof(luVOID),Matrix);; I: }4 C# M$ c6 ]

pMatrix2=(myMatrix *)SearchKey((char *)&((xx+1)->x),sizeof(luVOID),Matrix);8 j, Y  ~( @6 c3 U) G\\" D# ?( o

if(!pMatrix1 || !pMatrix2) break;        //对象句柄无效，不是矩阵\\" i1 I8 P! V. Y

if(pMatrix1->Dim[0]!=pMatrix2->Dim[0] || pMatrix1->Dim[1]!=pMatrix2->Dim[1]) break;        //维数不相同5 ^\\" i1 H( s3 O7 i2 n

pMatrix3=NewMatrix(pMatrix1->Dim[0],pMatrix1->Dim[1]);        //生成新矩阵$ s' _3 Q  N  ^: e& n

if(!pMatrix3) break;( w* {1 c1 q7 ~% ?8 O  A3 p

for(i=0;i<pMatrix1->ArrayLen;i++) pMatrix3->Array[i]=pMatrix1->Array[i]*pMatrix2->Array[i];        //矩阵点乘 
# ^& v* ]6 e3 l9 }# M2 |% |: Q9 w
                FunReObj(hFor);        //告诉Lu，返回一个动态对象 
/ A; L3 f\\" k+ [% @) S; w
                a.BType=Matrix; a.VType=Matrix; a.x=0; *(luVOID *)&(a.x)=(luVOID)pMatrix3;+ ^, f\\" ~% b6 U6 W

break; 
7 u6 y% L* }\\" j
        case 46:        //重载函数new- K3 t3 K4 w3 P2 M: ~

if(mm<2) break;: \' U5 Y' z. f* F- e5 ^2 y

if((xx+1)->x<1 || (xx+2)->x<1 || (xx+1)->BType!=luStaData_int64 || (xx+2)->BType!=luStaData_int64) break;+ K9 {+ B! U$ @- g

pMatrix3=NewMatrix((luVOID)(xx+1)->x,(luVOID)(xx+2)->x);//生成新矩阵 
# b+ B# G$ P/ M* A. z
                if(!pMatrix3) break; 
2 M7 X) \1 C& @  m/ A0 W
                for(j=0,i=3;i<=mm;i++,j++)        //赋初值; j$ g7 y) C1 J: q- F1 `7 H

{ 
- w  N/ K* F3 `# y5 W3 T
                        if(j>=pMatrix3->ArrayLen) break; 
% F5 I0 x2 l; p9 ~! _# y' u
                        if((xx+i)->BType!=luStaData_double) break;        //只接受实数参数 
; W( i& l2 j* |- q/ P
                        pMatrix3->Array[j]=*(double *)&((xx+i)->x); 
- y  E4 E7 j. E( \  U9 _4 }' l
                } 
( `5 H5 }& a; x: X9 F$ {
                FunReObj(hFor);        //告诉Lu，返回一个动态对象  B/ k, B9 A. S4 C% l: y+ k

a.BType=Matrix; a.VType=Matrix; a.x=0; *(luVOID *)&(a.x)=(luVOID)pMatrix3; 
+ {) A\\" e2 ^+ ]) t! k
                break; 
* v+ c7 `) j9 f\\" J+ B7 Y
        case 49:        //重载函数o. [# k. m; n' X! W8 n/ r8 k5 ]/ U) g

pMessage=(luMessage)SearchKey("\0\0\0\0",sizeof(luVOID),luPubKey_User); 
. f1 L2 b6 D; q. y1 Z  L
                if(!pMessage) break; 
' u6 e9 f- a9 r6 O5 a7 N8 {: H
                pMatrix1=(myMatrix *)SearchKey((char *)&(xx->x),sizeof(luVOID),Matrix); 
: j' b- `2 {0 p0 Q1 l0 q
                if(!pMatrix1) break;        //对象句柄无效，不是矩阵 
; s& Q- e  B0 D# f0 t) i6 i4 v
                pa=pMatrix1->Array;' T\\" `6 d' ?' \5 ]

m=pMatrix1->Dim[0]; n=pMatrix1->Dim[1]; k=0;* t4 U/ @0 B! ]3 q/ s$ Z

for(i=0; i<m; i++)        //输出矩阵 
! R+ w$ R' @) L3 c/ G. v2 J
                { 
6 x+ _( Z9 O4 D! o; f
                        pMessage(L"\r\n"); k+=2; 
) p$ P/ {' r, n; \
                        for(j=0; j<n; j++) 
' |: T& [$ P# D6 P5 R$ d
                        { 
: Y9 J- k\\" y& ^3 l' }& {
                                _gcvt_s(chNum,pa[i*n+j],16); 
( U* D( i' C& u4 }4 n' V
                                for(u=0;chNum[u];u++) {wchNum[u]=chNum[u]; k++;} 
+ u\\" [\\" f( M% e! y5 C
                                wchNum[u]='\0';9 ?\\" ~$ R, `4 \\\" u+ K

pMessage(wchNum); pMessage(L"  "); k+=2;. \' Q1 V6 s. x/ v

} 
1 J$ H5 i  n/ i, n  S' l+ F5 H  [
                }6 }( u( {) H& U+ m$ \( r4 s, z. X4 ^

pMessage(L"\r\n"); k+=2;4 s: x: j8 Z( q0 y) ]

a.BType=luStaData_int64; a.VType=luStaData_int64; a.x=k;        //按函数o的要求，返回输出的字符总数9 c8 S; s3 |! M% b/ _1 _9 A* |

break;' n) l, |# g# W- d

default:6 a3 N3 `( b3 h+ w, p& @

break;' d1 r- A9 I- U- y! `

}+ a8 X2 x. V3 V+ ^5 p: c2 r

return a;8 `* q) k, f' I' s' A; L# P

}2 G: s' J! ^0 M' ?( m) c

void main(void)2 d\\" r0 p* {& \2 O\\" M

{ 
\\" f# @' }; k; i  u
        void *hFor;                //表达式句柄1 v0 s9 X9 g4 g9 Y! y# ~9 i+ h, _% n

luINT nPara;                //存放表达式的自变量个数 
2 Y/ q) u$ k\\" H& J3 L/ ]# ^: ]
        LuData *pPara;                //存放输入自变量的数组指针7 O- j& E/ I2 H: |! D- w4 H9 J8 c\\" [

luINT ErrBegin,ErrEnd;        //表达式编译出错的初始位置和结束位置* M6 N\\" {, b/ E; U

int ErrCode;                //错误代码 
3 x& D+ a\\" ~- P( v5 c
        void *v;; e0 A: }+ [! d4 [# Z/ ~

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.]}";//字符串表达式，矩阵乘& a. |5 Z0 e\\" k

//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.]}";//字符串表达式，矩阵点乘9 B) y% ^% v0 K! i; T( o+ H% [  T

LuData Val;3 u9 t; V, q- t- N# i

if(!InitLu()) return;        //初始化Lu6 K\\" c; F- }/ D7 h% Y2 J) d

while(LockKey(Matrix,DelMatrix,OpMatrix)){Matrix--;}        //锁定一个键，用于存储矩阵扩展类型 
* P! w/ f( g& f\\" N5 J
 
0 ?+ e; p  j* `
        Val.BType=luStaData_int64; Val.VType=luStaData_int64; Val.x=Matrix;        //定义整数常量+ a1 L* q, x, ]1 Z  R

SetConst(L"matrix",&Val);        //设置整数常量 
! v7 {. G\\" {3 X2 T( N& |& Q
        InsertKey("\0\0\0\0",4,luPubKey_User,LuMessage,NULL,NULL,1,v); //使Lu运行时可输出函数信息. V. S; M1 C, H\\" m: z4 p

wcout.imbue(locale("chs"));        //设置输出的locale为中文, Z1 j0 K8 ^7 U- O- E' Q- r

* ]  q  ^3 \0 r4 X8 ?( I# O( [

ErrCode=LuCom(ForStr,0,0,0,hFor,nPara,pPara,ErrBegin,ErrEnd); //编译表达式 
) {\\" ^, h& I+ i+ N9 ]0 D
        if(ErrCode)5 m$ ]& ^6 _, r/ ?

{, K$ G0 ]) L$ I

wcout<<L"表达式有错误！错误代码："<<ErrCode<<endl; 
) w' E9 ?# g9 W/ d
        } 
9 C% g  Z; X5 {, u
        else 
9 n8 ]/ H+ v! O& Q# n) I
        {. j5 D, T! }/ u, y; y6 S3 @

LuCal(hFor,pPara);        //计算表达式的值- E\\" }* \' d# m, M% l; |$ q

} 
3 ~; u\\" G- i8 [# @) s
        LockKey(Matrix,NULL,OpMatrix);//解锁键Matrix，本例中，该函数可以不用 
7 @* H! ?6 a0 C- |( P
        FreeLu();                        //释放Lu 
1 c( d: U/ s* f9 M3 f. Q8 V! n
}

习题：

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

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

main(:a,b,c,d,t,i)=
; H+ I0 H) y8 ]& b
a=new[matrix,2,2: 1.,2.,2.,1.],! R$ n4 [) p6 Y4 t7 [& F
b=new[matrix,2,2: 2.,1.,1.,2.],# N% }! s @5 g! m( P) f; T1 o& e
c=new[matrix,2,2: 2/3.,-1/3.,-1/3.,2/3.],3 @( w3 d: B2 }$ \% j
t=clock(),
0 r! f3 v3 \% Q
d=a*b, i=0, while{i<1000000, d=d*c*b, i++},
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\"}";//字符串表达式

复制代码

结果：