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

查看: 8460|回复: 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>
\\" ]5 M1 S+ z- s& d4 W
#include <iostream>1 W5 b9 p8 u% q
#include <math.h>6 W) g7 J$ w1 y3 s0 p5 v
#include "lu32.h"0 {\\" y2 a+ U6 h$ L
#pragma comment( lib, "lu32.lib" )! P\\" W& Q! ?6 L' V& l2 I
using namespace std;
* d2 J9 B' z' J
//自定义矩阵
3 S0 l- q9 i/ h6 K\\" I* _
class myMatrix
3 q M6 I I/ h+ j# U9 o2 w/ k
{
3 e$ u9 ~2 j/ j3 I7 T& M
public:
1 Z8 ]5 N! k( D9 R$ V
double *Array; //数据缓冲区
\\" q o7 n8 p. K* y
luVOID ArrayLen; //数据缓冲区长度
# B( g0 I) ?! ^
luVOID Dim[2]; //矩阵维数9 l& u9 J& ?9 |' l! \2 R* B
myMatrix(){Array=NULL; ArrayLen=0; Dim[0]=0; Dim[1]=0;}
! t0 ~6 o' v0 ~% E0 X) Y9 N) F
~myMatrix()1 o( c+ z; ?3 Z2 y
{) B1 V0 A; W* }7 R2 {* B
if(Array) delete[] Array;' z5 L: c6 C\\" O$ o5 L; n; f
}2 R, Y5 K3 D5 L4 a
};& |' N0 |. t5 y8 X
luKEY Matrix=-1000; //标识矩阵类型，最终的Matrix由LockKey决定
( f- D1 p) b1 b) j
void _stdcall LuMessage(wchar_t *pch)//输出动态库信息，该函数注册到Lu，由Lu二级函数调用
3 a1 L, m& ?\\" W3 v! [7 r! d0 I4 D, E
{
7 V! X+ E4 f7 l9 a: b& r# J
wcout<<pch;6 y- n# G- V% e0 l
}1 U5 |0 ^5 z/ ^6 K; W4 \8 n0 s+ t) T
void _stdcall DelMatrix(void *me) //用于LockKey函数及InsertKey函数，使Lu能自动销毁myMatrix对象
' i, N9 w; R3 M+ U/ i% Z
{
- X: b% q, p9 _7 W8 Z/ @) \! ~+ \/ n
delete (myMatrix *)me;
# B- A3 d4 s3 q
}
: \! J; Z( q6 a0 f% U2 U
myMatrix * _stdcall NewMatrix(luVOID m,luVOID n) //生成一个myMatrix对象
. h1 l+ _# h/ ]9 ]* T% a9 P6 i
{, M; t, o( r: C
myMatrix *pMatrix;4 ^9 x3 F4 f; r: s9 J
luVOID k;
! h% p) z& ^5 h! {1 I6 b1 C K
double *pa;
, Y3 ?6 a7 J$ V8 F- z9 L
char keyname[sizeof(luVOID)];
& X9 I) ]! }; p; c: |0 \; U3 y3 }
void *NowKey;
' y8 s) t' I' f8 k( Z8 b* ?& g
k=m*n;
: { G! W2 G P- Q- @
pMatrix=(myMatrix *)GetBufObj(Matrix,keyname);//先尝试从缓冲区中获取一个矩阵对象; Q/ T5 E/ E7 U. Y$ c
if(pMatrix)7 u0 ^' i* ]! o2 F. I
{
& u( A, H\\" p! H3 W
if(pMatrix->ArrayLen!=k) //重置矩阵的大小\\" z i ]9 J, O# {\\" ~
{ H0 V( n( I; {, y0 j7 n
pa=new double[k];
) e8 a8 q0 G! ?+ a- N% f4 ~. A
if(!pa)* U5 A9 e9 |8 v- E2 V
{
3 z, i; W\\" o3 v/ F# ]; R. [8 x8 U
DeleteKey(keyname,sizeof(luVOID),Matrix,DelMatrix,1); //将矩阵对象放回缓冲区
U- m7 O0 t7 |4 p
return NULL;6 i3 h+ e: d* b( |4 F' v: s+ P& N5 L
}
* E7 ?8 q0 v3 l
delete[] pMatrix->Array;9 H2 X/ Q; K- M& J; q
pMatrix->Array=pa;
* p) ]4 u) _* R! T- t
}; W$ F1 U6 z: u- j; r
}- @; l& y' |. C. r& c8 s/ X% u6 F
else
1 x7 N3 |, Z\\" `3 p0 O
{
\\" _/ K% h2 \ _8 B Y
pMatrix=new myMatrix; //创建矩阵对象
7 c1 z3 N- q$ V* m
if(!pMatrix) return NULL;6 F9 K7 Z1 j1 s q, _- _
pMatrix->Array=new double[k];% y: y. @2 A3 ], V
if(!pMatrix->Array)
; h# H- k, N/ S6 K1 v
{$ r. S\\" D8 n4 w: A- z1 L. k6 A; d' r
delete pMatrix;9 o0 N7 ^2 p* }, B- F/ r
return NULL;9 E8 }3 `1 V0 p: Z0 h\\" e! L
}
$ e% p( r' L( E3 r0 ~
if(InsertKey((char *)&pMatrix,-1,Matrix,pMatrix,DelMatrix,NULL,0,NowKey)) //将矩阵对象注册到Lu( q8 Y; P7 u4 T9 e2 u0 v) k+ V
{7 [4 Y! |, w4 t+ D
delete pMatrix;
$ D! x4 C1 k4 ^8 |$ n
return NULL;
8 e. G e2 Y0 g8 t& c0 ^. J ^& ~
}
# d, S, f/ B) r ?1 \
}
7 ~ R& w- x* a* G0 i' \1 Q
pMatrix->ArrayLen=k; pMatrix->Dim[0]=m; pMatrix->Dim[1]=n;: F5 Y+ v) B( z) S5 H
return pMatrix;
* n7 S) I- V0 ^' V# ?# T' B
}
5 J0 M) A0 f! S/ s
LuData _stdcall OpMatrix(luINT mm,LuData *xx,void *hFor,int theOperator) //运算符重载函数，用于LockKey函数. l1 k1 k, U0 X+ r: h, Y$ T* _\\" [
{* B0 e; n& a4 c
LuData a;! i! a! T3 f% k( v
myMatrix *pMatrix1,*pMatrix2,*pMatrix3;( F8 l7 k, O+ Y
luVOID i,j,k,m,n,u,v;
2 R Q C Q2 L% a0 b6 l: o
double *pa,*pb,*pc;( j' h) k+ s% J. z\\" ?2 u; K# H
luMessage pMessage;# @7 x) k7 ~4 [/ ? n
wchar_t wchNum[32];3 U9 s( \( i# e4 S1 u c$ T
char chNum[32];8 F) r/ H. z/ |$ g- L
a.BType=luStaData_nil; a.VType=luStaData_nil; a.x=0;
% R5 q3 k) p3 q# N8 a
switch(theOperator)
8 a6 F$ ~. i0 L9 |+ [* X# I; i( p8 q3 y
{% U8 k/ c# m; N
case 2: //重载运算符*
1 Q, Z+ } n6 Y9 C( {/ m
pMatrix1=(myMatrix *)SearchKey((char *)&(xx->x),sizeof(luVOID),Matrix);: F7 ?# F* A& ]! T+ T$ D& i3 P8 t
pMatrix2=(myMatrix *)SearchKey((char *)&((xx+1)->x),sizeof(luVOID),Matrix);! v2 @. m2 V* [: w3 n\\" A
if(!pMatrix1 || !pMatrix2) break; //对象句柄无效，不是矩阵
* O! r2 h8 V$ S0 o+ j\\" X Q
if(pMatrix1->Dim[1]!=pMatrix2->Dim[0]) break; //维数不匹配
& s; U! m7 D1 j4 g2 E' a
pMatrix3=NewMatrix(pMatrix1->Dim[0],pMatrix2->Dim[1]); //生成新矩阵
Z( \2 [1 L/ c/ X& R
if(!pMatrix3) break;
# G$ [% j2 |( I, t& Y4 k: r
pa=pMatrix1->Array; pb=pMatrix2->Array; pc=pMatrix3->Array;
9 {) i9 e& Y1 e: F, |
m=pMatrix1->Dim[0]; n=pMatrix1->Dim[1]; k=pMatrix2->Dim[1];
3 E! G0 p+ D- `+ |/ r2 H8 w
for(i=0; i<m; i++) //矩阵乘
* O9 i\\" ]\\" t( i% z; R1 C\\" v
{0 p2 z- G/ K: T1 t! z' U; G9 Y. N
for(j=0; j<k; j++)0 J4 W7 ]/ r& N! d
{6 l' r- a3 L5 C. J# S
u=i*k+j; pc[u]=0.0;/ p8 Y# [' c* l) A5 b( @
for (v=0; v<n; v++)
8 L/ V3 @6 ^6 x- E
{0 e$ {/ b# n) b- K
pc[u]=pc[u]+pa[i*n+v]*pb[v*k+j];% c% U, g W( d5 X4 q$ s7 ~
}
; }& h0 Y5 e5 G, T# R7 O9 u5 y
}, x. O+ V6 B; _/ w3 V7 M
}& H6 S; d* A0 m6 W
FunReObj(hFor); //告诉Lu，返回一个动态对象
' m, T) Z, W4 b3 A3 U
a.BType=Matrix; a.VType=Matrix; a.x=0; *(luVOID *)&(a.x)=(luVOID)pMatrix3;) W, z+ S5 Y8 C1 {- o0 X
break;
3 f0 ?* R+ G/ [1 p
case 25: //重载运算符.*
: V# o+ K6 ^: r$ t0 n
pMatrix1=(myMatrix *)SearchKey((char *)&(xx->x),sizeof(luVOID),Matrix);- M, P1 W, x V' `% G5 V
pMatrix2=(myMatrix *)SearchKey((char *)&((xx+1)->x),sizeof(luVOID),Matrix);
\\" n4 }6 Q' u$ }7 A
if(!pMatrix1 || !pMatrix2) break; //对象句柄无效，不是矩阵
9 x2 V- Q4 D8 o
if(pMatrix1->Dim[0]!=pMatrix2->Dim[0] || pMatrix1->Dim[1]!=pMatrix2->Dim[1]) break; //维数不相同8 d) c8 {8 [, h0 a; c1 V
pMatrix3=NewMatrix(pMatrix1->Dim[0],pMatrix1->Dim[1]); //生成新矩阵+ q8 i5 t4 L, J/ @
if(!pMatrix3) break;2 O0 M% s6 ~) @, ?8 l
for(i=0;i<pMatrix1->ArrayLen;i++) pMatrix3->Array[i]=pMatrix1->Array[i]*pMatrix2->Array[i]; //矩阵点乘- H& a# i/ f f* f; x9 n: p7 m
FunReObj(hFor); //告诉Lu，返回一个动态对象' A+ z( u4 E( X1 [% Z% k& {, ]
a.BType=Matrix; a.VType=Matrix; a.x=0; *(luVOID *)&(a.x)=(luVOID)pMatrix3;
0 S\\" H2 K/ ?# [9 x
break;
6 ~' N3 u* t9 e) {0 a* B: V
case 46: //重载函数new6 Q( s# Z+ S' n: C8 }
if(mm<2) break;
. _) A: Q4 ?7 c5 O! j. o) U
if((xx+1)->x<1 || (xx+2)->x<1 || (xx+1)->BType!=luStaData_int64 || (xx+2)->BType!=luStaData_int64) break;
$ ^. ~# L. p! V; W# R, L( A M
pMatrix3=NewMatrix((luVOID)(xx+1)->x,(luVOID)(xx+2)->x);//生成新矩阵7 p3 A4 `) u6 N; B$ e, s, D# W
if(!pMatrix3) break;
2 T8 Z' |0 h4 a) q7 ? a- q7 K/ J
for(j=0,i=3;i<=mm;i++,j++) //赋初值
) ?' g* p\\" b( { P( }2 i
{- l: G3 m0 ^, n; A
if(j>=pMatrix3->ArrayLen) break;% t3 V, @; L: b- [7 I, R( H( ?
if((xx+i)->BType!=luStaData_double) break; //只接受实数参数) S; F3 z4 e- y. A/ Q\\" ]
pMatrix3->Array[j]=*(double *)&((xx+i)->x);' Y% Z i- n9 K2 }- ~. l. ~- q4 M
}$ o0 W0 y\\" I/ S0 G5 Y- O0 j
FunReObj(hFor); //告诉Lu，返回一个动态对象
6 l0 f& N, T( j; n7 ?2 d. h
a.BType=Matrix; a.VType=Matrix; a.x=0; *(luVOID *)&(a.x)=(luVOID)pMatrix3;
$ r2 d! w, R- m2 v
break;
' l& Y+ O- c8 N
case 49: //重载函数o
& t/ V4 Q. x5 T
pMessage=(luMessage)SearchKey("\0\0\0\0",sizeof(luVOID),luPubKey_User);9 d2 V' t5 |$ M& X2 z% r
if(!pMessage) break;7 I) k7 d! [0 }+ W
pMatrix1=(myMatrix *)SearchKey((char *)&(xx->x),sizeof(luVOID),Matrix);. t- S3 v% k4 H) X
if(!pMatrix1) break; //对象句柄无效，不是矩阵, ?) t( T- d4 M- D( s+ y+ x
pa=pMatrix1->Array;+ I, ?1 V$ g8 w. F1 S/ J
m=pMatrix1->Dim[0]; n=pMatrix1->Dim[1]; k=0;+ _4 [2 J' M0 t& [ N
for(i=0; i<m; i++) //输出矩阵2 y+ f' D4 X( D& {/ S\\" V
{+ N9 t2 N) v, b: f+ c! o) f7 W, o
pMessage(L"\r\n"); k+=2;
7 j1 ^+ R\\" g5 R, B: D1 @3 I- E
for(j=0; j<n; j++)0 c6 I1 \1 I+ D* m/ j\\" _3 G
{
5 l6 E5 B: h8 \( ~, p
_gcvt_s(chNum,pa[i*n+j],16);
1 C4 u# Y/ [2 T3 r
for(u=0;chNum[u];u++) {wchNum[u]=chNum[u]; k++;}' i, A: a+ }\\" V4 j3 J- i1 C8 e
wchNum[u]='\0';
8 V$ f0 d6 t, Y
pMessage(wchNum); pMessage(L" "); k+=2;( F( o/ q9 m% @& @3 v0 e- \8 H
}/ h, e( L% J7 g& A8 B: d0 L, H
}* e1 @& k6 i d
pMessage(L"\r\n"); k+=2;7 b4 G. R( a! j
a.BType=luStaData_int64; a.VType=luStaData_int64; a.x=k; //按函数o的要求，返回输出的字符总数1 {2 ^\\" X4 V2 ]) H
break;3 f! r7 E6 F$ U* a' R: x% L
default:\\" R; z5 q* t+ W5 w
break;1 n2 R$ q( n9 Y, X+ h5 Y
}
5 V6 S6 q1 s5 C
return a;
\\" m6 g, [7 \, I4 V% \3 V
}) Q& x x) t8 S, T5 b& Y: n
void main(void)/ ~6 J2 j4 e9 S0 _0 d7 s
{
( U8 I( v\\" }( d; M! i) @
void *hFor; //表达式句柄
9 U+ G* V2 ^7 \& A5 {! _
luINT nPara; //存放表达式的自变量个数
' Y8 |5 W! @* F8 w
LuData *pPara; //存放输入自变量的数组指针6 b( o6 q7 k* v! ?7 J\\" U) I; l
luINT ErrBegin,ErrEnd; //表达式编译出错的初始位置和结束位置
8 n4 s, G1 `& s\\" o' ]# r
int ErrCode; //错误代码
/ J3 }4 M6 l3 @; g6 V/ x9 v
void *v;
% m( L, K/ \\\" {0 Q
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.]}";//字符串表达式，矩阵乘
! m0 l/ ? y( ]3 ^
//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.]}";//字符串表达式，矩阵点乘$ t2 Z4 K8 Z( N1 F- @( G, e\\" q
LuData Val;
5 z9 E! ~* P! r' B! N
if(!InitLu()) return; //初始化Lu
9 k% c9 l! Y* j' G4 @2 `
while(LockKey(Matrix,DelMatrix,OpMatrix)){Matrix--;} //锁定一个键，用于存储矩阵扩展类型
E1 B9 j/ D' [) r5 m1 V9 y) u. H
9 [9 }8 s: k; r
Val.BType=luStaData_int64; Val.VType=luStaData_int64; Val.x=Matrix; //定义整数常量* v4 C1 E8 V8 h8 ^ O
SetConst(L"matrix",&Val); //设置整数常量4 Q; L. s3 n; r8 c+ l\\" I
InsertKey("\0\0\0\0",4,luPubKey_User,LuMessage,NULL,NULL,1,v); //使Lu运行时可输出函数信息
- \* n# F' {8 D
wcout.imbue(locale("chs")); //设置输出的locale为中文* S- I: ^% @5 O) e0 p& _
. u4 ?3 f% n, {/ m* z
ErrCode=LuCom(ForStr,0,0,0,hFor,nPara,pPara,ErrBegin,ErrEnd); //编译表达式! O, b N\\" u4 q! A+ ~ e
if(ErrCode)
: b% f6 W\\" n' ^5 {/ Z6 o! t\\" C% B
{2 A\\" }% A\\" X T: p! _' @
wcout<<L"表达式有错误！错误代码："<<ErrCode<<endl;
6 J- z- C\\" K$ O4 a+ ^# c
}8 X ^- i4 a- ?/ s7 O2 f1 f/ a/ `
else& U6 w8 p2 k8 g+ l+ n, m
{
7 b( b& N. c; u. ^( C6 w
LuCal(hFor,pPara); //计算表达式的值6 p; D$ J2 A4 D, i
}
2 d6 d; }& p' `) P% {( ~8 `
LockKey(Matrix,NULL,OpMatrix);//解锁键Matrix，本例中，该函数可以不用
^* Q) H& |8 E9 ^1 _
FreeLu(); //释放Lu1 w) d1 j* X9 T* ]4 s
}

#include <windows.h> 
\\" ]5 M1 S+ z- s& d4 W
#include <iostream>1 W5 b9 p8 u% q

#include <math.h>6 W) g7 J$ w1 y3 s0 p5 v

#include "lu32.h"0 {\\" y2 a+ U6 h$ L

#pragma comment( lib, "lu32.lib" )! P\\" W& Q! ?6 L' V& l2 I

using namespace std; 
* d2 J9 B' z' J
//自定义矩阵 
3 S0 l- q9 i/ h6 K\\" I* _
class myMatrix 
3 q  M6 I  I/ h+ j# U9 o2 w/ k
{ 
3 e$ u9 ~2 j/ j3 I7 T& M
public: 
1 Z8 ]5 N! k( D9 R$ V
        double *Array;        //数据缓冲区 
\\" q  o7 n8 p. K* y
        luVOID ArrayLen;        //数据缓冲区长度 
# B( g0 I) ?! ^
        luVOID Dim[2];        //矩阵维数9 l& u9 J& ?9 |' l! \2 R* B

myMatrix(){Array=NULL; ArrayLen=0; Dim[0]=0; Dim[1]=0;} 
! t0 ~6 o' v0 ~% E0 X) Y9 N) F
        ~myMatrix()1 o( c+ z; ?3 Z2 y

{) B1 V0 A; W* }7 R2 {* B

if(Array) delete[] Array;' z5 L: c6 C\\" O$ o5 L; n; f

}2 R, Y5 K3 D5 L4 a

};& |' N0 |. t5 y8 X

luKEY Matrix=-1000;        //标识矩阵类型，最终的Matrix由LockKey决定 
( f- D1 p) b1 b) j
void _stdcall LuMessage(wchar_t *pch)//输出动态库信息，该函数注册到Lu，由Lu二级函数调用 
3 a1 L, m& ?\\" W3 v! [7 r! d0 I4 D, E
{ 
7 V! X+ E4 f7 l9 a: b& r# J
        wcout<<pch;6 y- n# G- V% e0 l

}1 U5 |0 ^5 z/ ^6 K; W4 \8 n0 s+ t) T

void _stdcall DelMatrix(void *me)        //用于LockKey函数及InsertKey函数，使Lu能自动销毁myMatrix对象 
' i, N9 w; R3 M+ U/ i% Z
{ 
- X: b% q, p9 _7 W8 Z/ @) \! ~+ \/ n
        delete (myMatrix *)me; 
# B- A3 d4 s3 q
} 
: \! J; Z( q6 a0 f% U2 U
myMatrix * _stdcall NewMatrix(luVOID m,luVOID n)        //生成一个myMatrix对象 
. h1 l+ _# h/ ]9 ]* T% a9 P6 i
{, M; t, o( r: C

myMatrix *pMatrix;4 ^9 x3 F4 f; r: s9 J

luVOID k; 
! h% p) z& ^5 h! {1 I6 b1 C  K
        double *pa; 
, Y3 ?6 a7 J$ V8 F- z9 L
        char keyname[sizeof(luVOID)]; 
& X9 I) ]! }; p; c: |0 \; U3 y3 }
        void *NowKey; 
' y8 s) t' I' f8 k( Z8 b* ?& g
        k=m*n; 
: {  G! W2 G  P- Q- @
        pMatrix=(myMatrix *)GetBufObj(Matrix,keyname);//先尝试从缓冲区中获取一个矩阵对象; Q/ T5 E/ E7 U. Y$ c

if(pMatrix)7 u0 ^' i* ]! o2 F. I

{ 
& u( A, H\\" p! H3 W
                if(pMatrix->ArrayLen!=k)        //重置矩阵的大小\\" z  i  ]9 J, O# {\\" ~

{  H0 V( n( I; {, y0 j7 n

pa=new double[k]; 
) e8 a8 q0 G! ?+ a- N% f4 ~. A
                        if(!pa)* U5 A9 e9 |8 v- E2 V

{ 
3 z, i; W\\" o3 v/ F# ]; R. [8 x8 U
                                DeleteKey(keyname,sizeof(luVOID),Matrix,DelMatrix,1);        //将矩阵对象放回缓冲区 
  U- m7 O0 t7 |4 p
                                return NULL;6 i3 h+ e: d* b( |4 F' v: s+ P& N5 L

} 
* E7 ?8 q0 v3 l
                        delete[] pMatrix->Array;9 H2 X/ Q; K- M& J; q

pMatrix->Array=pa; 
* p) ]4 u) _* R! T- t
                }; W$ F1 U6 z: u- j; r

}- @; l& y' |. C. r& c8 s/ X% u6 F

else 
1 x7 N3 |, Z\\" `3 p0 O
        { 
\\" _/ K% h2 \  _8 B  Y
                pMatrix=new myMatrix;        //创建矩阵对象 
7 c1 z3 N- q$ V* m
                if(!pMatrix) return NULL;6 F9 K7 Z1 j1 s  q, _- _

pMatrix->Array=new double[k];% y: y. @2 A3 ], V

if(!pMatrix->Array) 
; h# H- k, N/ S6 K1 v
                {$ r. S\\" D8 n4 w: A- z1 L. k6 A; d' r

delete pMatrix;9 o0 N7 ^2 p* }, B- F/ r

return NULL;9 E8 }3 `1 V0 p: Z0 h\\" e! L

} 
$ e% p( r' L( E3 r0 ~
                if(InsertKey((char *)&pMatrix,-1,Matrix,pMatrix,DelMatrix,NULL,0,NowKey))        //将矩阵对象注册到Lu( q8 Y; P7 u4 T9 e2 u0 v) k+ V

{7 [4 Y! |, w4 t+ D

delete pMatrix; 
$ D! x4 C1 k4 ^8 |$ n
                        return NULL; 
8 e. G  e2 Y0 g8 t& c0 ^. J  ^& ~
                } 
# d, S, f/ B) r  ?1 \
        } 
7 ~  R& w- x* a* G0 i' \1 Q
        pMatrix->ArrayLen=k; pMatrix->Dim[0]=m; pMatrix->Dim[1]=n;: F5 Y+ v) B( z) S5 H

return pMatrix; 
* n7 S) I- V0 ^' V# ?# T' B
} 
5 J0 M) A0 f! S/ s
LuData _stdcall OpMatrix(luINT mm,LuData *xx,void *hFor,int theOperator)        //运算符重载函数，用于LockKey函数. l1 k1 k, U0 X+ r: h, Y$ T* _\\" [

{* B0 e; n& a4 c

LuData a;! i! a! T3 f% k( v

myMatrix *pMatrix1,*pMatrix2,*pMatrix3;( F8 l7 k, O+ Y

luVOID i,j,k,m,n,u,v; 
2 R  Q  C  Q2 L% a0 b6 l: o
        double *pa,*pb,*pc;( j' h) k+ s% J. z\\" ?2 u; K# H

luMessage pMessage;# @7 x) k7 ~4 [/ ?  n

wchar_t wchNum[32];3 U9 s( \( i# e4 S1 u  c$ T

char chNum[32];8 F) r/ H. z/ |$ g- L

a.BType=luStaData_nil; a.VType=luStaData_nil; a.x=0; 
% R5 q3 k) p3 q# N8 a
        switch(theOperator) 
8 a6 F$ ~. i0 L9 |+ [* X# I; i( p8 q3 y
        {% U8 k/ c# m; N

case 2:        //重载运算符* 
1 Q, Z+ }  n6 Y9 C( {/ m
                pMatrix1=(myMatrix *)SearchKey((char *)&(xx->x),sizeof(luVOID),Matrix);: F7 ?# F* A& ]! T+ T$ D& i3 P8 t

pMatrix2=(myMatrix *)SearchKey((char *)&((xx+1)->x),sizeof(luVOID),Matrix);! v2 @. m2 V* [: w3 n\\" A

if(!pMatrix1 || !pMatrix2) break;        //对象句柄无效，不是矩阵 
* O! r2 h8 V$ S0 o+ j\\" X  Q
                if(pMatrix1->Dim[1]!=pMatrix2->Dim[0]) break;        //维数不匹配 
& s; U! m7 D1 j4 g2 E' a
                pMatrix3=NewMatrix(pMatrix1->Dim[0],pMatrix2->Dim[1]);        //生成新矩阵 
  Z( \2 [1 L/ c/ X& R
                if(!pMatrix3) break; 
# G$ [% j2 |( I, t& Y4 k: r
                pa=pMatrix1->Array; pb=pMatrix2->Array; pc=pMatrix3->Array; 
9 {) i9 e& Y1 e: F, |
                m=pMatrix1->Dim[0]; n=pMatrix1->Dim[1]; k=pMatrix2->Dim[1]; 
3 E! G0 p+ D- `+ |/ r2 H8 w
                for(i=0; i<m; i++)        //矩阵乘 
* O9 i\\" ]\\" t( i% z; R1 C\\" v
                {0 p2 z- G/ K: T1 t! z' U; G9 Y. N

for(j=0; j<k; j++)0 J4 W7 ]/ r& N! d

{6 l' r- a3 L5 C. J# S

u=i*k+j; pc[u]=0.0;/ p8 Y# [' c* l) A5 b( @

for (v=0; v<n; v++) 
8 L/ V3 @6 ^6 x- E
                                {0 e$ {/ b# n) b- K

pc[u]=pc[u]+pa[i*n+v]*pb[v*k+j];% c% U, g  W( d5 X4 q$ s7 ~

} 
; }& h0 Y5 e5 G, T# R7 O9 u5 y
                        }, x. O+ V6 B; _/ w3 V7 M

}& H6 S; d* A0 m6 W

FunReObj(hFor);        //告诉Lu，返回一个动态对象 
' m, T) Z, W4 b3 A3 U
                a.BType=Matrix; a.VType=Matrix; a.x=0; *(luVOID *)&(a.x)=(luVOID)pMatrix3;) W, z+ S5 Y8 C1 {- o0 X

break; 
3 f0 ?* R+ G/ [1 p
        case 25:        //重载运算符.* 
: V# o+ K6 ^: r$ t0 n
                pMatrix1=(myMatrix *)SearchKey((char *)&(xx->x),sizeof(luVOID),Matrix);- M, P1 W, x  V' `% G5 V

pMatrix2=(myMatrix *)SearchKey((char *)&((xx+1)->x),sizeof(luVOID),Matrix); 
\\" n4 }6 Q' u$ }7 A
                if(!pMatrix1 || !pMatrix2) break;        //对象句柄无效，不是矩阵 
9 x2 V- Q4 D8 o
                if(pMatrix1->Dim[0]!=pMatrix2->Dim[0] || pMatrix1->Dim[1]!=pMatrix2->Dim[1]) break;        //维数不相同8 d) c8 {8 [, h0 a; c1 V

pMatrix3=NewMatrix(pMatrix1->Dim[0],pMatrix1->Dim[1]);        //生成新矩阵+ q8 i5 t4 L, J/ @

if(!pMatrix3) break;2 O0 M% s6 ~) @, ?8 l

for(i=0;i<pMatrix1->ArrayLen;i++) pMatrix3->Array[i]=pMatrix1->Array[i]*pMatrix2->Array[i];        //矩阵点乘- H& a# i/ f  f* f; x9 n: p7 m

FunReObj(hFor);        //告诉Lu，返回一个动态对象' A+ z( u4 E( X1 [% Z% k& {, ]

a.BType=Matrix; a.VType=Matrix; a.x=0; *(luVOID *)&(a.x)=(luVOID)pMatrix3; 
0 S\\" H2 K/ ?# [9 x
                break; 
6 ~' N3 u* t9 e) {0 a* B: V
        case 46:        //重载函数new6 Q( s# Z+ S' n: C8 }

if(mm<2) break; 
. _) A: Q4 ?7 c5 O! j. o) U
                if((xx+1)->x<1 || (xx+2)->x<1 || (xx+1)->BType!=luStaData_int64 || (xx+2)->BType!=luStaData_int64) break; 
$ ^. ~# L. p! V; W# R, L( A  M
                pMatrix3=NewMatrix((luVOID)(xx+1)->x,(luVOID)(xx+2)->x);//生成新矩阵7 p3 A4 `) u6 N; B$ e, s, D# W

if(!pMatrix3) break; 
2 T8 Z' |0 h4 a) q7 ?  a- q7 K/ J
                for(j=0,i=3;i<=mm;i++,j++)        //赋初值 
) ?' g* p\\" b( {  P( }2 i
                {- l: G3 m0 ^, n; A

if(j>=pMatrix3->ArrayLen) break;% t3 V, @; L: b- [7 I, R( H( ?

if((xx+i)->BType!=luStaData_double) break;        //只接受实数参数) S; F3 z4 e- y. A/ Q\\" ]

pMatrix3->Array[j]=*(double *)&((xx+i)->x);' Y% Z  i- n9 K2 }- ~. l. ~- q4 M

}$ o0 W0 y\\" I/ S0 G5 Y- O0 j

FunReObj(hFor);        //告诉Lu，返回一个动态对象 
6 l0 f& N, T( j; n7 ?2 d. h
                a.BType=Matrix; a.VType=Matrix; a.x=0; *(luVOID *)&(a.x)=(luVOID)pMatrix3; 
$ r2 d! w, R- m2 v
                break; 
' l& Y+ O- c8 N
        case 49:        //重载函数o 
& t/ V4 Q. x5 T
                pMessage=(luMessage)SearchKey("\0\0\0\0",sizeof(luVOID),luPubKey_User);9 d2 V' t5 |$ M& X2 z% r

if(!pMessage) break;7 I) k7 d! [0 }+ W

pMatrix1=(myMatrix *)SearchKey((char *)&(xx->x),sizeof(luVOID),Matrix);. t- S3 v% k4 H) X

if(!pMatrix1) break;        //对象句柄无效，不是矩阵, ?) t( T- d4 M- D( s+ y+ x

pa=pMatrix1->Array;+ I, ?1 V$ g8 w. F1 S/ J

m=pMatrix1->Dim[0]; n=pMatrix1->Dim[1]; k=0;+ _4 [2 J' M0 t& [  N

for(i=0; i<m; i++)        //输出矩阵2 y+ f' D4 X( D& {/ S\\" V

{+ N9 t2 N) v, b: f+ c! o) f7 W, o

pMessage(L"\r\n"); k+=2; 
7 j1 ^+ R\\" g5 R, B: D1 @3 I- E
                        for(j=0; j<n; j++)0 c6 I1 \1 I+ D* m/ j\\" _3 G

{ 
5 l6 E5 B: h8 \( ~, p
                                _gcvt_s(chNum,pa[i*n+j],16); 
1 C4 u# Y/ [2 T3 r
                                for(u=0;chNum[u];u++) {wchNum[u]=chNum[u]; k++;}' i, A: a+ }\\" V4 j3 J- i1 C8 e

wchNum[u]='\0'; 
8 V$ f0 d6 t, Y
                                pMessage(wchNum); pMessage(L"  "); k+=2;( F( o/ q9 m% @& @3 v0 e- \8 H

}/ h, e( L% J7 g& A8 B: d0 L, H

}* e1 @& k6 i  d

pMessage(L"\r\n"); k+=2;7 b4 G. R( a! j

a.BType=luStaData_int64; a.VType=luStaData_int64; a.x=k;        //按函数o的要求，返回输出的字符总数1 {2 ^\\" X4 V2 ]) H

break;3 f! r7 E6 F$ U* a' R: x% L

default:\\" R; z5 q* t+ W5 w

break;1 n2 R$ q( n9 Y, X+ h5 Y

} 
5 V6 S6 q1 s5 C
        return a; 
\\" m6 g, [7 \, I4 V% \3 V
}) Q& x  x) t8 S, T5 b& Y: n

void main(void)/ ~6 J2 j4 e9 S0 _0 d7 s

{ 
( U8 I( v\\" }( d; M! i) @
        void *hFor;                //表达式句柄 
9 U+ G* V2 ^7 \& A5 {! _
        luINT nPara;                //存放表达式的自变量个数 
' Y8 |5 W! @* F8 w
        LuData *pPara;                //存放输入自变量的数组指针6 b( o6 q7 k* v! ?7 J\\" U) I; l

luINT ErrBegin,ErrEnd;        //表达式编译出错的初始位置和结束位置 
8 n4 s, G1 `& s\\" o' ]# r
        int ErrCode;                //错误代码 
/ J3 }4 M6 l3 @; g6 V/ x9 v
        void *v; 
% m( L, K/ \\\" {0 Q
        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.]}";//字符串表达式，矩阵乘 
! m0 l/ ?  y( ]3 ^
        //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.]}";//字符串表达式，矩阵点乘$ t2 Z4 K8 Z( N1 F- @( G, e\\" q

LuData Val; 
5 z9 E! ~* P! r' B! N
        if(!InitLu()) return;        //初始化Lu 
9 k% c9 l! Y* j' G4 @2 `
        while(LockKey(Matrix,DelMatrix,OpMatrix)){Matrix--;}        //锁定一个键，用于存储矩阵扩展类型 
  E1 B9 j/ D' [) r5 m1 V9 y) u. H
 
9 [9 }8 s: k; r
        Val.BType=luStaData_int64; Val.VType=luStaData_int64; Val.x=Matrix;        //定义整数常量* v4 C1 E8 V8 h8 ^  O

SetConst(L"matrix",&Val);        //设置整数常量4 Q; L. s3 n; r8 c+ l\\" I

InsertKey("\0\0\0\0",4,luPubKey_User,LuMessage,NULL,NULL,1,v); //使Lu运行时可输出函数信息 
- \* n# F' {8 D
        wcout.imbue(locale("chs"));        //设置输出的locale为中文* S- I: ^% @5 O) e0 p& _

. u4 ?3 f% n, {/ m* z

ErrCode=LuCom(ForStr,0,0,0,hFor,nPara,pPara,ErrBegin,ErrEnd); //编译表达式! O, b  N\\" u4 q! A+ ~  e

if(ErrCode) 
: b% f6 W\\" n' ^5 {/ Z6 o! t\\" C% B
        {2 A\\" }% A\\" X  T: p! _' @

wcout<<L"表达式有错误！错误代码："<<ErrCode<<endl; 
6 J- z- C\\" K$ O4 a+ ^# c
        }8 X  ^- i4 a- ?/ s7 O2 f1 f/ a/ `

else& U6 w8 p2 k8 g+ l+ n, m

{ 
7 b( b& N. c; u. ^( C6 w
                LuCal(hFor,pPara);        //计算表达式的值6 p; D$ J2 A4 D, i

} 
2 d6 d; }& p' `) P% {( ~8 `
        LockKey(Matrix,NULL,OpMatrix);//解锁键Matrix，本例中，该函数可以不用 
  ^* Q) H& |8 E9 ^1 _
        FreeLu();                        //释放Lu1 w) d1 j* X9 T* ]4 s

}

习题：

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

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

main(:a,b,c,d,t,i)=
/ P4 r$ U+ x6 Z2 \1 M
a=new[matrix,2,2: 1.,2.,2.,1.],9 \, P m' E1 _/ u, z
b=new[matrix,2,2: 2.,1.,1.,2.],5 q( |& e; _0 ]. X: ~
c=new[matrix,2,2: 2/3.,-1/3.,-1/3.,2/3.],
$ R7 e- ]% `. f% z9 o
t=clock(),' k. x1 A( {. m
d=a*b, i=0, while{i<1000000, d=d*c*b, i++},7 P* j4 z; _9 _; _2 u( A9 b# r
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\"}";//字符串表达式

复制代码

结果：