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

查看: 9058|回复: 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 C/ G( _# k3 f9 w
#include <iostream>
V8 ]5 f3 o! q8 u3 q0 _# f/ i* h
#include <math.h>
. k8 R, ^, d k2 r
#include "lu32.h"
1 A\\" D' H! @* M8 Y( k
#pragma comment( lib, "lu32.lib" )/ ?1 `. A1 g- g0 z& y
using namespace std;$ r7 ]$ u; B0 r7 n7 {( l1 Q
//自定义矩阵
# Z$ Z4 l: x$ c3 U
class myMatrix
# C! I6 F* I/ U4 h
{( s2 q2 P, A) g
public:
5 X\\" c9 R$ P, e1 @\\" q7 @# I
double *Array; //数据缓冲区$ X9 {/ ^4 F6 O4 ^
luVOID ArrayLen; //数据缓冲区长度
( e `' ^ T/ }
luVOID Dim[2]; //矩阵维数
% q0 y2 o6 \: S' u% P# V
myMatrix(){Array=NULL; ArrayLen=0; Dim[0]=0; Dim[1]=0;}
+ X- |/ ?& C$ r+ _# W
~myMatrix()' z% Z5 \ \3 V1 \# n
{
) g1 K# z6 W/ s+ @5 a: S& ?
if(Array) delete[] Array;* c! E+ j2 e! t7 r3 S1 c& U/ w! l
}1 }' K- C3 a1 b# K$ W9 l
};2 P+ W7 o' x/ ? R7 E' j
luKEY Matrix=-1000; //标识矩阵类型，最终的Matrix由LockKey决定
3 q% ?' d0 c/ o& ]\\" p9 i0 [
void _stdcall LuMessage(wchar_t *pch)//输出动态库信息，该函数注册到Lu，由Lu二级函数调用
2 H- N& b6 B8 ~8 K' S; _7 W+ F
{- j. v$ u- b7 {( m
wcout<<pch;3 [% |% _; B3 H* p, k2 L3 N4 L0 c
}
7 P* ~ \; e\\" z# N* b& c
void _stdcall DelMatrix(void *me) //用于LockKey函数及InsertKey函数，使Lu能自动销毁myMatrix对象
6 c1 b' o! a0 N2 Y& A8 W
{
1 V8 ?4 H$ Z/ {4 T2 N. S* w
delete (myMatrix *)me;
/ n7 I3 l) F, S( P1 h/ K: a
}
8 S! V6 x* s4 b7 O4 S! t
myMatrix * _stdcall NewMatrix(luVOID m,luVOID n) //生成一个myMatrix对象
/ I, o) K3 b9 S j5 n0 q3 L* t
{\\" B1 G+ ^0 D5 M% m5 k
myMatrix *pMatrix;/ B+ E+ `/ l3 E1 k\\" Y6 {* V
luVOID k;
6 D4 T2 B1 s4 c' R# K( z! n+ ?
double *pa;
' \( Q6 K G8 m3 k! }8 o0 S1 g0 O
char keyname[sizeof(luVOID)];
6 T( n; o( K4 P8 y# r& Z: M7 o
void *NowKey;9 ^\\" K9 d0 v) L6 r! j; t$ P7 m8 U3 A. K. R
k=m*n;( ^/ {; \3 ?) l' V
pMatrix=(myMatrix *)GetBufObj(Matrix,keyname);//先尝试从缓冲区中获取一个矩阵对象8 o5 F6 j2 b+ e
if(pMatrix)
, k$ A: N% P; C+ B
{
9 G7 ]& \- b/ ^: X, ~
if(pMatrix->ArrayLen!=k) //重置矩阵的大小
. Y7 p9 ~/ K& U a- J8 y
{
+ B+ w$ W. C! j) J% W8 h
pa=new double[k];! ^2 b# m# z ?; o( Y' i
if(!pa)
$ H R0 { y& U2 B. l
{
; ` V! y% _- d+ I' |; @/ o
DeleteKey(keyname,sizeof(luVOID),Matrix,DelMatrix,1); //将矩阵对象放回缓冲区% B! ?4 ?3 A8 w
return NULL;7 r& B1 ^# \( h9 ]
}9 h4 u; ]\\" H0 o$ q1 z
delete[] pMatrix->Array;+ O* B& n( e. D9 K% c k
pMatrix->Array=pa;
^7 r8 V, k, B\\" r, Z3 S
}
9 i. j, Z+ u7 z: R2 o6 M( K6 K' f' l
}9 N\\" ~\\" J) Q: y' B b8 g
else; g9 b- o2 w2 e5 d& j2 N
{
! Q2 V2 H\\" c# M; a
pMatrix=new myMatrix; //创建矩阵对象* a: Y: H\\" y# D# Z1 d. h, n8 V: Q
if(!pMatrix) return NULL;
3 e$ z/ J: ]/ c$ k
pMatrix->Array=new double[k];2 u7 {, K% R% B0 b$ [( N7 {
if(!pMatrix->Array)
, Y! @' N7 F; x& D& L
{
5 n$ W6 d! ?0 e! E; n
delete pMatrix;8 T. {6 m& \7 i2 J! ^5 |
return NULL;: q) V' n0 y! w+ C% Z, {
}% O4 q, d9 X9 [! q/ O6 e
if(InsertKey((char *)&pMatrix,-1,Matrix,pMatrix,DelMatrix,NULL,0,NowKey)) //将矩阵对象注册到Lu) X. Q$ q# n) l7 C* U6 B
{
6 j9 y( C\\" L- q4 F; }
delete pMatrix;\\" f6 V A U* E$ b\\" R9 j C
return NULL;
2 A& V( L F- \, y
}2 R1 B [( \- v
}7 `% z! a$ ~% p: G
pMatrix->ArrayLen=k; pMatrix->Dim[0]=m; pMatrix->Dim[1]=n;, P7 o# s+ f8 d* S2 c' c7 p7 ?
return pMatrix;
3 ^9 `: b/ }* H* i7 E6 i5 g& I
}\\" C* M- I4 {* L7 X1 z& h, P
LuData _stdcall OpMatrix(luINT mm,LuData *xx,void *hFor,int theOperator) //运算符重载函数，用于LockKey函数$ u- |: l. v, q X3 ^
{) b\\" h5 N8 W' S4 t/ p4 i6 t
LuData a;
5 ~0 H; ?9 g9 l* e\\" @# ?
myMatrix *pMatrix1,*pMatrix2,*pMatrix3;
% L9 j$ ^5 O- J* |- j+ P
luVOID i,j,k,m,n,u,v;) d% e/ M& o6 | o
double *pa,*pb,*pc;
: a1 T: e3 r6 L9 H K
luMessage pMessage;* j# S4 r1 A/ ]8 Z\\" r
wchar_t wchNum[32];- B; o( ~2 o G6 T
char chNum[32];0 b- y ~/ r. S
a.BType=luStaData_nil; a.VType=luStaData_nil; a.x=0;/ I& E2 R8 t R( [5 a# y+ U$ M0 o( o
switch(theOperator)
* z+ w4 y( j( k6 O, A
{
9 l% w1 [' W* M9 _0 v+ n% {5 u
case 2: //重载运算符*
- i& h6 S3 k& B+ U) e3 ?, E
pMatrix1=(myMatrix *)SearchKey((char *)&(xx->x),sizeof(luVOID),Matrix);
) y2 F! ^! ~3 ~* L3 v5 @8 {
pMatrix2=(myMatrix *)SearchKey((char *)&((xx+1)->x),sizeof(luVOID),Matrix);; e, U\\" ^; Q$ P& O9 o: m
if(!pMatrix1 || !pMatrix2) break; //对象句柄无效，不是矩阵# B, m6 ?) ^+ @5 O& O1 ]
if(pMatrix1->Dim[1]!=pMatrix2->Dim[0]) break; //维数不匹配 B5 c: H% K! D. t
pMatrix3=NewMatrix(pMatrix1->Dim[0],pMatrix2->Dim[1]); //生成新矩阵# m' \8 `) `! x8 ]6 l\\" L( `
if(!pMatrix3) break;% ?( b o+ i$ w' w& n1 @
pa=pMatrix1->Array; pb=pMatrix2->Array; pc=pMatrix3->Array;
( Z0 o+ u6 [3 P0 P\\" i\\" J
m=pMatrix1->Dim[0]; n=pMatrix1->Dim[1]; k=pMatrix2->Dim[1];, P& M\\" t9 f3 t9 w1 L- X1 e7 K1 M
for(i=0; i<m; i++) //矩阵乘
0 y* X( R& R- O% g
{+ G5 F L: M, K% {9 C
for(j=0; j<k; j++)
2 N, g3 p. k J z8 y
{
- h& q( k1 D D9 q8 t& E/ W; q$ f
u=i*k+j; pc[u]=0.0;0 Q6 J3 o$ ?4 x' f
for (v=0; v<n; v++)
V4 G1 e! C$ e
{\\" C. ~. r* `9 b3 z6 x
pc[u]=pc[u]+pa[i*n+v]*pb[v*k+j];5 n- w3 z+ S& B& `, B
}1 \! ~5 d9 }' W9 j
}6 M6 K5 w0 ]+ a* b
}
, W5 y; r9 g6 u/ O# j5 J
FunReObj(hFor); //告诉Lu，返回一个动态对象+ [1 c0 N: F1 |, Q
a.BType=Matrix; a.VType=Matrix; a.x=0; *(luVOID *)&(a.x)=(luVOID)pMatrix3;9 y3 j: m, ^: Z3 Y6 w9 S$ D5 j
break;4 v1 ^6 E# ?) }+ u$ a: k
case 25: //重载运算符.*
^5 ^* V' {# W
pMatrix1=(myMatrix *)SearchKey((char *)&(xx->x),sizeof(luVOID),Matrix);
& {: }/ r+ L3 e& i% w; c
pMatrix2=(myMatrix *)SearchKey((char *)&((xx+1)->x),sizeof(luVOID),Matrix);: A9 x* \/ ~4 J8 J; ?5 h
if(!pMatrix1 || !pMatrix2) break; //对象句柄无效，不是矩阵- o: r( `+ [1 p/ L% E6 a6 ?
if(pMatrix1->Dim[0]!=pMatrix2->Dim[0] || pMatrix1->Dim[1]!=pMatrix2->Dim[1]) break; //维数不相同& m3 Y: I7 I% ~
pMatrix3=NewMatrix(pMatrix1->Dim[0],pMatrix1->Dim[1]); //生成新矩阵' G8 n. L4 r4 \+ U0 a
if(!pMatrix3) break;9 f# n/ {, H8 L
for(i=0;i<pMatrix1->ArrayLen;i++) pMatrix3->Array[i]=pMatrix1->Array[i]*pMatrix2->Array[i]; //矩阵点乘
2 c. ]2 d, U8 _' j0 D
FunReObj(hFor); //告诉Lu，返回一个动态对象
% [! l @( Q; d7 l' D+ |! g
a.BType=Matrix; a.VType=Matrix; a.x=0; *(luVOID *)&(a.x)=(luVOID)pMatrix3;! _. s$ Q- ]; F& V6 C& z
break;
8 Z( ~0 f/ J+ {: @1 J c3 a* ~\\" _
case 46: //重载函数new5 N/ y! t0 p3 s% U+ u: W, v
if(mm<2) break;+ M5 \# Q1 F7 ^) h
if((xx+1)->x<1 || (xx+2)->x<1 || (xx+1)->BType!=luStaData_int64 || (xx+2)->BType!=luStaData_int64) break;$ U\\" C( v+ |5 Z, `! S! t. H0 x
pMatrix3=NewMatrix((luVOID)(xx+1)->x,(luVOID)(xx+2)->x);//生成新矩阵, F9 ^# u! ?$ J7 E* Q- J4 J* ]
if(!pMatrix3) break;& \+ _2 g6 l( a7 u0 T7 f
for(j=0,i=3;i<=mm;i++,j++) //赋初值% o9 }\\" c) B9 k8 l1 x
{
0 H0 Y3 g- A% H1 r& v
if(j>=pMatrix3->ArrayLen) break;' T5 E$ l1 v* `8 n$ V: b! \
if((xx+i)->BType!=luStaData_double) break; //只接受实数参数
( \+ R0 G/ Y# f8 z3 ^2 V
pMatrix3->Array[j]=*(double *)&((xx+i)->x);
/ @9 H& Y1 W\\" r1 ~& {7 Y; M
}
6 _) L+ q/ D8 |
FunReObj(hFor); //告诉Lu，返回一个动态对象% H3 {) N+ r/ r0 B% D+ X7 J
a.BType=Matrix; a.VType=Matrix; a.x=0; *(luVOID *)&(a.x)=(luVOID)pMatrix3;$ A$ z6 Q, h2 ^# \. t7 ~
break;
1 k5 ]$ f) v1 _( Y# U
case 49: //重载函数o6 y9 A1 X\\" e. _: A5 j) I, m# V
pMessage=(luMessage)SearchKey("\0\0\0\0",sizeof(luVOID),luPubKey_User);
. i ]% F+ e7 j7 r# i
if(!pMessage) break;: B& N4 }. {9 |5 g( x
pMatrix1=(myMatrix *)SearchKey((char *)&(xx->x),sizeof(luVOID),Matrix);& M: n\\" U* Z% e# d! {$ F& o+ Z& T+ u
if(!pMatrix1) break; //对象句柄无效，不是矩阵0 v) O6 f+ e$ ?3 f* T
pa=pMatrix1->Array;
/ ?* w/ [4 U% ]2 V5 x2 J
m=pMatrix1->Dim[0]; n=pMatrix1->Dim[1]; k=0;
% i- F) c/ f1 g2 g# a0 C
for(i=0; i<m; i++) //输出矩阵\\" k5 K7 T1 r+ j5 w# _) Q1 O3 Y9 L& S
{; r9 y\\" y\\" K- q
pMessage(L"\r\n"); k+=2;
' f( a/ p2 z3 g6 y, J/ B
for(j=0; j<n; j++)$ P$ @8 E6 O0 v\\" ]' D+ A
{
( l0 P5 V7 I' [
_gcvt_s(chNum,pa[i*n+j],16);5 O/ z\\" @4 \' Y+ O# F
for(u=0;chNum[u];u++) {wchNum[u]=chNum[u]; k++;}1 [- `; v0 U* q2 I) R6 c0 J
wchNum[u]='\0';
6 f* i _: r) W; n7 I
pMessage(wchNum); pMessage(L" "); k+=2;
g! n- Q9 q! V. | C& N! W- A
}
: G: O& y& x, E* A( D, Q6 K! M
}; b3 w2 }! i; u; p
pMessage(L"\r\n"); k+=2;# `$ E1 ]+ R* x% U\\" K# G. ?
a.BType=luStaData_int64; a.VType=luStaData_int64; a.x=k; //按函数o的要求，返回输出的字符总数( ^% K' y- F S: f
break;
2 A$ w' I* J) r9 M& ~9 J
default:
2 x, k6 @: Z/ N8 l! o; ^
break;
: L; L1 }6 Z4 b$ q5 _: p
}( I. M* H/ a$ z- h2 A* l3 c
return a;. F2 D0 L- e9 @) Z' P) K9 @
}3 G a2 A8 D; o3 z6 J
void main(void)* e\\" d1 [* x z$ o: W2 ~
{
8 b9 K( b: Z. N* E* I+ v4 i
void *hFor; //表达式句柄3 Q7 ?3 i, H8 b/ P
luINT nPara; //存放表达式的自变量个数
4 h& Y( X' v) w) ^5 `8 p7 e
LuData *pPara; //存放输入自变量的数组指针3 I5 b: |% J3 M+ t2 P$ A6 L' Q
luINT ErrBegin,ErrEnd; //表达式编译出错的初始位置和结束位置
Z\\" ~5 t1 _0 Q) Z# B* E
int ErrCode; //错误代码* h% b) e# Q/ H M( ^8 M
void *v;% Z' k; A1 U: @
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.]}";//字符串表达式，矩阵乘& ?7 `6 h3 ?7 |8 j; }& Q8 }: z
//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.]}";//字符串表达式，矩阵点乘( B8 l7 @' u- D$ ^
LuData Val;7 i* y+ `+ |' E+ L$ V2 q |
if(!InitLu()) return; //初始化Lu
) M; S9 V0 ]4 q\\" r
while(LockKey(Matrix,DelMatrix,OpMatrix)){Matrix--;} //锁定一个键，用于存储矩阵扩展类型3 K7 P. q- I! _ p% I* _: j
; k G9 Z. N+ e6 w& [\\" i) B
Val.BType=luStaData_int64; Val.VType=luStaData_int64; Val.x=Matrix; //定义整数常量
, ^- s+ v2 W* G. `7 F9 L
SetConst(L"matrix",&Val); //设置整数常量
8 h3 d$ B' r. h' L! J9 p2 P
InsertKey("\0\0\0\0",4,luPubKey_User,LuMessage,NULL,NULL,1,v); //使Lu运行时可输出函数信息
8 V9 V. n) B4 P! a( r& S6 l
wcout.imbue(locale("chs")); //设置输出的locale为中文' w( {/ x9 r$ l3 @
2 t# F; B7 L4 W5 Q3 o
ErrCode=LuCom(ForStr,0,0,0,hFor,nPara,pPara,ErrBegin,ErrEnd); //编译表达式& @+ @! u- L/ E9 [2 s! \$ {7 s; M
if(ErrCode)
! q0 d* b' E# ^9 i
{, y4 T/ }9 _; Z# @
wcout<<L"表达式有错误！错误代码："<<ErrCode<<endl;
/ s9 m: a3 Z$ a! E
}
! m% b7 O) ?, P3 J& n7 X8 ?
else6 ]7 u, X: R3 A$ W/ [ o
{* Z' {, C( R+ G; a; Q
LuCal(hFor,pPara); //计算表达式的值' J# g& P' S0 Q, |: \ @# c* j9 _
}
0 a+ N# W. N2 b2 N: I6 O0 y
LockKey(Matrix,NULL,OpMatrix);//解锁键Matrix，本例中，该函数可以不用# y& \) R# N; w O& k
FreeLu(); //释放Lu
! [/ W/ y+ n4 W$ {/ R
}

#include <windows.h> 
5 C/ G( _# k3 f9 w
#include <iostream> 
  V8 ]5 f3 o! q8 u3 q0 _# f/ i* h
#include <math.h> 
. k8 R, ^, d  k2 r
#include "lu32.h" 
1 A\\" D' H! @* M8 Y( k
#pragma comment( lib, "lu32.lib" )/ ?1 `. A1 g- g0 z& y

using namespace std;$ r7 ]$ u; B0 r7 n7 {( l1 Q

//自定义矩阵 
# Z$ Z4 l: x$ c3 U
class myMatrix 
# C! I6 F* I/ U4 h
{( s2 q2 P, A) g

public: 
5 X\\" c9 R$ P, e1 @\\" q7 @# I
        double *Array;        //数据缓冲区$ X9 {/ ^4 F6 O4 ^

luVOID ArrayLen;        //数据缓冲区长度 
( e  `' ^  T/ }
        luVOID Dim[2];        //矩阵维数 
% q0 y2 o6 \: S' u% P# V
        myMatrix(){Array=NULL; ArrayLen=0; Dim[0]=0; Dim[1]=0;} 
+ X- |/ ?& C$ r+ _# W
        ~myMatrix()' z% Z5 \  \3 V1 \# n

{ 
) g1 K# z6 W/ s+ @5 a: S& ?
                if(Array) delete[] Array;* c! E+ j2 e! t7 r3 S1 c& U/ w! l

}1 }' K- C3 a1 b# K$ W9 l

};2 P+ W7 o' x/ ?  R7 E' j

luKEY Matrix=-1000;        //标识矩阵类型，最终的Matrix由LockKey决定 
3 q% ?' d0 c/ o& ]\\" p9 i0 [
void _stdcall LuMessage(wchar_t *pch)//输出动态库信息，该函数注册到Lu，由Lu二级函数调用 
2 H- N& b6 B8 ~8 K' S; _7 W+ F
{- j. v$ u- b7 {( m

wcout<<pch;3 [% |% _; B3 H* p, k2 L3 N4 L0 c

} 
7 P* ~  \; e\\" z# N* b& c
void _stdcall DelMatrix(void *me)        //用于LockKey函数及InsertKey函数，使Lu能自动销毁myMatrix对象 
6 c1 b' o! a0 N2 Y& A8 W
{ 
1 V8 ?4 H$ Z/ {4 T2 N. S* w
        delete (myMatrix *)me; 
/ n7 I3 l) F, S( P1 h/ K: a
} 
8 S! V6 x* s4 b7 O4 S! t
myMatrix * _stdcall NewMatrix(luVOID m,luVOID n)        //生成一个myMatrix对象 
/ I, o) K3 b9 S  j5 n0 q3 L* t
{\\" B1 G+ ^0 D5 M% m5 k

myMatrix *pMatrix;/ B+ E+ `/ l3 E1 k\\" Y6 {* V

luVOID k; 
6 D4 T2 B1 s4 c' R# K( z! n+ ?
        double *pa; 
' \( Q6 K  G8 m3 k! }8 o0 S1 g0 O
        char keyname[sizeof(luVOID)]; 
6 T( n; o( K4 P8 y# r& Z: M7 o
        void *NowKey;9 ^\\" K9 d0 v) L6 r! j; t$ P7 m8 U3 A. K. R

k=m*n;( ^/ {; \3 ?) l' V

pMatrix=(myMatrix *)GetBufObj(Matrix,keyname);//先尝试从缓冲区中获取一个矩阵对象8 o5 F6 j2 b+ e

if(pMatrix) 
, k$ A: N% P; C+ B
        { 
9 G7 ]& \- b/ ^: X, ~
                if(pMatrix->ArrayLen!=k)        //重置矩阵的大小 
. Y7 p9 ~/ K& U  a- J8 y
                { 
+ B+ w$ W. C! j) J% W8 h
                        pa=new double[k];! ^2 b# m# z  ?; o( Y' i

if(!pa) 
$ H  R0 {  y& U2 B. l
                        { 
; `  V! y% _- d+ I' |; @/ o
                                DeleteKey(keyname,sizeof(luVOID),Matrix,DelMatrix,1);        //将矩阵对象放回缓冲区% B! ?4 ?3 A8 w

return NULL;7 r& B1 ^# \( h9 ]

}9 h4 u; ]\\" H0 o$ q1 z

delete[] pMatrix->Array;+ O* B& n( e. D9 K% c  k

pMatrix->Array=pa; 
  ^7 r8 V, k, B\\" r, Z3 S
                } 
9 i. j, Z+ u7 z: R2 o6 M( K6 K' f' l
        }9 N\\" ~\\" J) Q: y' B  b8 g

else; g9 b- o2 w2 e5 d& j2 N

{ 
! Q2 V2 H\\" c# M; a
                pMatrix=new myMatrix;        //创建矩阵对象* a: Y: H\\" y# D# Z1 d. h, n8 V: Q

if(!pMatrix) return NULL; 
3 e$ z/ J: ]/ c$ k
                pMatrix->Array=new double[k];2 u7 {, K% R% B0 b$ [( N7 {

if(!pMatrix->Array) 
, Y! @' N7 F; x& D& L
                { 
5 n$ W6 d! ?0 e! E; n
                        delete pMatrix;8 T. {6 m& \7 i2 J! ^5 |

return NULL;: q) V' n0 y! w+ C% Z, {

}% O4 q, d9 X9 [! q/ O6 e

if(InsertKey((char *)&pMatrix,-1,Matrix,pMatrix,DelMatrix,NULL,0,NowKey))        //将矩阵对象注册到Lu) X. Q$ q# n) l7 C* U6 B

{ 
6 j9 y( C\\" L- q4 F; }
                        delete pMatrix;\\" f6 V  A  U* E$ b\\" R9 j  C

return NULL; 
2 A& V( L  F- \, y
                }2 R1 B  [( \- v

}7 `% z! a$ ~% p: G

pMatrix->ArrayLen=k; pMatrix->Dim[0]=m; pMatrix->Dim[1]=n;, P7 o# s+ f8 d* S2 c' c7 p7 ?

return pMatrix; 
3 ^9 `: b/ }* H* i7 E6 i5 g& I
}\\" C* M- I4 {* L7 X1 z& h, P

LuData _stdcall OpMatrix(luINT mm,LuData *xx,void *hFor,int theOperator)        //运算符重载函数，用于LockKey函数$ u- |: l. v, q  X3 ^

{) b\\" h5 N8 W' S4 t/ p4 i6 t

LuData a; 
5 ~0 H; ?9 g9 l* e\\" @# ?
        myMatrix *pMatrix1,*pMatrix2,*pMatrix3; 
% L9 j$ ^5 O- J* |- j+ P
        luVOID i,j,k,m,n,u,v;) d% e/ M& o6 |  o

double *pa,*pb,*pc; 
: a1 T: e3 r6 L9 H  K
        luMessage pMessage;* j# S4 r1 A/ ]8 Z\\" r

wchar_t wchNum[32];- B; o( ~2 o  G6 T

char chNum[32];0 b- y  ~/ r. S

a.BType=luStaData_nil; a.VType=luStaData_nil; a.x=0;/ I& E2 R8 t  R( [5 a# y+ U$ M0 o( o

switch(theOperator) 
* z+ w4 y( j( k6 O, A
        { 
9 l% w1 [' W* M9 _0 v+ n% {5 u
        case 2:        //重载运算符* 
- i& h6 S3 k& B+ U) e3 ?, E
                pMatrix1=(myMatrix *)SearchKey((char *)&(xx->x),sizeof(luVOID),Matrix); 
) y2 F! ^! ~3 ~* L3 v5 @8 {
                pMatrix2=(myMatrix *)SearchKey((char *)&((xx+1)->x),sizeof(luVOID),Matrix);; e, U\\" ^; Q$ P& O9 o: m

if(!pMatrix1 || !pMatrix2) break;        //对象句柄无效，不是矩阵# B, m6 ?) ^+ @5 O& O1 ]

if(pMatrix1->Dim[1]!=pMatrix2->Dim[0]) break;        //维数不匹配  B5 c: H% K! D. t

pMatrix3=NewMatrix(pMatrix1->Dim[0],pMatrix2->Dim[1]);        //生成新矩阵# m' \8 `) `! x8 ]6 l\\" L( `

if(!pMatrix3) break;% ?( b  o+ i$ w' w& n1 @

pa=pMatrix1->Array; pb=pMatrix2->Array; pc=pMatrix3->Array; 
( Z0 o+ u6 [3 P0 P\\" i\\" J
                m=pMatrix1->Dim[0]; n=pMatrix1->Dim[1]; k=pMatrix2->Dim[1];, P& M\\" t9 f3 t9 w1 L- X1 e7 K1 M

for(i=0; i<m; i++)        //矩阵乘 
0 y* X( R& R- O% g
                {+ G5 F  L: M, K% {9 C

for(j=0; j<k; j++) 
2 N, g3 p. k  J  z8 y
                        { 
- h& q( k1 D  D9 q8 t& E/ W; q$ f
                                u=i*k+j; pc[u]=0.0;0 Q6 J3 o$ ?4 x' f

for (v=0; v<n; v++) 
  V4 G1 e! C$ e
                                {\\" C. ~. r* `9 b3 z6 x

pc[u]=pc[u]+pa[i*n+v]*pb[v*k+j];5 n- w3 z+ S& B& `, B

}1 \! ~5 d9 }' W9 j

}6 M6 K5 w0 ]+ a* b

} 
, W5 y; r9 g6 u/ O# j5 J
                FunReObj(hFor);        //告诉Lu，返回一个动态对象+ [1 c0 N: F1 |, Q

a.BType=Matrix; a.VType=Matrix; a.x=0; *(luVOID *)&(a.x)=(luVOID)pMatrix3;9 y3 j: m, ^: Z3 Y6 w9 S$ D5 j

break;4 v1 ^6 E# ?) }+ u$ a: k

case 25:        //重载运算符.* 
  ^5 ^* V' {# W
                pMatrix1=(myMatrix *)SearchKey((char *)&(xx->x),sizeof(luVOID),Matrix); 
& {: }/ r+ L3 e& i% w; c
                pMatrix2=(myMatrix *)SearchKey((char *)&((xx+1)->x),sizeof(luVOID),Matrix);: A9 x* \/ ~4 J8 J; ?5 h

if(!pMatrix1 || !pMatrix2) break;        //对象句柄无效，不是矩阵- o: r( `+ [1 p/ L% E6 a6 ?

if(pMatrix1->Dim[0]!=pMatrix2->Dim[0] || pMatrix1->Dim[1]!=pMatrix2->Dim[1]) break;        //维数不相同& m3 Y: I7 I% ~

pMatrix3=NewMatrix(pMatrix1->Dim[0],pMatrix1->Dim[1]);        //生成新矩阵' G8 n. L4 r4 \+ U0 a

if(!pMatrix3) break;9 f# n/ {, H8 L

for(i=0;i<pMatrix1->ArrayLen;i++) pMatrix3->Array[i]=pMatrix1->Array[i]*pMatrix2->Array[i];        //矩阵点乘 
2 c. ]2 d, U8 _' j0 D
                FunReObj(hFor);        //告诉Lu，返回一个动态对象 
% [! l  @( Q; d7 l' D+ |! g
                a.BType=Matrix; a.VType=Matrix; a.x=0; *(luVOID *)&(a.x)=(luVOID)pMatrix3;! _. s$ Q- ]; F& V6 C& z

break; 
8 Z( ~0 f/ J+ {: @1 J  c3 a* ~\\" _
        case 46:        //重载函数new5 N/ y! t0 p3 s% U+ u: W, v

if(mm<2) break;+ M5 \# Q1 F7 ^) h

if((xx+1)->x<1 || (xx+2)->x<1 || (xx+1)->BType!=luStaData_int64 || (xx+2)->BType!=luStaData_int64) break;$ U\\" C( v+ |5 Z, `! S! t. H0 x

pMatrix3=NewMatrix((luVOID)(xx+1)->x,(luVOID)(xx+2)->x);//生成新矩阵, F9 ^# u! ?$ J7 E* Q- J4 J* ]

if(!pMatrix3) break;& \+ _2 g6 l( a7 u0 T7 f

for(j=0,i=3;i<=mm;i++,j++)        //赋初值% o9 }\\" c) B9 k8 l1 x

{ 
0 H0 Y3 g- A% H1 r& v
                        if(j>=pMatrix3->ArrayLen) break;' T5 E$ l1 v* `8 n$ V: b! \

if((xx+i)->BType!=luStaData_double) break;        //只接受实数参数 
( \+ R0 G/ Y# f8 z3 ^2 V
                        pMatrix3->Array[j]=*(double *)&((xx+i)->x); 
/ @9 H& Y1 W\\" r1 ~& {7 Y; M
                } 
6 _) L+ q/ D8 |
                FunReObj(hFor);        //告诉Lu，返回一个动态对象% H3 {) N+ r/ r0 B% D+ X7 J

a.BType=Matrix; a.VType=Matrix; a.x=0; *(luVOID *)&(a.x)=(luVOID)pMatrix3;$ A$ z6 Q, h2 ^# \. t7 ~

break; 
1 k5 ]$ f) v1 _( Y# U
        case 49:        //重载函数o6 y9 A1 X\\" e. _: A5 j) I, m# V

pMessage=(luMessage)SearchKey("\0\0\0\0",sizeof(luVOID),luPubKey_User); 
. i  ]% F+ e7 j7 r# i
                if(!pMessage) break;: B& N4 }. {9 |5 g( x

pMatrix1=(myMatrix *)SearchKey((char *)&(xx->x),sizeof(luVOID),Matrix);& M: n\\" U* Z% e# d! {$ F& o+ Z& T+ u

if(!pMatrix1) break;        //对象句柄无效，不是矩阵0 v) O6 f+ e$ ?3 f* T

pa=pMatrix1->Array; 
/ ?* w/ [4 U% ]2 V5 x2 J
                m=pMatrix1->Dim[0]; n=pMatrix1->Dim[1]; k=0; 
% i- F) c/ f1 g2 g# a0 C
                for(i=0; i<m; i++)        //输出矩阵\\" k5 K7 T1 r+ j5 w# _) Q1 O3 Y9 L& S

{; r9 y\\" y\\" K- q

pMessage(L"\r\n"); k+=2; 
' f( a/ p2 z3 g6 y, J/ B
                        for(j=0; j<n; j++)$ P$ @8 E6 O0 v\\" ]' D+ A

{ 
( l0 P5 V7 I' [
                                _gcvt_s(chNum,pa[i*n+j],16);5 O/ z\\" @4 \' Y+ O# F

for(u=0;chNum[u];u++) {wchNum[u]=chNum[u]; k++;}1 [- `; v0 U* q2 I) R6 c0 J

wchNum[u]='\0'; 
6 f* i  _: r) W; n7 I
                                pMessage(wchNum); pMessage(L"  "); k+=2; 
  g! n- Q9 q! V. |  C& N! W- A
                        } 
: G: O& y& x, E* A( D, Q6 K! M
                }; b3 w2 }! i; u; p

pMessage(L"\r\n"); k+=2;# `$ E1 ]+ R* x% U\\" K# G. ?

a.BType=luStaData_int64; a.VType=luStaData_int64; a.x=k;        //按函数o的要求，返回输出的字符总数( ^% K' y- F  S: f

break; 
2 A$ w' I* J) r9 M& ~9 J
        default: 
2 x, k6 @: Z/ N8 l! o; ^
                break; 
: L; L1 }6 Z4 b$ q5 _: p
        }( I. M* H/ a$ z- h2 A* l3 c

return a;. F2 D0 L- e9 @) Z' P) K9 @

}3 G  a2 A8 D; o3 z6 J

void main(void)* e\\" d1 [* x  z$ o: W2 ~

{ 
8 b9 K( b: Z. N* E* I+ v4 i
        void *hFor;                //表达式句柄3 Q7 ?3 i, H8 b/ P

luINT nPara;                //存放表达式的自变量个数 
4 h& Y( X' v) w) ^5 `8 p7 e
        LuData *pPara;                //存放输入自变量的数组指针3 I5 b: |% J3 M+ t2 P$ A6 L' Q

luINT ErrBegin,ErrEnd;        //表达式编译出错的初始位置和结束位置 
  Z\\" ~5 t1 _0 Q) Z# B* E
        int ErrCode;                //错误代码* h% b) e# Q/ H  M( ^8 M

void *v;% Z' k; A1 U: @

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.]}";//字符串表达式，矩阵乘& ?7 `6 h3 ?7 |8 j; }& Q8 }: z

//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.]}";//字符串表达式，矩阵点乘( B8 l7 @' u- D$ ^

LuData Val;7 i* y+ `+ |' E+ L$ V2 q  |

if(!InitLu()) return;        //初始化Lu 
) M; S9 V0 ]4 q\\" r
        while(LockKey(Matrix,DelMatrix,OpMatrix)){Matrix--;}        //锁定一个键，用于存储矩阵扩展类型3 K7 P. q- I! _  p% I* _: j

; k  G9 Z. N+ e6 w& [\\" i) B
        Val.BType=luStaData_int64; Val.VType=luStaData_int64; Val.x=Matrix;        //定义整数常量 
, ^- s+ v2 W* G. `7 F9 L
        SetConst(L"matrix",&Val);        //设置整数常量 
8 h3 d$ B' r. h' L! J9 p2 P
        InsertKey("\0\0\0\0",4,luPubKey_User,LuMessage,NULL,NULL,1,v); //使Lu运行时可输出函数信息 
8 V9 V. n) B4 P! a( r& S6 l
        wcout.imbue(locale("chs"));        //设置输出的locale为中文' w( {/ x9 r$ l3 @

2 t# F; B7 L4 W5 Q3 o

ErrCode=LuCom(ForStr,0,0,0,hFor,nPara,pPara,ErrBegin,ErrEnd); //编译表达式& @+ @! u- L/ E9 [2 s! \$ {7 s; M

if(ErrCode) 
! q0 d* b' E# ^9 i
        {, y4 T/ }9 _; Z# @

wcout<<L"表达式有错误！错误代码："<<ErrCode<<endl; 
/ s9 m: a3 Z$ a! E
        } 
! m% b7 O) ?, P3 J& n7 X8 ?
        else6 ]7 u, X: R3 A$ W/ [  o

{* Z' {, C( R+ G; a; Q

LuCal(hFor,pPara);        //计算表达式的值' J# g& P' S0 Q, |: \  @# c* j9 _

} 
0 a+ N# W. N2 b2 N: I6 O0 y
        LockKey(Matrix,NULL,OpMatrix);//解锁键Matrix，本例中，该函数可以不用# y& \) R# N; w  O& k

FreeLu();                        //释放Lu 
! [/ W/ y+ n4 W$ {/ R
}

习题：

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

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

main(:a,b,c,d,t,i)=, k( Q0 T- z4 V5 R# {
a=new[matrix,2,2: 1.,2.,2.,1.],
+ Y0 o U8 L. K& d: a5 @. l
b=new[matrix,2,2: 2.,1.,1.,2.],
# j- F( B- Z7 B- \# q8 M\" w7 a0 g* N
c=new[matrix,2,2: 2/3.,-1/3.,-1/3.,2/3.],
: \/ y2 E0 L- K- E- _) y) ]
t=clock(),
5 L$ ^8 O5 P: B' [
d=a*b, i=0, while{i<1000000, d=d*c*b, i++},
* Y/ Z: @9 N! Y+ M% ^
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\"}";//字符串表达式

复制代码

结果：