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

查看: 9057|回复: 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>
8 a( S0 h. l5 O p9 o
#include <iostream>0 M0 W1 u& w! O& m6 i4 K% s
#include <math.h>
% ^2 C/ F6 w' U+ F) z. i& N) r
#include "lu32.h"
E1 f+ u\\" Y I% q
#pragma comment( lib, "lu32.lib" ), p) y7 o9 B1 `1 L; G# C
using namespace std;' o8 Y0 v0 ?) n3 l
//自定义矩阵
( y% N8 u* Q. @1 ]/ A; f0 x
class myMatrix
: x. ^. ?1 C X! m
{' B! a5 B7 V, ?: Q
public:2 K3 |& e5 L' W2 d$ N
double *Array; //数据缓冲区
0 y( l: Z5 b7 _4 i! J5 z& O
luVOID ArrayLen; //数据缓冲区长度
7 {6 s( D) t- U\\" c# s0 i
luVOID Dim[2]; //矩阵维数8 p/ _8 m6 O# A. ~
myMatrix(){Array=NULL; ArrayLen=0; Dim[0]=0; Dim[1]=0;}
& b/ N4 D, n! s% @
~myMatrix()$ v8 [& e4 _8 R3 u2 c; P
{
% }- v' ?2 A& F/ S+ A2 T3 h. s
if(Array) delete[] Array;\\" S% D& K2 {5 v; t
}
; E3 n! e. U5 r, ]. g
};
) x0 T6 H4 S( v. w/ e
luKEY Matrix=-1000; //标识矩阵类型，最终的Matrix由LockKey决定/ N' U- _$ Q; b
void _stdcall LuMessage(wchar_t *pch)//输出动态库信息，该函数注册到Lu，由Lu二级函数调用 + [. U6 T3 i, V; {8 V' F\\" S
{1 K1 Q3 A5 I- W0 M
wcout<<pch;5 P; ]/ y0 }! S2 o6 s7 V' K
}/ }$ t4 q! Y$ }; T8 K* a, P: I
void _stdcall DelMatrix(void *me) //用于LockKey函数及InsertKey函数，使Lu能自动销毁myMatrix对象 @5 K; j\\" I P p% q7 _+ U
{+ k1 a& ^4 P: G4 D
delete (myMatrix *)me;- v5 o8 v4 R- g4 h8 k
}
( \9 q) K) {' G\\" |
myMatrix * _stdcall NewMatrix(luVOID m,luVOID n) //生成一个myMatrix对象4 t3 j# p+ @9 ]# y8 B+ P' P
{$ n. a6 ?0 H; u9 b% R( C6 x; }
myMatrix *pMatrix;$ Z5 C6 A- ?) A3 z8 B- `
luVOID k;
9 `! p& [) G; F4 ^1 Q' q
double *pa;1 R\\" [ y7 a; r3 F2 m W: w
char keyname[sizeof(luVOID)];
& v s5 p1 |- _4 N) U! s3 Z
void *NowKey;7 C8 p0 b7 ?2 W5 e
k=m*n;
( S2 g9 T% u+ X; w9 F4 o
pMatrix=(myMatrix *)GetBufObj(Matrix,keyname);//先尝试从缓冲区中获取一个矩阵对象
y$ @; N( i\\" @; |6 Q; p
if(pMatrix)& s. J# ]( d+ U* |2 j
{
\\" `; b) @! K- A
if(pMatrix->ArrayLen!=k) //重置矩阵的大小7 Q, Y6 r0 G! j, m0 h) {
{
! p+ X& g0 F/ L! l/ @
pa=new double[k];
' A8 V1 J, W: J\\" b
if(!pa)
* e( S( `: M x% Z( v
{
. {% D, |' b; C) p
DeleteKey(keyname,sizeof(luVOID),Matrix,DelMatrix,1); //将矩阵对象放回缓冲区
3 P2 i+ m. y9 ] g6 s3 G
return NULL;: x8 \2 t# L- b1 V
}% D5 S, U9 G4 {: h0 O* n
delete[] pMatrix->Array;9 z, E3 y( P! s& b3 ~
pMatrix->Array=pa;
9 s% }2 @ g\\" f0 K
}
- Q& S3 \; ?/ y, \0 }. k
}
: ?) N/ U5 A\\" ?' a( f; P) u
else
/ P\\" ~ A0 W$ I7 l, D! m
{
7 H f5 X4 b) E7 y
pMatrix=new myMatrix; //创建矩阵对象, d9 D: T9 f. o) l K) j
if(!pMatrix) return NULL;5 w3 X0 K$ P5 w8 `( [# h
pMatrix->Array=new double[k];8 b: Q5 J& N8 @' a9 R6 a* ]
if(!pMatrix->Array)
/ T o3 ^\\" K! k# O$ q' l
{
1 }; q% _4 K; |2 r! I
delete pMatrix;
- C% S! b# Q# r7 i3 u |- g
return NULL;5 ^) ~$ c8 |' L2 Z\\" O9 N9 A
}3 o$ Z- }& o! H& m8 W: C
if(InsertKey((char *)&pMatrix,-1,Matrix,pMatrix,DelMatrix,NULL,0,NowKey)) //将矩阵对象注册到Lu* d. \# n- m7 U( j$ f6 d( O
{
3 Z\\" U3 @9 h\\" h I$ N8 [/ d
delete pMatrix;
- H. F. O0 Q% [8 j# C: b\\" }; Y
return NULL;' V. i$ g$ M9 Y
}3 `2 u. I\\" _% Z$ B
}4 \5 E. v( _+ g* c
pMatrix->ArrayLen=k; pMatrix->Dim[0]=m; pMatrix->Dim[1]=n;
\\" g- M* b& l* T2 @1 v0 r
return pMatrix;
0 `- _0 E3 q# ~1 ^
}# ^+ w% q& m; ], \/ Y) ]2 L
LuData _stdcall OpMatrix(luINT mm,LuData *xx,void *hFor,int theOperator) //运算符重载函数，用于LockKey函数
2 z* T. L; D3 C: y! `$ J
{$ a6 ~: I4 v7 L, J
LuData a;
: |7 l* T, S0 d5 A2 Q) U
myMatrix *pMatrix1,*pMatrix2,*pMatrix3;
4 H+ a; x4 h5 C
luVOID i,j,k,m,n,u,v; x# d- S8 a1 ^
double *pa,*pb,*pc;
2 t( p! I. ^! b* N1 _
luMessage pMessage;
' O\\" D& R7 ~7 j: P\\" Y
wchar_t wchNum[32];- L( J% F& m/ z$ K$ |3 J
char chNum[32];
; x b* D8 ^$ S
a.BType=luStaData_nil; a.VType=luStaData_nil; a.x=0;' ]; w) ~% q+ M. M/ `: p) @! s: ]
switch(theOperator)0 @% ]3 u' x8 p- E' l
{+ I6 f0 d7 W1 |
case 2: //重载运算符*
5 w. T: B1 n1 ~; n
pMatrix1=(myMatrix *)SearchKey((char *)&(xx->x),sizeof(luVOID),Matrix);
) L% o' b& k b
pMatrix2=(myMatrix *)SearchKey((char *)&((xx+1)->x),sizeof(luVOID),Matrix); M) C, I$ D& h
if(!pMatrix1 || !pMatrix2) break; //对象句柄无效，不是矩阵
0 P4 X2 f4 J8 x& L1 c8 Y
if(pMatrix1->Dim[1]!=pMatrix2->Dim[0]) break; //维数不匹配7 n& |4 x4 h, N8 J6 `\\" b
pMatrix3=NewMatrix(pMatrix1->Dim[0],pMatrix2->Dim[1]); //生成新矩阵4 M9 s$ w+ S! x
if(!pMatrix3) break;, N* g\\" b+ ?/ A
pa=pMatrix1->Array; pb=pMatrix2->Array; pc=pMatrix3->Array;# [ t: f1 i6 }
m=pMatrix1->Dim[0]; n=pMatrix1->Dim[1]; k=pMatrix2->Dim[1];. C. g, k4 a# F6 }
for(i=0; i<m; i++) //矩阵乘/ e; H) y7 @/ @. \
{
/ v, H) g7 g* ?) a* m# z- v
for(j=0; j<k; j++) S( X& W/ H3 \4 k+ \. @& `
{
# ]\\" t- Y' e6 W% J0 ^/ {
u=i*k+j; pc[u]=0.0;1 r4 ]( l\\" V% F
for (v=0; v<n; v++)2 a j: t* V, I) A\\" i/ Q) G9 j
{5 `. M3 v( g% Y4 c! Z' u
pc[u]=pc[u]+pa[i*n+v]*pb[v*k+j];
7 h+ }- E, V7 H8 ]! b \$ O
}! K) }6 H/ p6 o) |0 u4 b1 Y( m+ a* w
}: j6 ?* h; ^' c1 J0 ^
}: H% t. G7 u d# Z
FunReObj(hFor); //告诉Lu，返回一个动态对象4 P5 m3 t9 B: C\\" W$ ]! x
a.BType=Matrix; a.VType=Matrix; a.x=0; *(luVOID *)&(a.x)=(luVOID)pMatrix3;8 ]6 o7 T( d\\" D+ I/ N- K\\" \
break;+ a& \ C D& l3 v\\" I
case 25: //重载运算符.*8 b0 z. j, |+ }% @
pMatrix1=(myMatrix *)SearchKey((char *)&(xx->x),sizeof(luVOID),Matrix);
9 }- w6 Q1 w\\" T5 E1 ~+ Q
pMatrix2=(myMatrix *)SearchKey((char *)&((xx+1)->x),sizeof(luVOID),Matrix);: `& _; }. T+ M. K\\" M
if(!pMatrix1 || !pMatrix2) break; //对象句柄无效，不是矩阵
% H6 R+ ?: ^9 z: D# `! E
if(pMatrix1->Dim[0]!=pMatrix2->Dim[0] || pMatrix1->Dim[1]!=pMatrix2->Dim[1]) break; //维数不相同% _8 S5 ^7 L$ J) U- E; A/ a
pMatrix3=NewMatrix(pMatrix1->Dim[0],pMatrix1->Dim[1]); //生成新矩阵
6 }0 y8 N2 g/ P6 c
if(!pMatrix3) break;
0 V' y+ b9 u\\" L7 M/ R
for(i=0;i<pMatrix1->ArrayLen;i++) pMatrix3->Array[i]=pMatrix1->Array[i]*pMatrix2->Array[i]; //矩阵点乘* m3 I Z! [6 R7 G' ?
FunReObj(hFor); //告诉Lu，返回一个动态对象\\" e6 J( z3 c& F/ F1 b
a.BType=Matrix; a.VType=Matrix; a.x=0; *(luVOID *)&(a.x)=(luVOID)pMatrix3; K4 }! Y+ W% p4 t! R8 r7 z3 t6 m
break;' p; k* Z% T/ j
case 46: //重载函数new! Q C0 F% l a- e- e$ O
if(mm<2) break;
1 T' ?& g! X, V: X0 G; F% @
if((xx+1)->x<1 || (xx+2)->x<1 || (xx+1)->BType!=luStaData_int64 || (xx+2)->BType!=luStaData_int64) break;
) q, v1 Y3 \' i/ z! G7 V) m
pMatrix3=NewMatrix((luVOID)(xx+1)->x,(luVOID)(xx+2)->x);//生成新矩阵
2 w3 p$ P5 ^+ ?
if(!pMatrix3) break;9 h* X* P Z p7 h
for(j=0,i=3;i<=mm;i++,j++) //赋初值 l' q9 w5 V+ z- U
{
' y( y: a. c1 W2 I! ~
if(j>=pMatrix3->ArrayLen) break;
3 S9 T' p# |& u; N+ N
if((xx+i)->BType!=luStaData_double) break; //只接受实数参数: u9 ]: s$ i- @% M& P4 z
pMatrix3->Array[j]=*(double *)&((xx+i)->x);0 R) {6 g9 M0 U) I
}
! K( K! w; R4 o- h
FunReObj(hFor); //告诉Lu，返回一个动态对象
9 W2 Y\\" `5 v: i# ]* ?
a.BType=Matrix; a.VType=Matrix; a.x=0; *(luVOID *)&(a.x)=(luVOID)pMatrix3;$ g3 X) m* a- T2 M1 L% t
break;
5 d7 p$ p |+ y3 D! H! X* ]
case 49: //重载函数o
pMessage=(luMessage)SearchKey("\0\0\0\0",sizeof(luVOID),luPubKey_User);
$ \1 C8 I# w8 {+ @8 F. p
if(!pMessage) break;# C/ o2 T* G D5 l8 g
pMatrix1=(myMatrix *)SearchKey((char *)&(xx->x),sizeof(luVOID),Matrix);, I: i5 V7 {: R, S3 j! t- T0 p V$ v
if(!pMatrix1) break; //对象句柄无效，不是矩阵3 [+ u4 o( s, V
pa=pMatrix1->Array;
' b4 Y3 O* R/ B8 ^: H9 k
m=pMatrix1->Dim[0]; n=pMatrix1->Dim[1]; k=0;( V- Q+ Z, ?2 i7 ^
for(i=0; i<m; i++) //输出矩阵* O' y _* a( Z. n- M
{# l. J. ? V, s\\" Z
pMessage(L"\r\n"); k+=2;9 \6 G: y0 ?. F& O
for(j=0; j<n; j++)
; ~, W* j. c; g! _5 P' |. b. \
{3 n# [1 U7 R2 i) |; B2 t; j d
_gcvt_s(chNum,pa[i*n+j],16);6 Q5 r: q; I/ t0 U\\" Y' b
for(u=0;chNum[u];u++) {wchNum[u]=chNum[u]; k++;}/ Q\\" A, D& r2 d* t9 g4 ?, T3 j
wchNum[u]='\0';2 W/ M6 b4 m. r- q4 M L
pMessage(wchNum); pMessage(L" "); k+=2;
7 @ w6 L& c2 ?\\" W/ ~
}3 z: x2 E6 E# ]7 f3 ~
}
. I0 C7 b1 Q8 x% r6 K% j
pMessage(L"\r\n"); k+=2;5 a8 s3 M# M4 Z8 X/ c- K
a.BType=luStaData_int64; a.VType=luStaData_int64; a.x=k; //按函数o的要求，返回输出的字符总数4 A! {6 @& O9 }\\" i& c
break;
0 b- B$ k! j+ z
default:
Y* b) \0 O0 z% R1 X
break;& t# ^) w( L/ `$ n$ @3 b8 }; }2 O
}. M3 g. I3 I: t3 T5 d, o\\" J6 H* S
return a;
$ i, y ]) ]6 S4 _% [
}- O7 n& ~7 g0 B8 F5 ~8 e5 |
void main(void)
9 E3 h/ T' z3 c7 y M# [8 O# {
{
/ ?: S* o' n$ b! C( \/ s1 {
void *hFor; //表达式句柄
$ v- Y! ~6 w8 n6 `2 G
luINT nPara; //存放表达式的自变量个数, b! N0 F6 k5 P E7 R& p
LuData *pPara; //存放输入自变量的数组指针- U! N4 k$ G+ j( z! T
luINT ErrBegin,ErrEnd; //表达式编译出错的初始位置和结束位置3 Q& s6 H# O$ y( i% l
int ErrCode; //错误代码7 [8 X$ @! H. ^/ o% f4 L/ h( y- s
void *v;
$ K3 M9 I1 z3 ~
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.]}";//字符串表达式，矩阵乘* X' C& a9 u% l9 X1 t( U! B% W
//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.]}";//字符串表达式，矩阵点乘
6 D3 ~% Q+ _( R, ~# W
LuData Val;
6 ?$ U( R' C: t& Z4 [, e0 C: a/ X
if(!InitLu()) return; //初始化Lu; B v: Z/ J9 A\\" v5 c! s+ h& R* g1 J) c: V
while(LockKey(Matrix,DelMatrix,OpMatrix)){Matrix--;} //锁定一个键，用于存储矩阵扩展类型
. |, d Q3 p# _# T+ y1 E
& C1 \( H2 E# Q8 |7 D
Val.BType=luStaData_int64; Val.VType=luStaData_int64; Val.x=Matrix; //定义整数常量9 j2 K/ t! i, V* d: V0 y v% T! @: h
SetConst(L"matrix",&Val); //设置整数常量
/ \( J7 a) |2 I' ?- ?% R/ L; i
InsertKey("\0\0\0\0",4,luPubKey_User,LuMessage,NULL,NULL,1,v); //使Lu运行时可输出函数信息
. ~, `$ s) r+ d6 a# W8 [
wcout.imbue(locale("chs")); //设置输出的locale为中文
$ R( @; Q7 |8 e/ g1 C8 q
0 O4 u' l1 {0 `
ErrCode=LuCom(ForStr,0,0,0,hFor,nPara,pPara,ErrBegin,ErrEnd); //编译表达式' w0 E- K& d8 t9 @
if(ErrCode)
# X( r% X\\" [9 k) J. r2 I- V1 X
{
. \5 L$ J. H3 ?% I* U7 v) u6 m
wcout<<L"表达式有错误！错误代码："<<ErrCode<<endl;9 Z8 N5 J( b Y- o9 [
}
3 Y2 h/ z- S/ `; @8 j/ ?
else4 G! t, x6 D8 r
{
& i# z9 m- ~3 z4 c2 u. z- _$ f
LuCal(hFor,pPara); //计算表达式的值* n6 Q9 N3 a; N! C( g E3 u+ y! V
}
3 s! Y$ m' O4 }1 y( P\\" h) s
LockKey(Matrix,NULL,OpMatrix);//解锁键Matrix，本例中，该函数可以不用
2 H3 F+ ~+ _+ K$ G+ b( y
FreeLu(); //释放Lu# p% p' {% @) _# ^- C I V0 d
}

#include <windows.h> 
8 a( S0 h. l5 O  p9 o
#include <iostream>0 M0 W1 u& w! O& m6 i4 K% s

#include <math.h> 
% ^2 C/ F6 w' U+ F) z. i& N) r
#include "lu32.h" 
  E1 f+ u\\" Y  I% q
#pragma comment( lib, "lu32.lib" ), p) y7 o9 B1 `1 L; G# C

using namespace std;' o8 Y0 v0 ?) n3 l

//自定义矩阵 
( y% N8 u* Q. @1 ]/ A; f0 x
class myMatrix 
: x. ^. ?1 C  X! m
{' B! a5 B7 V, ?: Q

public:2 K3 |& e5 L' W2 d$ N

double *Array;        //数据缓冲区 
0 y( l: Z5 b7 _4 i! J5 z& O
        luVOID ArrayLen;        //数据缓冲区长度 
7 {6 s( D) t- U\\" c# s0 i
        luVOID Dim[2];        //矩阵维数8 p/ _8 m6 O# A. ~

myMatrix(){Array=NULL; ArrayLen=0; Dim[0]=0; Dim[1]=0;} 
& b/ N4 D, n! s% @
        ~myMatrix()$ v8 [& e4 _8 R3 u2 c; P

{ 
% }- v' ?2 A& F/ S+ A2 T3 h. s
                if(Array) delete[] Array;\\" S% D& K2 {5 v; t

} 
; E3 n! e. U5 r, ]. g
}; 
) x0 T6 H4 S( v. w/ e
luKEY Matrix=-1000;        //标识矩阵类型，最终的Matrix由LockKey决定/ N' U- _$ Q; b

void _stdcall LuMessage(wchar_t *pch)//输出动态库信息，该函数注册到Lu，由Lu二级函数调用 + [. U6 T3 i, V; {8 V' F\\" S

{1 K1 Q3 A5 I- W0 M

wcout<<pch;5 P; ]/ y0 }! S2 o6 s7 V' K

}/ }$ t4 q! Y$ }; T8 K* a, P: I

void _stdcall DelMatrix(void *me)        //用于LockKey函数及InsertKey函数，使Lu能自动销毁myMatrix对象  @5 K; j\\" I  P  p% q7 _+ U

{+ k1 a& ^4 P: G4 D

delete (myMatrix *)me;- v5 o8 v4 R- g4 h8 k

} 
( \9 q) K) {' G\\" |
myMatrix * _stdcall NewMatrix(luVOID m,luVOID n)        //生成一个myMatrix对象4 t3 j# p+ @9 ]# y8 B+ P' P

{$ n. a6 ?0 H; u9 b% R( C6 x; }

myMatrix *pMatrix;$ Z5 C6 A- ?) A3 z8 B- `

luVOID k; 
9 `! p& [) G; F4 ^1 Q' q
        double *pa;1 R\\" [  y7 a; r3 F2 m  W: w

char keyname[sizeof(luVOID)]; 
& v  s5 p1 |- _4 N) U! s3 Z
        void *NowKey;7 C8 p0 b7 ?2 W5 e

k=m*n; 
( S2 g9 T% u+ X; w9 F4 o
        pMatrix=(myMatrix *)GetBufObj(Matrix,keyname);//先尝试从缓冲区中获取一个矩阵对象 
  y$ @; N( i\\" @; |6 Q; p
        if(pMatrix)& s. J# ]( d+ U* |2 j

{ 
\\" `; b) @! K- A
                if(pMatrix->ArrayLen!=k)        //重置矩阵的大小7 Q, Y6 r0 G! j, m0 h) {

{ 
! p+ X& g0 F/ L! l/ @
                        pa=new double[k]; 
' A8 V1 J, W: J\\" b
                        if(!pa) 
* e( S( `: M  x% Z( v
                        { 
. {% D, |' b; C) p
                                DeleteKey(keyname,sizeof(luVOID),Matrix,DelMatrix,1);        //将矩阵对象放回缓冲区 
3 P2 i+ m. y9 ]  g6 s3 G
                                return NULL;: x8 \2 t# L- b1 V

}% D5 S, U9 G4 {: h0 O* n

delete[] pMatrix->Array;9 z, E3 y( P! s& b3 ~

pMatrix->Array=pa; 
9 s% }2 @  g\\" f0 K
                } 
- Q& S3 \; ?/ y, \0 }. k
        } 
: ?) N/ U5 A\\" ?' a( f; P) u
        else 
/ P\\" ~  A0 W$ I7 l, D! m
        { 
7 H  f5 X4 b) E7 y
                pMatrix=new myMatrix;        //创建矩阵对象, d9 D: T9 f. o) l  K) j

if(!pMatrix) return NULL;5 w3 X0 K$ P5 w8 `( [# h

pMatrix->Array=new double[k];8 b: Q5 J& N8 @' a9 R6 a* ]

if(!pMatrix->Array) 
/ T  o3 ^\\" K! k# O$ q' l
                { 
1 }; q% _4 K; |2 r! I
                        delete pMatrix; 
- C% S! b# Q# r7 i3 u  |- g
                        return NULL;5 ^) ~$ c8 |' L2 Z\\" O9 N9 A

}3 o$ Z- }& o! H& m8 W: C

if(InsertKey((char *)&pMatrix,-1,Matrix,pMatrix,DelMatrix,NULL,0,NowKey))        //将矩阵对象注册到Lu* d. \# n- m7 U( j$ f6 d( O

{ 
3 Z\\" U3 @9 h\\" h  I$ N8 [/ d
                        delete pMatrix; 
- H. F. O0 Q% [8 j# C: b\\" }; Y
                        return NULL;' V. i$ g$ M9 Y

}3 `2 u. I\\" _% Z$ B

}4 \5 E. v( _+ g* c

pMatrix->ArrayLen=k; pMatrix->Dim[0]=m; pMatrix->Dim[1]=n; 
\\" g- M* b& l* T2 @1 v0 r
        return pMatrix; 
0 `- _0 E3 q# ~1 ^
}# ^+ w% q& m; ], \/ Y) ]2 L

LuData _stdcall OpMatrix(luINT mm,LuData *xx,void *hFor,int theOperator)        //运算符重载函数，用于LockKey函数 
2 z* T. L; D3 C: y! `$ J
{$ a6 ~: I4 v7 L, J

LuData a; 
: |7 l* T, S0 d5 A2 Q) U
        myMatrix *pMatrix1,*pMatrix2,*pMatrix3; 
4 H+ a; x4 h5 C
        luVOID i,j,k,m,n,u,v;  x# d- S8 a1 ^

double *pa,*pb,*pc; 
2 t( p! I. ^! b* N1 _
        luMessage pMessage; 
' O\\" D& R7 ~7 j: P\\" Y
        wchar_t wchNum[32];- L( J% F& m/ z$ K$ |3 J

char chNum[32]; 
; x  b* D8 ^$ S
        a.BType=luStaData_nil; a.VType=luStaData_nil; a.x=0;' ]; w) ~% q+ M. M/ `: p) @! s: ]

switch(theOperator)0 @% ]3 u' x8 p- E' l

{+ I6 f0 d7 W1 |

case 2:        //重载运算符* 
5 w. T: B1 n1 ~; n
                pMatrix1=(myMatrix *)SearchKey((char *)&(xx->x),sizeof(luVOID),Matrix); 
) L% o' b& k  b
                pMatrix2=(myMatrix *)SearchKey((char *)&((xx+1)->x),sizeof(luVOID),Matrix);  M) C, I$ D& h

if(!pMatrix1 || !pMatrix2) break;        //对象句柄无效，不是矩阵 
0 P4 X2 f4 J8 x& L1 c8 Y
                if(pMatrix1->Dim[1]!=pMatrix2->Dim[0]) break;        //维数不匹配7 n& |4 x4 h, N8 J6 `\\" b

pMatrix3=NewMatrix(pMatrix1->Dim[0],pMatrix2->Dim[1]);        //生成新矩阵4 M9 s$ w+ S! x

if(!pMatrix3) break;, N* g\\" b+ ?/ A

pa=pMatrix1->Array; pb=pMatrix2->Array; pc=pMatrix3->Array;# [  t: f1 i6 }

m=pMatrix1->Dim[0]; n=pMatrix1->Dim[1]; k=pMatrix2->Dim[1];. C. g, k4 a# F6 }

for(i=0; i<m; i++)        //矩阵乘/ e; H) y7 @/ @. \

{ 
/ v, H) g7 g* ?) a* m# z- v
                        for(j=0; j<k; j++)  S( X& W/ H3 \4 k+ \. @& `

{ 
# ]\\" t- Y' e6 W% J0 ^/ {
                                u=i*k+j; pc[u]=0.0;1 r4 ]( l\\" V% F

for (v=0; v<n; v++)2 a  j: t* V, I) A\\" i/ Q) G9 j

{5 `. M3 v( g% Y4 c! Z' u

pc[u]=pc[u]+pa[i*n+v]*pb[v*k+j]; 
7 h+ }- E, V7 H8 ]! b  \$ O
                                }! K) }6 H/ p6 o) |0 u4 b1 Y( m+ a* w

}: j6 ?* h; ^' c1 J0 ^

}: H% t. G7 u  d# Z

FunReObj(hFor);        //告诉Lu，返回一个动态对象4 P5 m3 t9 B: C\\" W$ ]! x

a.BType=Matrix; a.VType=Matrix; a.x=0; *(luVOID *)&(a.x)=(luVOID)pMatrix3;8 ]6 o7 T( d\\" D+ I/ N- K\\" \

break;+ a& \  C  D& l3 v\\" I

case 25:        //重载运算符.*8 b0 z. j, |+ }% @

pMatrix1=(myMatrix *)SearchKey((char *)&(xx->x),sizeof(luVOID),Matrix); 
9 }- w6 Q1 w\\" T5 E1 ~+ Q
                pMatrix2=(myMatrix *)SearchKey((char *)&((xx+1)->x),sizeof(luVOID),Matrix);: `& _; }. T+ M. K\\" M

if(!pMatrix1 || !pMatrix2) break;        //对象句柄无效，不是矩阵 
% H6 R+ ?: ^9 z: D# `! E
                if(pMatrix1->Dim[0]!=pMatrix2->Dim[0] || pMatrix1->Dim[1]!=pMatrix2->Dim[1]) break;        //维数不相同% _8 S5 ^7 L$ J) U- E; A/ a

pMatrix3=NewMatrix(pMatrix1->Dim[0],pMatrix1->Dim[1]);        //生成新矩阵 
6 }0 y8 N2 g/ P6 c
                if(!pMatrix3) break; 
0 V' y+ b9 u\\" L7 M/ R
                for(i=0;i<pMatrix1->ArrayLen;i++) pMatrix3->Array[i]=pMatrix1->Array[i]*pMatrix2->Array[i];        //矩阵点乘* m3 I  Z! [6 R7 G' ?

FunReObj(hFor);        //告诉Lu，返回一个动态对象\\" e6 J( z3 c& F/ F1 b

a.BType=Matrix; a.VType=Matrix; a.x=0; *(luVOID *)&(a.x)=(luVOID)pMatrix3;  K4 }! Y+ W% p4 t! R8 r7 z3 t6 m

break;' p; k* Z% T/ j

case 46:        //重载函数new! Q  C0 F% l  a- e- e$ O

if(mm<2) break; 
1 T' ?& g! X, V: X0 G; F% @
                if((xx+1)->x<1 || (xx+2)->x<1 || (xx+1)->BType!=luStaData_int64 || (xx+2)->BType!=luStaData_int64) break; 
) q, v1 Y3 \' i/ z! G7 V) m
                pMatrix3=NewMatrix((luVOID)(xx+1)->x,(luVOID)(xx+2)->x);//生成新矩阵 
2 w3 p$ P5 ^+ ?
                if(!pMatrix3) break;9 h* X* P  Z  p7 h

for(j=0,i=3;i<=mm;i++,j++)        //赋初值  l' q9 w5 V+ z- U

{ 
' y( y: a. c1 W2 I! ~
                        if(j>=pMatrix3->ArrayLen) break; 
3 S9 T' p# |& u; N+ N
                        if((xx+i)->BType!=luStaData_double) break;        //只接受实数参数: u9 ]: s$ i- @% M& P4 z

pMatrix3->Array[j]=*(double *)&((xx+i)->x);0 R) {6 g9 M0 U) I

} 
! K( K! w; R4 o- h
                FunReObj(hFor);        //告诉Lu，返回一个动态对象 
9 W2 Y\\" `5 v: i# ]* ?
                a.BType=Matrix; a.VType=Matrix; a.x=0; *(luVOID *)&(a.x)=(luVOID)pMatrix3;$ g3 X) m* a- T2 M1 L% t

break; 
5 d7 p$ p  |+ y3 D! H! X* ]
        case 49:        //重载函数o 
1 W\\" s2 K/ |\\" A# C* t& U3 j& g* F* y
                pMessage=(luMessage)SearchKey("\0\0\0\0",sizeof(luVOID),luPubKey_User); 
$ \1 C8 I# w8 {+ @8 F. p
                if(!pMessage) break;# C/ o2 T* G  D5 l8 g

pMatrix1=(myMatrix *)SearchKey((char *)&(xx->x),sizeof(luVOID),Matrix);, I: i5 V7 {: R, S3 j! t- T0 p  V$ v

if(!pMatrix1) break;        //对象句柄无效，不是矩阵3 [+ u4 o( s, V

pa=pMatrix1->Array; 
' b4 Y3 O* R/ B8 ^: H9 k
                m=pMatrix1->Dim[0]; n=pMatrix1->Dim[1]; k=0;( V- Q+ Z, ?2 i7 ^

for(i=0; i<m; i++)        //输出矩阵* O' y  _* a( Z. n- M

{# l. J. ?  V, s\\" Z

pMessage(L"\r\n"); k+=2;9 \6 G: y0 ?. F& O

for(j=0; j<n; j++) 
; ~, W* j. c; g! _5 P' |. b. \
                        {3 n# [1 U7 R2 i) |; B2 t; j  d

_gcvt_s(chNum,pa[i*n+j],16);6 Q5 r: q; I/ t0 U\\" Y' b

for(u=0;chNum[u];u++) {wchNum[u]=chNum[u]; k++;}/ Q\\" A, D& r2 d* t9 g4 ?, T3 j

wchNum[u]='\0';2 W/ M6 b4 m. r- q4 M  L

pMessage(wchNum); pMessage(L"  "); k+=2; 
7 @  w6 L& c2 ?\\" W/ ~
                        }3 z: x2 E6 E# ]7 f3 ~

} 
. I0 C7 b1 Q8 x% r6 K% j
                pMessage(L"\r\n"); k+=2;5 a8 s3 M# M4 Z8 X/ c- K

a.BType=luStaData_int64; a.VType=luStaData_int64; a.x=k;        //按函数o的要求，返回输出的字符总数4 A! {6 @& O9 }\\" i& c

break; 
0 b- B$ k! j+ z
        default: 
  Y* b) \0 O0 z% R1 X
                break;& t# ^) w( L/ `$ n$ @3 b8 }; }2 O

}. M3 g. I3 I: t3 T5 d, o\\" J6 H* S

return a; 
$ i, y  ]) ]6 S4 _% [
}- O7 n& ~7 g0 B8 F5 ~8 e5 |

void main(void) 
9 E3 h/ T' z3 c7 y  M# [8 O# {
{ 
/ ?: S* o' n$ b! C( \/ s1 {
        void *hFor;                //表达式句柄 
$ v- Y! ~6 w8 n6 `2 G
        luINT nPara;                //存放表达式的自变量个数, b! N0 F6 k5 P  E7 R& p

LuData *pPara;                //存放输入自变量的数组指针- U! N4 k$ G+ j( z! T

luINT ErrBegin,ErrEnd;        //表达式编译出错的初始位置和结束位置3 Q& s6 H# O$ y( i% l

int ErrCode;                //错误代码7 [8 X$ @! H. ^/ o% f4 L/ h( y- s

void *v; 
$ K3 M9 I1 z3 ~
        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.]}";//字符串表达式，矩阵乘* X' C& a9 u% l9 X1 t( U! B% W

//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.]}";//字符串表达式，矩阵点乘 
6 D3 ~% Q+ _( R, ~# W
        LuData Val; 
6 ?$ U( R' C: t& Z4 [, e0 C: a/ X
        if(!InitLu()) return;        //初始化Lu; B  v: Z/ J9 A\\" v5 c! s+ h& R* g1 J) c: V

while(LockKey(Matrix,DelMatrix,OpMatrix)){Matrix--;}        //锁定一个键，用于存储矩阵扩展类型 
. |, d  Q3 p# _# T+ y1 E
 
& C1 \( H2 E# Q8 |7 D
        Val.BType=luStaData_int64; Val.VType=luStaData_int64; Val.x=Matrix;        //定义整数常量9 j2 K/ t! i, V* d: V0 y  v% T! @: h

SetConst(L"matrix",&Val);        //设置整数常量 
/ \( J7 a) |2 I' ?- ?% R/ L; i
        InsertKey("\0\0\0\0",4,luPubKey_User,LuMessage,NULL,NULL,1,v); //使Lu运行时可输出函数信息 
. ~, `$ s) r+ d6 a# W8 [
        wcout.imbue(locale("chs"));        //设置输出的locale为中文 
$ R( @; Q7 |8 e/ g1 C8 q
   
0 O4 u' l1 {0 `
        ErrCode=LuCom(ForStr,0,0,0,hFor,nPara,pPara,ErrBegin,ErrEnd); //编译表达式' w0 E- K& d8 t9 @

if(ErrCode) 
# X( r% X\\" [9 k) J. r2 I- V1 X
        { 
. \5 L$ J. H3 ?% I* U7 v) u6 m
                wcout<<L"表达式有错误！错误代码："<<ErrCode<<endl;9 Z8 N5 J( b  Y- o9 [

} 
3 Y2 h/ z- S/ `; @8 j/ ?
        else4 G! t, x6 D8 r

{ 
& i# z9 m- ~3 z4 c2 u. z- _$ f
                LuCal(hFor,pPara);        //计算表达式的值* n6 Q9 N3 a; N! C( g  E3 u+ y! V

} 
3 s! Y$ m' O4 }1 y( P\\" h) s
        LockKey(Matrix,NULL,OpMatrix);//解锁键Matrix，本例中，该函数可以不用 
2 H3 F+ ~+ _+ K$ G+ b( y
        FreeLu();                        //释放Lu# p% p' {% @) _# ^- C  I  V0 d

}

习题：

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

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

main(:a,b,c,d,t,i)=
: r$ f\" o- q* n5 Y! O5 J. y/ Z
a=new[matrix,2,2: 1.,2.,2.,1.],0 h) t' Y0 ^! x8 Y% o% e
b=new[matrix,2,2: 2.,1.,1.,2.],
8 w3 I- p9 k$ E# f. [2 s+ q% S( F
c=new[matrix,2,2: 2/3.,-1/3.,-1/3.,2/3.],\" R8 s; S( k; T! ]
t=clock(), L. r. q% _8 C' K. g
d=a*b, i=0, while{i<1000000, d=d*c*b, i++},
& W; B9 N% D5 W- Y b; V
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\"}";//字符串表达式

复制代码

结果：