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

查看: 8677|回复: 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>
' X* G- O9 K2 Q8 B- M
#include <iostream>
3 x ?4 y+ m4 m p$ r C
#include <math.h>
+ R# r% H% p! c/ T- c
#include "lu32.h", H) j0 R0 t8 e9 M' D
#pragma comment( lib, "lu32.lib" )1 x\\" j* K6 y4 h# S7 {
using namespace std;
: y# @, N4 G n/ m
//自定义矩阵 H* [+ z* F' @( W
class myMatrix
0 M- A# @# m+ v5 }2 y
{
$ I0 [' Y4 v3 T
public:# H0 ^* F% ]) ?0 h6 S7 P2 j
double *Array; //数据缓冲区
2 U4 y6 H, h& k* {! \1 w
luVOID ArrayLen; //数据缓冲区长度0 ? D6 n0 E% f: j
luVOID Dim[2]; //矩阵维数
! w' J5 @' W! [( d* a8 G% t3 m
myMatrix(){Array=NULL; ArrayLen=0; Dim[0]=0; Dim[1]=0;}
/ f+ s6 }! U\\" m# D K' R* y
~myMatrix()
4 X) l' M: E7 K1 n# M2 M
{
& [! ^& d ~2 b9 u7 G! k
if(Array) delete[] Array;1 i7 s7 c9 J# `0 D2 _' ]/ C
}, U* e8 i5 j# i. [' U
};, Z; N* h/ K; I+ e3 S
luKEY Matrix=-1000; //标识矩阵类型，最终的Matrix由LockKey决定$ X* b; [8 `& T4 Y2 k; v
void _stdcall LuMessage(wchar_t *pch)//输出动态库信息，该函数注册到Lu，由Lu二级函数调用 9 W% o7 m3 b1 l Z
{
+ C/ Q% O2 l. L9 X9 {7 f8 S
wcout<<pch;5 g* {* a\\" n3 a7 w$ W0 t3 Q' y
}
! p0 }& m( u3 D' K
void _stdcall DelMatrix(void *me) //用于LockKey函数及InsertKey函数，使Lu能自动销毁myMatrix对象( R5 k& N J( I6 c
{' v( b# F2 G8 |8 \! S; J8 F/ z
delete (myMatrix *)me;7 B% X4 Y3 T6 _9 l
}. w0 v5 @0 L5 m\\" t% t' `' q
myMatrix * _stdcall NewMatrix(luVOID m,luVOID n) //生成一个myMatrix对象
8 F\\" H: V$ ~' i$ D
{+ a/ I* X1 x' L. e0 \
myMatrix *pMatrix;
2 F# a\\" L% W9 B
luVOID k;
- ^ c4 t( R5 i5 r: z\\" i+ g: m+ N
double *pa;9 q1 T; |. ^+ y
char keyname[sizeof(luVOID)];1 @: { e\\" g\\" @\\" S! q0 g
void *NowKey;
0 R6 W% j6 j( ]: V. z$ A
k=m*n;
6 Z8 J4 L, L0 a6 ^9 t: c
pMatrix=(myMatrix *)GetBufObj(Matrix,keyname);//先尝试从缓冲区中获取一个矩阵对象2 L) D/ C: w9 N
if(pMatrix)
& j! _7 o, W' U6 Y; V5 h* {; i
{ C: j0 V' h: ~- J
if(pMatrix->ArrayLen!=k) //重置矩阵的大小
! P6 U3 Y3 |/ M2 k; B. s0 M
{+ K$ S0 t+ D9 g: S( {
pa=new double[k];5 I0 ^2 x( u( R# f
if(!pa)
' I4 S; R5 x* C! {) B, }
{
: j+ O\\" s% P2 M6 o8 b* C: K
DeleteKey(keyname,sizeof(luVOID),Matrix,DelMatrix,1); //将矩阵对象放回缓冲区% y9 Y2 m% R0 t( S: p
return NULL;
/ B) V7 L8 A4 d8 x: W+ ?
}) g, W3 G2 x( g0 g7 E6 R
delete[] pMatrix->Array;
0 L; `1 G! `6 i' F
pMatrix->Array=pa;
* \! b+ ]% b! F% t& i( m5 s
}
6 L# Z- Z( J8 {, \: I: H
}4 {5 X5 r/ h3 g- k4 D
else
% k# y5 p; Q# f
{: R6 l; C3 g1 {5 r
pMatrix=new myMatrix; //创建矩阵对象
$ R- X/ W5 }, o A1 u+ T\\" a7 f4 Z
if(!pMatrix) return NULL;
+ j/ W' X: C4 w
pMatrix->Array=new double[k];
9 _' r. K9 d5 V5 K0 }' J$ e$ O
if(!pMatrix->Array)$ O% \: F: Z0 h\\" o) l
{8 C- ^# c! E4 T R ^8 ~
delete pMatrix;: m0 Z. b; Y( h! h5 C n
return NULL;6 b5 w/ S z# H \3 K J' Q' Y: }
}. D5 x* i0 C' D5 N\\" l) J( s
if(InsertKey((char *)&pMatrix,-1,Matrix,pMatrix,DelMatrix,NULL,0,NowKey)) //将矩阵对象注册到Lu
* ?& P, D' B, ?( N
{
% i2 g! |% |) I4 U$ @5 j U
delete pMatrix;# G, { k c+ n\\" e5 H I) K
return NULL;1 H\\" b, f E. V7 t$ D7 {( j( I
}% c& b; F$ x; E: P5 T
}
+ _& c) i& |5 y0 r
pMatrix->ArrayLen=k; pMatrix->Dim[0]=m; pMatrix->Dim[1]=n;4 `0 U7 I) }' c2 B8 B
return pMatrix;
5 j. j6 j- q( H8 r) r
}
. ?2 ^( A( `1 d1 i5 x
LuData _stdcall OpMatrix(luINT mm,LuData *xx,void *hFor,int theOperator) //运算符重载函数，用于LockKey函数- q6 w3 @' @8 d6 C2 r: W. l% M
{. p9 `8 T6 T- m\\" U
LuData a;7 z y* y9 O( h
myMatrix *pMatrix1,*pMatrix2,*pMatrix3;3 ?& i/ p2 Y\\" }1 _6 l# h( F# x. w
luVOID i,j,k,m,n,u,v;' S( f4 K0 r: G- A# f
double *pa,*pb,*pc;
; |! b$ G1 l/ f3 u- a5 q
luMessage pMessage;
- e) A7 r* s2 G
wchar_t wchNum[32];
) M* Z) ]% R2 I8 w$ V. @0 T
char chNum[32];
2 U/ J\\" i4 m; Q3 h# F! l
a.BType=luStaData_nil; a.VType=luStaData_nil; a.x=0;0 W4 w2 k, J/ W/ U\\" Q; e! K8 F4 `
switch(theOperator)
: O4 N% ^/ I. ]% g9 Z1 ?9 {
{
. }+ {0 {- V! B- Z! l
case 2: //重载运算符*
0 g, A. x: V1 A' ^0 Z: t1 h! r
pMatrix1=(myMatrix *)SearchKey((char *)&(xx->x),sizeof(luVOID),Matrix);
8 p% C; @7 |* B# s
pMatrix2=(myMatrix *)SearchKey((char *)&((xx+1)->x),sizeof(luVOID),Matrix);
, Z7 `& e8 @3 | Q
if(!pMatrix1 || !pMatrix2) break; //对象句柄无效，不是矩阵' H, `9 L: u3 _4 d5 X( c2 }
if(pMatrix1->Dim[1]!=pMatrix2->Dim[0]) break; //维数不匹配
' e\\" k; d0 n+ g\\" k6 |\\" I
pMatrix3=NewMatrix(pMatrix1->Dim[0],pMatrix2->Dim[1]); //生成新矩阵
$ D5 l' [* Z. @, M
if(!pMatrix3) break;- ~3 D3 _9 A5 e+ V5 g- ]& E5 a9 f
pa=pMatrix1->Array; pb=pMatrix2->Array; pc=pMatrix3->Array;4 _3 L ^- V; Q( ?! |3 x# @0 g$ u5 w
m=pMatrix1->Dim[0]; n=pMatrix1->Dim[1]; k=pMatrix2->Dim[1];7 a9 W5 `: y# `
for(i=0; i<m; i++) //矩阵乘% K* ~2 t, `: s, q; D+ z) `3 z9 a9 ]
{7 b% w' o! E6 y8 o N+ {
for(j=0; j<k; j++)
3 h6 T' S% B# {& c
{
! B) P2 e9 q! E
u=i*k+j; pc[u]=0.0;
- k% ^4 q+ v1 q7 b( X
for (v=0; v<n; v++)
6 w1 P4 D7 f5 m, u+ S5 c! I0 r
{
N9 T* F5 E1 l
pc[u]=pc[u]+pa[i*n+v]*pb[v*k+j];
( y3 y# M6 I2 F% Q/ ^! q
}6 W9 k! \) a3 G6 e$ D7 A k
}( d! z\\" S/ @* k; m- w\\" j
}
$ E* R( a/ J4 ]5 `! H: \
FunReObj(hFor); //告诉Lu，返回一个动态对象8 S! ^1 Q3 f5 ^6 b1 L( I
a.BType=Matrix; a.VType=Matrix; a.x=0; *(luVOID *)&(a.x)=(luVOID)pMatrix3;8 H& w% M7 n& n, I0 @' h d
break;
\\" L! K' H8 I8 }/ t4 l' U2 c
case 25: //重载运算符.*- ]1 M! d1 E( q, x W\\" X( V1 U
pMatrix1=(myMatrix *)SearchKey((char *)&(xx->x),sizeof(luVOID),Matrix);: z& E8 V, O- V( D: h' N
pMatrix2=(myMatrix *)SearchKey((char *)&((xx+1)->x),sizeof(luVOID),Matrix);
+ m7 ^% V i$ t+ o2 d
if(!pMatrix1 || !pMatrix2) break; //对象句柄无效，不是矩阵; I |6 P; |0 @, i\\" ^
if(pMatrix1->Dim[0]!=pMatrix2->Dim[0] || pMatrix1->Dim[1]!=pMatrix2->Dim[1]) break; //维数不相同\\" g& k$ J( j0 Y4 @$ [1 h* {* C
pMatrix3=NewMatrix(pMatrix1->Dim[0],pMatrix1->Dim[1]); //生成新矩阵
1 s- t' P# Z/ C) Y
if(!pMatrix3) break;
8 M8 r: g7 |. G
for(i=0;i<pMatrix1->ArrayLen;i++) pMatrix3->Array[i]=pMatrix1->Array[i]*pMatrix2->Array[i]; //矩阵点乘
+ P7 U! S( @, E( r5 k
FunReObj(hFor); //告诉Lu，返回一个动态对象
1 A+ M, ~, J/ P# B9 {! E& V# [
a.BType=Matrix; a.VType=Matrix; a.x=0; *(luVOID *)&(a.x)=(luVOID)pMatrix3;
5 K# ^- r# R u
break;* L\\" H7 x* Q, c: \
case 46: //重载函数new
: ^1 g& y3 a. ]
if(mm<2) break;
6 l) u1 M$ ^( X
if((xx+1)->x<1 || (xx+2)->x<1 || (xx+1)->BType!=luStaData_int64 || (xx+2)->BType!=luStaData_int64) break; n. l8 _% h8 `( V
pMatrix3=NewMatrix((luVOID)(xx+1)->x,(luVOID)(xx+2)->x);//生成新矩阵
$ H( q: e. {* b; h9 }' N
if(!pMatrix3) break;
$ |6 m% Z' @ R( r) M5 h4 g
for(j=0,i=3;i<=mm;i++,j++) //赋初值8 l\\" R6 l, T( o; c
{3 Q0 [; x b$ v0 }- M
if(j>=pMatrix3->ArrayLen) break;
- U8 l; {! ^* h* ~: x2 m7 j
if((xx+i)->BType!=luStaData_double) break; //只接受实数参数, `; S8 H( @5 F4 c% g: l! M8 E
pMatrix3->Array[j]=*(double *)&((xx+i)->x);
) o( L/ ~1 j/ E& d% W
}
; T6 S% @' q1 K
FunReObj(hFor); //告诉Lu，返回一个动态对象
6 I& y6 |# X' m4 y% g
a.BType=Matrix; a.VType=Matrix; a.x=0; *(luVOID *)&(a.x)=(luVOID)pMatrix3;
9 v# X' m# {( y
break;1 h5 X5 C/ l- \8 v: W C5 S
case 49: //重载函数o- m, v9 Z# s, @; i) f
pMessage=(luMessage)SearchKey("\0\0\0\0",sizeof(luVOID),luPubKey_User);
8 P; p2 k i' \. e1 J/ K
if(!pMessage) break;
[& ?4 ]# x( ?% g' s' }
pMatrix1=(myMatrix *)SearchKey((char *)&(xx->x),sizeof(luVOID),Matrix);
3 v# c4 X0 z, |% b7 R
if(!pMatrix1) break; //对象句柄无效，不是矩阵
\\" U2 d7 l6 I- P6 B& e- N8 q5 c
pa=pMatrix1->Array;
6 v0 }; c* Z# @& |& C4 ?
m=pMatrix1->Dim[0]; n=pMatrix1->Dim[1]; k=0;
\\" Z; F( Z6 O# B2 \
for(i=0; i<m; i++) //输出矩阵
7 |( t# W: u- d# I' U. J5 D
{, ], F0 Q$ V5 O* W6 n; ^3 T
pMessage(L"\r\n"); k+=2;( o; c, e7 |5 g1 N/ F/ h
for(j=0; j<n; j++)
$ f/ ^0 x; N N. w3 |/ q2 C2 H8 W
{5 d! B; q, k, X- w' o\\" R9 d
_gcvt_s(chNum,pa[i*n+j],16);
3 t S4 T- j- n8 B8 v
for(u=0;chNum[u];u++) {wchNum[u]=chNum[u]; k++;}$ K5 M/ Y; V! ~; B/ X ]
wchNum[u]='\0';1 u) E: x: j' A2 T9 f4 n' U- t
pMessage(wchNum); pMessage(L" "); k+=2;
6 o( X# d d\\" Y6 C4 W: B' a
}7 Z\\" x/ z- ^. N& a7 m
}
, c3 E% |& {\\" R# W8 y1 t4 i
pMessage(L"\r\n"); k+=2;& H4 U5 `9 G\\" [7 W) n& ~
a.BType=luStaData_int64; a.VType=luStaData_int64; a.x=k; //按函数o的要求，返回输出的字符总数
7 F, I6 O* n2 o
break;
! d\\" }6 r; n: c/ F. ~
default:
# R7 D- X( A! L* _5 ?, N, Z' I; V
break;
; ?2 l+ `% t\\" B6 Z/ j
}
0 L: l3 e1 t( l; u! M: I
return a;$ {, s- N2 D9 D& v b
}6 `) j' c! E$ ~- L( Y
void main(void)
8 S6 K2 W2 R: r& ]
{6 i* o0 c1 T$ a+ Q1 A
void *hFor; //表达式句柄/ o0 O; E& e0 u0 T* T: F
luINT nPara; //存放表达式的自变量个数$ \$ k9 i0 A5 O8 k
LuData *pPara; //存放输入自变量的数组指针1 m8 N5 W5 l# ]- h( H
luINT ErrBegin,ErrEnd; //表达式编译出错的初始位置和结束位置% c( N$ P8 _8 b3 F$ t5 r\\" m! b
int ErrCode; //错误代码
* p; F3 A; G; A: f6 p! m. y
void *v;
# X; Q+ z$ P& z0 m0 T
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.]}";//字符串表达式，矩阵乘/ G) E& k1 J$ W\\" a) W Z3 g; S
//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.]}";//字符串表达式，矩阵点乘% g, Z5 z/ K5 V4 S+ M
LuData Val;
6 |- z+ t& O, _% W, o$ B
if(!InitLu()) return; //初始化Lu. y5 q7 c: S- j; O+ s- ? i
while(LockKey(Matrix,DelMatrix,OpMatrix)){Matrix--;} //锁定一个键，用于存储矩阵扩展类型7 J( J\\" {2 m( T! c\\" Z
, V: H$ y$ p1 }
Val.BType=luStaData_int64; Val.VType=luStaData_int64; Val.x=Matrix; //定义整数常量; r+ }\\" ^) d1 \% s# @: ]5 y
SetConst(L"matrix",&Val); //设置整数常量- y4 W J8 _6 `\\" m+ P' C
InsertKey("\0\0\0\0",4,luPubKey_User,LuMessage,NULL,NULL,1,v); //使Lu运行时可输出函数信息; l! z7 _2 [$ g) e/ W7 C2 i! K; U& l# v
wcout.imbue(locale("chs")); //设置输出的locale为中文
) e. W, X\\" [- \. O% _9 g/ `, i( j
5 e* M: y7 o! l; z; P
ErrCode=LuCom(ForStr,0,0,0,hFor,nPara,pPara,ErrBegin,ErrEnd); //编译表达式
4 e1 V* p3 V) Q2 t
if(ErrCode)
; _% I* d3 o& k. G) E) ^0 t# K
{, }7 Y p% i0 J k2 P; e
wcout<<L"表达式有错误！错误代码："<<ErrCode<<endl;4 u+ `8 ^0 D, D* X
}
1 a. [3 l2 H! \1 O; k\\" X4 S. L6 l: U
else6 B5 Z. U0 n$ [ c
{7 u: p5 a4 M1 W
LuCal(hFor,pPara); //计算表达式的值
\\" l* k5 L1 z) m8 |, p6 g\\" v3 o
}
5 [$ H' E. }9 J6 c& x+ w
LockKey(Matrix,NULL,OpMatrix);//解锁键Matrix，本例中，该函数可以不用
0 J& t5 W9 t- O! ?& i
FreeLu(); //释放Lu' o0 g& t) M @3 L
}

#include <windows.h> 
' X* G- O9 K2 Q8 B- M
#include <iostream> 
3 x  ?4 y+ m4 m  p$ r  C
#include <math.h> 
+ R# r% H% p! c/ T- c
#include "lu32.h", H) j0 R0 t8 e9 M' D

#pragma comment( lib, "lu32.lib" )1 x\\" j* K6 y4 h# S7 {

using namespace std; 
: y# @, N4 G  n/ m
//自定义矩阵  H* [+ z* F' @( W

class myMatrix 
0 M- A# @# m+ v5 }2 y
{ 
$ I0 [' Y4 v3 T
public:# H0 ^* F% ]) ?0 h6 S7 P2 j

double *Array;        //数据缓冲区 
2 U4 y6 H, h& k* {! \1 w
        luVOID ArrayLen;        //数据缓冲区长度0 ?  D6 n0 E% f: j

luVOID Dim[2];        //矩阵维数 
! w' J5 @' W! [( d* a8 G% t3 m
        myMatrix(){Array=NULL; ArrayLen=0; Dim[0]=0; Dim[1]=0;} 
/ f+ s6 }! U\\" m# D  K' R* y
        ~myMatrix() 
4 X) l' M: E7 K1 n# M2 M
        { 
& [! ^& d  ~2 b9 u7 G! k
                if(Array) delete[] Array;1 i7 s7 c9 J# `0 D2 _' ]/ C

}, U* e8 i5 j# i. [' U

};, Z; N* h/ K; I+ e3 S

luKEY Matrix=-1000;        //标识矩阵类型，最终的Matrix由LockKey决定$ X* b; [8 `& T4 Y2 k; v

void _stdcall LuMessage(wchar_t *pch)//输出动态库信息，该函数注册到Lu，由Lu二级函数调用 9 W% o7 m3 b1 l  Z

{ 
+ C/ Q% O2 l. L9 X9 {7 f8 S
        wcout<<pch;5 g* {* a\\" n3 a7 w$ W0 t3 Q' y

} 
! p0 }& m( u3 D' K
void _stdcall DelMatrix(void *me)        //用于LockKey函数及InsertKey函数，使Lu能自动销毁myMatrix对象( R5 k& N  J( I6 c

{' v( b# F2 G8 |8 \! S; J8 F/ z

delete (myMatrix *)me;7 B% X4 Y3 T6 _9 l

}. w0 v5 @0 L5 m\\" t% t' `' q

myMatrix * _stdcall NewMatrix(luVOID m,luVOID n)        //生成一个myMatrix对象 
8 F\\" H: V$ ~' i$ D
{+ a/ I* X1 x' L. e0 \

myMatrix *pMatrix; 
2 F# a\\" L% W9 B
        luVOID k; 
- ^  c4 t( R5 i5 r: z\\" i+ g: m+ N
        double *pa;9 q1 T; |. ^+ y

char keyname[sizeof(luVOID)];1 @: {  e\\" g\\" @\\" S! q0 g

void *NowKey; 
0 R6 W% j6 j( ]: V. z$ A
        k=m*n; 
6 Z8 J4 L, L0 a6 ^9 t: c
        pMatrix=(myMatrix *)GetBufObj(Matrix,keyname);//先尝试从缓冲区中获取一个矩阵对象2 L) D/ C: w9 N

if(pMatrix) 
& j! _7 o, W' U6 Y; V5 h* {; i
        {  C: j0 V' h: ~- J

if(pMatrix->ArrayLen!=k)        //重置矩阵的大小 
! P6 U3 Y3 |/ M2 k; B. s0 M
                {+ K$ S0 t+ D9 g: S( {

pa=new double[k];5 I0 ^2 x( u( R# f

if(!pa) 
' I4 S; R5 x* C! {) B, }
                        { 
: j+ O\\" s% P2 M6 o8 b* C: K
                                DeleteKey(keyname,sizeof(luVOID),Matrix,DelMatrix,1);        //将矩阵对象放回缓冲区% y9 Y2 m% R0 t( S: p

return NULL; 
/ B) V7 L8 A4 d8 x: W+ ?
                        }) g, W3 G2 x( g0 g7 E6 R

delete[] pMatrix->Array; 
0 L; `1 G! `6 i' F
                        pMatrix->Array=pa; 
* \! b+ ]% b! F% t& i( m5 s
                } 
6 L# Z- Z( J8 {, \: I: H
        }4 {5 X5 r/ h3 g- k4 D

else 
% k# y5 p; Q# f
        {: R6 l; C3 g1 {5 r

pMatrix=new myMatrix;        //创建矩阵对象 
$ R- X/ W5 }, o  A1 u+ T\\" a7 f4 Z
                if(!pMatrix) return NULL; 
+ j/ W' X: C4 w
                pMatrix->Array=new double[k]; 
9 _' r. K9 d5 V5 K0 }' J$ e$ O
                if(!pMatrix->Array)$ O% \: F: Z0 h\\" o) l

{8 C- ^# c! E4 T  R  ^8 ~

delete pMatrix;: m0 Z. b; Y( h! h5 C  n

return NULL;6 b5 w/ S  z# H  \3 K  J' Q' Y: }

}. D5 x* i0 C' D5 N\\" l) J( s

if(InsertKey((char *)&pMatrix,-1,Matrix,pMatrix,DelMatrix,NULL,0,NowKey))        //将矩阵对象注册到Lu 
* ?& P, D' B, ?( N
                { 
% i2 g! |% |) I4 U$ @5 j  U
                        delete pMatrix;# G, {  k  c+ n\\" e5 H  I) K

return NULL;1 H\\" b, f  E. V7 t$ D7 {( j( I

}% c& b; F$ x; E: P5 T

} 
+ _& c) i& |5 y0 r
        pMatrix->ArrayLen=k; pMatrix->Dim[0]=m; pMatrix->Dim[1]=n;4 `0 U7 I) }' c2 B8 B

return pMatrix; 
5 j. j6 j- q( H8 r) r
} 
. ?2 ^( A( `1 d1 i5 x
LuData _stdcall OpMatrix(luINT mm,LuData *xx,void *hFor,int theOperator)        //运算符重载函数，用于LockKey函数- q6 w3 @' @8 d6 C2 r: W. l% M

{. p9 `8 T6 T- m\\" U

LuData a;7 z  y* y9 O( h

myMatrix *pMatrix1,*pMatrix2,*pMatrix3;3 ?& i/ p2 Y\\" }1 _6 l# h( F# x. w

luVOID i,j,k,m,n,u,v;' S( f4 K0 r: G- A# f

double *pa,*pb,*pc; 
; |! b$ G1 l/ f3 u- a5 q
        luMessage pMessage; 
- e) A7 r* s2 G
        wchar_t wchNum[32]; 
) M* Z) ]% R2 I8 w$ V. @0 T
        char chNum[32]; 
2 U/ J\\" i4 m; Q3 h# F! l
        a.BType=luStaData_nil; a.VType=luStaData_nil; a.x=0;0 W4 w2 k, J/ W/ U\\" Q; e! K8 F4 `

switch(theOperator) 
: O4 N% ^/ I. ]% g9 Z1 ?9 {
        { 
. }+ {0 {- V! B- Z! l
        case 2:        //重载运算符* 
0 g, A. x: V1 A' ^0 Z: t1 h! r
                pMatrix1=(myMatrix *)SearchKey((char *)&(xx->x),sizeof(luVOID),Matrix); 
8 p% C; @7 |* B# s
                pMatrix2=(myMatrix *)SearchKey((char *)&((xx+1)->x),sizeof(luVOID),Matrix); 
, Z7 `& e8 @3 |  Q
                if(!pMatrix1 || !pMatrix2) break;        //对象句柄无效，不是矩阵' H, `9 L: u3 _4 d5 X( c2 }

if(pMatrix1->Dim[1]!=pMatrix2->Dim[0]) break;        //维数不匹配 
' e\\" k; d0 n+ g\\" k6 |\\" I
                pMatrix3=NewMatrix(pMatrix1->Dim[0],pMatrix2->Dim[1]);        //生成新矩阵 
$ D5 l' [* Z. @, M
                if(!pMatrix3) break;- ~3 D3 _9 A5 e+ V5 g- ]& E5 a9 f

pa=pMatrix1->Array; pb=pMatrix2->Array; pc=pMatrix3->Array;4 _3 L  ^- V; Q( ?! |3 x# @0 g$ u5 w

m=pMatrix1->Dim[0]; n=pMatrix1->Dim[1]; k=pMatrix2->Dim[1];7 a9 W5 `: y# `

for(i=0; i<m; i++)        //矩阵乘% K* ~2 t, `: s, q; D+ z) `3 z9 a9 ]

{7 b% w' o! E6 y8 o  N+ {

for(j=0; j<k; j++) 
3 h6 T' S% B# {& c
                        { 
! B) P2 e9 q! E
                                u=i*k+j; pc[u]=0.0; 
- k% ^4 q+ v1 q7 b( X
                                for (v=0; v<n; v++) 
6 w1 P4 D7 f5 m, u+ S5 c! I0 r
                                { 
  N9 T* F5 E1 l
                                        pc[u]=pc[u]+pa[i*n+v]*pb[v*k+j]; 
( y3 y# M6 I2 F% Q/ ^! q
                                }6 W9 k! \) a3 G6 e$ D7 A  k

}( d! z\\" S/ @* k; m- w\\" j

} 
$ E* R( a/ J4 ]5 `! H: \
                FunReObj(hFor);        //告诉Lu，返回一个动态对象8 S! ^1 Q3 f5 ^6 b1 L( I

a.BType=Matrix; a.VType=Matrix; a.x=0; *(luVOID *)&(a.x)=(luVOID)pMatrix3;8 H& w% M7 n& n, I0 @' h  d

break; 
\\" L! K' H8 I8 }/ t4 l' U2 c
        case 25:        //重载运算符.*- ]1 M! d1 E( q, x  W\\" X( V1 U

pMatrix1=(myMatrix *)SearchKey((char *)&(xx->x),sizeof(luVOID),Matrix);: z& E8 V, O- V( D: h' N

pMatrix2=(myMatrix *)SearchKey((char *)&((xx+1)->x),sizeof(luVOID),Matrix); 
+ m7 ^% V  i$ t+ o2 d
                if(!pMatrix1 || !pMatrix2) break;        //对象句柄无效，不是矩阵; I  |6 P; |0 @, i\\" ^

if(pMatrix1->Dim[0]!=pMatrix2->Dim[0] || pMatrix1->Dim[1]!=pMatrix2->Dim[1]) break;        //维数不相同\\" g& k$ J( j0 Y4 @$ [1 h* {* C

pMatrix3=NewMatrix(pMatrix1->Dim[0],pMatrix1->Dim[1]);        //生成新矩阵 
1 s- t' P# Z/ C) Y
                if(!pMatrix3) break; 
8 M8 r: g7 |. G
                for(i=0;i<pMatrix1->ArrayLen;i++) pMatrix3->Array[i]=pMatrix1->Array[i]*pMatrix2->Array[i];        //矩阵点乘 
+ P7 U! S( @, E( r5 k
                FunReObj(hFor);        //告诉Lu，返回一个动态对象 
1 A+ M, ~, J/ P# B9 {! E& V# [
                a.BType=Matrix; a.VType=Matrix; a.x=0; *(luVOID *)&(a.x)=(luVOID)pMatrix3; 
5 K# ^- r# R  u
                break;* L\\" H7 x* Q, c: \

case 46:        //重载函数new 
: ^1 g& y3 a. ]
                if(mm<2) break; 
6 l) u1 M$ ^( X
                if((xx+1)->x<1 || (xx+2)->x<1 || (xx+1)->BType!=luStaData_int64 || (xx+2)->BType!=luStaData_int64) break;  n. l8 _% h8 `( V

pMatrix3=NewMatrix((luVOID)(xx+1)->x,(luVOID)(xx+2)->x);//生成新矩阵 
$ H( q: e. {* b; h9 }' N
                if(!pMatrix3) break; 
$ |6 m% Z' @  R( r) M5 h4 g
                for(j=0,i=3;i<=mm;i++,j++)        //赋初值8 l\\" R6 l, T( o; c

{3 Q0 [; x  b$ v0 }- M

if(j>=pMatrix3->ArrayLen) break; 
- U8 l; {! ^* h* ~: x2 m7 j
                        if((xx+i)->BType!=luStaData_double) break;        //只接受实数参数, `; S8 H( @5 F4 c% g: l! M8 E

pMatrix3->Array[j]=*(double *)&((xx+i)->x); 
) o( L/ ~1 j/ E& d% W
                } 
; T6 S% @' q1 K
                FunReObj(hFor);        //告诉Lu，返回一个动态对象 
6 I& y6 |# X' m4 y% g
                a.BType=Matrix; a.VType=Matrix; a.x=0; *(luVOID *)&(a.x)=(luVOID)pMatrix3; 
9 v# X' m# {( y
                break;1 h5 X5 C/ l- \8 v: W  C5 S

case 49:        //重载函数o- m, v9 Z# s, @; i) f

pMessage=(luMessage)SearchKey("\0\0\0\0",sizeof(luVOID),luPubKey_User); 
8 P; p2 k  i' \. e1 J/ K
                if(!pMessage) break; 
  [& ?4 ]# x( ?% g' s' }
                pMatrix1=(myMatrix *)SearchKey((char *)&(xx->x),sizeof(luVOID),Matrix); 
3 v# c4 X0 z, |% b7 R
                if(!pMatrix1) break;        //对象句柄无效，不是矩阵 
\\" U2 d7 l6 I- P6 B& e- N8 q5 c
                pa=pMatrix1->Array; 
6 v0 }; c* Z# @& |& C4 ?
                m=pMatrix1->Dim[0]; n=pMatrix1->Dim[1]; k=0; 
\\" Z; F( Z6 O# B2 \
                for(i=0; i<m; i++)        //输出矩阵 
7 |( t# W: u- d# I' U. J5 D
                {, ], F0 Q$ V5 O* W6 n; ^3 T

pMessage(L"\r\n"); k+=2;( o; c, e7 |5 g1 N/ F/ h

for(j=0; j<n; j++) 
$ f/ ^0 x; N  N. w3 |/ q2 C2 H8 W
                        {5 d! B; q, k, X- w' o\\" R9 d

_gcvt_s(chNum,pa[i*n+j],16); 
3 t  S4 T- j- n8 B8 v
                                for(u=0;chNum[u];u++) {wchNum[u]=chNum[u]; k++;}$ K5 M/ Y; V! ~; B/ X  ]

wchNum[u]='\0';1 u) E: x: j' A2 T9 f4 n' U- t

pMessage(wchNum); pMessage(L"  "); k+=2; 
6 o( X# d  d\\" Y6 C4 W: B' a
                        }7 Z\\" x/ z- ^. N& a7 m

} 
, c3 E% |& {\\" R# W8 y1 t4 i
                pMessage(L"\r\n"); k+=2;& H4 U5 `9 G\\" [7 W) n& ~

a.BType=luStaData_int64; a.VType=luStaData_int64; a.x=k;        //按函数o的要求，返回输出的字符总数 
7 F, I6 O* n2 o
                break; 
! d\\" }6 r; n: c/ F. ~
        default: 
# R7 D- X( A! L* _5 ?, N, Z' I; V
                break; 
; ?2 l+ `% t\\" B6 Z/ j
        } 
0 L: l3 e1 t( l; u! M: I
        return a;$ {, s- N2 D9 D& v  b

}6 `) j' c! E$ ~- L( Y

void main(void) 
8 S6 K2 W2 R: r& ]
{6 i* o0 c1 T$ a+ Q1 A

void *hFor;                //表达式句柄/ o0 O; E& e0 u0 T* T: F

luINT nPara;                //存放表达式的自变量个数$ \$ k9 i0 A5 O8 k

LuData *pPara;                //存放输入自变量的数组指针1 m8 N5 W5 l# ]- h( H

luINT ErrBegin,ErrEnd;        //表达式编译出错的初始位置和结束位置% c( N$ P8 _8 b3 F$ t5 r\\" m! b

int ErrCode;                //错误代码 
* p; F3 A; G; A: f6 p! m. y
        void *v; 
# X; Q+ z$ P& z0 m0 T
        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.]}";//字符串表达式，矩阵乘/ G) E& k1 J$ W\\" a) W  Z3 g; S

//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.]}";//字符串表达式，矩阵点乘% g, Z5 z/ K5 V4 S+ M

LuData Val; 
6 |- z+ t& O, _% W, o$ B
        if(!InitLu()) return;        //初始化Lu. y5 q7 c: S- j; O+ s- ?  i

while(LockKey(Matrix,DelMatrix,OpMatrix)){Matrix--;}        //锁定一个键，用于存储矩阵扩展类型7 J( J\\" {2 m( T! c\\" Z

, V: H$ y$ p1 }

Val.BType=luStaData_int64; Val.VType=luStaData_int64; Val.x=Matrix;        //定义整数常量; r+ }\\" ^) d1 \% s# @: ]5 y

SetConst(L"matrix",&Val);        //设置整数常量- y4 W  J8 _6 `\\" m+ P' C

InsertKey("\0\0\0\0",4,luPubKey_User,LuMessage,NULL,NULL,1,v); //使Lu运行时可输出函数信息; l! z7 _2 [$ g) e/ W7 C2 i! K; U& l# v

wcout.imbue(locale("chs"));        //设置输出的locale为中文 
) e. W, X\\" [- \. O% _9 g/ `, i( j
  5 e* M: y7 o! l; z; P

ErrCode=LuCom(ForStr,0,0,0,hFor,nPara,pPara,ErrBegin,ErrEnd); //编译表达式 
4 e1 V* p3 V) Q2 t
        if(ErrCode) 
; _% I* d3 o& k. G) E) ^0 t# K
        {, }7 Y  p% i0 J  k2 P; e

wcout<<L"表达式有错误！错误代码："<<ErrCode<<endl;4 u+ `8 ^0 D, D* X

} 
1 a. [3 l2 H! \1 O; k\\" X4 S. L6 l: U
        else6 B5 Z. U0 n$ [  c

{7 u: p5 a4 M1 W

LuCal(hFor,pPara);        //计算表达式的值 
\\" l* k5 L1 z) m8 |, p6 g\\" v3 o
        } 
5 [$ H' E. }9 J6 c& x+ w
        LockKey(Matrix,NULL,OpMatrix);//解锁键Matrix，本例中，该函数可以不用 
0 J& t5 W9 t- O! ?& i
        FreeLu();                        //释放Lu' o0 g& t) M  @3 L

}

习题：

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

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

main(:a,b,c,d,t,i)=; q) o, r5 L% v* {( H0 l( L8 [
a=new[matrix,2,2: 1.,2.,2.,1.],
2 [' r% j) m, L: i* K# X7 k
b=new[matrix,2,2: 2.,1.,1.,2.],/ _& Z- s6 ~7 \. @( w$ y0 w' E+ E
c=new[matrix,2,2: 2/3.,-1/3.,-1/3.,2/3.],, Z) p, O% Z1 r+ k
t=clock(),% O& |) [4 i z! o9 a
d=a*b, i=0, while{i<1000000, d=d*c*b, i++},
2 g V) Z* e. Q, S) }$ G
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\"}";//字符串表达式

复制代码

结果：