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

查看: 7666|回复: 0

在Lu中创建自定义数据类型，小矩阵乘效率测试

[复制链接]

字体大小: 正常放大

forcal

45 主题	3 听众	282 积分

升级 91%

TA的每日心情

	难过 2012-8-27 18:22

签到天数: 1 天

[LV.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- R6 n7 A5 F$ D- c; ]
#include <iostream>/ H: q1 {* G9 m8 N; f
#include <math.h>+ T: K/ p N2 N% E; Y
#include "lu32.h"
' c$ D$ `' A/ Q5 J
#pragma comment( lib, "lu32.lib" )
. E6 j2 Y' l4 D* `5 h! h
using namespace std;
+ V+ u1 o\\" S2 ?+ ~7 K7 j
//自定义矩阵
8 T0 y- w2 X6 \. H
class myMatrix A9 _4 {8 H* I: {6 x8 J# r I
{
/ [\\" q) C) l# O/ z% F
public:
& m/ Q- }4 q, ~$ {3 M1 K
double *Array; //数据缓冲区8 d0 c9 g3 F. b4 @; z' h( w
luVOID ArrayLen; //数据缓冲区长度
6 u! A3 E+ {1 }9 z* K. X
luVOID Dim[2]; //矩阵维数
6 ^ X+ k+ @\\" |* t7 y
myMatrix(){Array=NULL; ArrayLen=0; Dim[0]=0; Dim[1]=0;}
% E5 Q' x. N+ Q' A' T
~myMatrix()
8 }8 i8 I) J, Y\\" X3 r, S! E
{7 h: U1 W2 r: ~7 C7 f
if(Array) delete[] Array;! e/ V: D% r0 w
}; m$ d+ p' `/ t* D2 ]$ ?
};# `6 E' I: K ~, D: A/ h
luKEY Matrix=-1000; //标识矩阵类型，最终的Matrix由LockKey决定
7 o$ t( o\\" p3 G- f' ^& O
void _stdcall LuMessage(wchar_t *pch)//输出动态库信息，该函数注册到Lu，由Lu二级函数调用
5 _# N# ^! ]\\" e3 o/ O% \* |) q
{8 t: F; H( l' \
wcout<<pch;8 N\\" q& E3 G5 T! |9 s
}: A5 s- R, N2 v+ z
void _stdcall DelMatrix(void *me) //用于LockKey函数及InsertKey函数，使Lu能自动销毁myMatrix对象
7 K& @8 a% ^) u+ s$ v. W
{' r4 n- _ J* Z\\" D
delete (myMatrix *)me;
9 w9 W. z! P; s2 j9 K; K' J
}; l! y* v- l+ l( P+ w* U
myMatrix * _stdcall NewMatrix(luVOID m,luVOID n) //生成一个myMatrix对象% W! V. p* ^! `
{
9 S% [7 c6 |3 a; ^: t v
myMatrix *pMatrix;8 E( w! `: c6 ^$ M7 o\\" p
luVOID k;\\" W, `\\" V8 h3 z
double *pa;
/ r, T4 J$ _4 J/ k9 P, y! r2 Q h& q
char keyname[sizeof(luVOID)];$ [5 J# e\\" w' |3 @6 P- D- [+ N
void *NowKey;$ `5 Y3 B( v\\" d3 M; T* W
k=m*n;+ w* R, p- [, }
pMatrix=(myMatrix *)GetBufObj(Matrix,keyname);//先尝试从缓冲区中获取一个矩阵对象
/ E8 ? Q$ H! h( v) ]7 Q
if(pMatrix)
3 {( G4 P; S) h# Q- ?: w6 i- r
{0 ?3 b4 A6 d6 G' q6 u7 p3 T3 c; \6 |
if(pMatrix->ArrayLen!=k) //重置矩阵的大小5 G6 b0 G; c0 R: z* T
{
0 W- q6 P; f+ _
pa=new double[k];
5 E/ v, R9 j/ Z\\" L) a
if(!pa)8 }% f: M, ^0 k% I
{+ e, r2 t, H: [) V
DeleteKey(keyname,sizeof(luVOID),Matrix,DelMatrix,1); //将矩阵对象放回缓冲区/ W. t\\" k' K: e# Z
return NULL;3 g! l+ L; M0 X\\" s1 k
}
8 n- ?$ `( U* d! j0 B
delete[] pMatrix->Array;% p8 M T+ L, v$ [* I
pMatrix->Array=pa;
( o( v, F7 b& V% Y
}
# E# N( ^# @! x2 g' j% |: v
}
: k3 P( o2 q: N: t& T. T- K
else
! |; n, N3 P; M. O2 ^) N
{
9 K8 }3 h# w' @% A- q6 ?( k
pMatrix=new myMatrix; //创建矩阵对象
# P4 R9 h3 V# N# h# {2 n; e4 r
if(!pMatrix) return NULL;
# k/ m9 _$ m- L7 O; w+ f+ G
pMatrix->Array=new double[k];+ S- Q# D9 b) V$ p7 S
if(!pMatrix->Array)
7 N& W x! Z7 c8 E- B* |
{
) S0 ?3 a4 O' u) C4 `
delete pMatrix;2 g/ a( M; Z& g0 q0 C. L2 N' N
return NULL;. k9 g6 z+ o/ }! V0 ?3 h
}
P8 W- x; M6 d9 ]: o5 P, g
if(InsertKey((char *)&pMatrix,-1,Matrix,pMatrix,DelMatrix,NULL,0,NowKey)) //将矩阵对象注册到Lu# d8 g) M& r+ Y
{\\" d3 U3 @: ~4 w+ Y; Z( V; N5 P
delete pMatrix;- @2 L$ L3 D5 A+ [
return NULL;( o: F) a& R: ^! G) Q
}
$ X* ~$ m i% o6 E' i, e; A; R' W
}
: Y# V8 I\\" b. s) g) [
pMatrix->ArrayLen=k; pMatrix->Dim[0]=m; pMatrix->Dim[1]=n;
: F. N8 s1 [; s9 E
return pMatrix;: F7 ?+ h% e( r) {
}
9 @; X; j( v* G2 ?5 E6 y
LuData _stdcall OpMatrix(luINT mm,LuData *xx,void *hFor,int theOperator) //运算符重载函数，用于LockKey函数
5 n/ l4 f8 X1 E, d$ t0 X9 n. u
{
6 c' v0 C' |! q5 y\\" e7 C
LuData a;( C! e. ]4 V/ t/ v# \0 n
myMatrix *pMatrix1,*pMatrix2,*pMatrix3;\\" E6 a8 C- r5 u4 d5 x7 ?
luVOID i,j,k,m,n,u,v;\\" y3 W9 b: k7 W C\\" O; b% c! `( m
double *pa,*pb,*pc;
7 H7 k2 \5 w$ T' y
luMessage pMessage;
8 W# N) d& e' E( h* ^# H6 d: {. q
wchar_t wchNum[32];! j, o1 {/ p\\" J\\" }9 x6 d4 x4 v
char chNum[32];' q8 g) P M! s# t
a.BType=luStaData_nil; a.VType=luStaData_nil; a.x=0;: y! t\\" v+ t0 O
switch(theOperator); M0 Z6 {\\" @/ Q2 E% I2 p* p
{\\" }; k2 @. r) Z0 X* v/ \; `
case 2: //重载运算符*! ?) ~1 o, {- q8 }& t4 t$ i3 N
pMatrix1=(myMatrix *)SearchKey((char *)&(xx->x),sizeof(luVOID),Matrix);
+ U1 b a; H. _5 O\\" ^% \+ B6 z
pMatrix2=(myMatrix *)SearchKey((char *)&((xx+1)->x),sizeof(luVOID),Matrix);: V ]: X! U( \. e\\" t# G# }6 k
if(!pMatrix1 || !pMatrix2) break; //对象句柄无效，不是矩阵
6 B8 U* e- z4 d( J7 W1 i\\" @
if(pMatrix1->Dim[1]!=pMatrix2->Dim[0]) break; //维数不匹配* F1 X* p\\" K9 ?
pMatrix3=NewMatrix(pMatrix1->Dim[0],pMatrix2->Dim[1]); //生成新矩阵
9 n% |: f* ~- W4 W2 Z, U# ?2 ^
if(!pMatrix3) break;6 |$ ^% O5 z9 V( a3 ^1 ]7 \
pa=pMatrix1->Array; pb=pMatrix2->Array; pc=pMatrix3->Array;3 f( c. z T/ d, c# R
m=pMatrix1->Dim[0]; n=pMatrix1->Dim[1]; k=pMatrix2->Dim[1];
: d! Y. L\\" M$ e8 Z3 t6 y9 s7 V8 \
for(i=0; i<m; i++) //矩阵乘
0 w0 S# l$ ^$ ?% Z7 f) w
{
! \4 D8 z0 t% e. g) Y9 l* q0 n: r
for(j=0; j<k; j++)& j\\" Y; _- y, Y' \. q& _- R
{
$ e7 d$ n! i. @- P
u=i*k+j; pc[u]=0.0;/ m5 \; B7 x/ L8 O/ w7 k
for (v=0; v<n; v++)
$ {; Q5 o w5 D+ Y0 e& y3 [
{% W4 T/ l; u* Y- ]# s* n: I1 w
pc[u]=pc[u]+pa[i*n+v]*pb[v*k+j];
6 F9 w% T5 Q) R1 f# e
}
+ [ C1 Q9 e H3 g. ]# j
}
\\" n( J* v# c% d3 K$ e2 z7 N5 O
}
' m8 R& V- K0 X\\" \( B
FunReObj(hFor); //告诉Lu，返回一个动态对象* w8 `+ c% i. ?6 A9 b6 f
a.BType=Matrix; a.VType=Matrix; a.x=0; *(luVOID *)&(a.x)=(luVOID)pMatrix3;/ W& @( t2 n/ t; c: n* P
break;; [ f+ t3 T% t2 }
case 25: //重载运算符.*
3 ]! }\\" | k\\" B: Q! w! P
pMatrix1=(myMatrix *)SearchKey((char *)&(xx->x),sizeof(luVOID),Matrix);7 |3 _/ a# t8 N: t; c2 k1 w
pMatrix2=(myMatrix *)SearchKey((char *)&((xx+1)->x),sizeof(luVOID),Matrix);
% R4 A7 `4 S' Y( i. J
if(!pMatrix1 || !pMatrix2) break; //对象句柄无效，不是矩阵
6 e$ r8 j) _; w9 L# n) n6 p
if(pMatrix1->Dim[0]!=pMatrix2->Dim[0] || pMatrix1->Dim[1]!=pMatrix2->Dim[1]) break; //维数不相同
8 r9 S6 |1 C7 B/ ?2 W- Z' C+ B
pMatrix3=NewMatrix(pMatrix1->Dim[0],pMatrix1->Dim[1]); //生成新矩阵
+ b# p* @0 `- s8 S5 y
if(!pMatrix3) break;
9 A( X' I: x\\" |& X [$ K
for(i=0;i<pMatrix1->ArrayLen;i++) pMatrix3->Array[i]=pMatrix1->Array[i]*pMatrix2->Array[i]; //矩阵点乘* d: a5 f' t; U/ M8 E% b* h
FunReObj(hFor); //告诉Lu，返回一个动态对象
) Z1 p2 _) P U+ E, r3 S2 U) u
a.BType=Matrix; a.VType=Matrix; a.x=0; *(luVOID *)&(a.x)=(luVOID)pMatrix3;
( I( G8 K5 N/ e! e; h+ V$ Y& w- o
break;
: Q- o1 h: q M0 ?' M\\" D\\" h7 u
case 46: //重载函数new
0 j! E: g' D/ y4 \5 ?
if(mm<2) break;
* p; a: O5 }1 z; y+ b
if((xx+1)->x<1 || (xx+2)->x<1 || (xx+1)->BType!=luStaData_int64 || (xx+2)->BType!=luStaData_int64) break;* s0 _5 ]: Q6 t$ `; R0 W
pMatrix3=NewMatrix((luVOID)(xx+1)->x,(luVOID)(xx+2)->x);//生成新矩阵
2 P, S$ M4 q. T2 O4 f9 T
if(!pMatrix3) break;6 Y+ ]4 Y* T6 B6 \% ~3 X
for(j=0,i=3;i<=mm;i++,j++) //赋初值& N3 e! q: f, Z' ?+ G
{
if(j>=pMatrix3->ArrayLen) break;5 t5 i7 k& w$ I9 l6 h- g6 O9 \
if((xx+i)->BType!=luStaData_double) break; //只接受实数参数* K2 p4 u& y1 F1 H3 i, v! t3 J
pMatrix3->Array[j]=*(double *)&((xx+i)->x);
+ m+ v; e* C0 A' x, T
}- k8 Q# W! b$ n% j( \
FunReObj(hFor); //告诉Lu，返回一个动态对象5 V$ q7 w4 K! G$ ~8 O
a.BType=Matrix; a.VType=Matrix; a.x=0; *(luVOID *)&(a.x)=(luVOID)pMatrix3;/ V! T3 ]7 V/ |& @8 ^1 U
break;
P8 W+ C* S1 n
case 49: //重载函数o4 A0 A9 G6 y7 P
pMessage=(luMessage)SearchKey("\0\0\0\0",sizeof(luVOID),luPubKey_User);
& E( c }) S, D1 W2 m$ z6 g
if(!pMessage) break;- s* B, W+ S\\" M: r. N
pMatrix1=(myMatrix *)SearchKey((char *)&(xx->x),sizeof(luVOID),Matrix);5 W% k& b& ^& ~4 }$ O* y
if(!pMatrix1) break; //对象句柄无效，不是矩阵
! K0 o% K9 E% h j1 T- H, `8 D
pa=pMatrix1->Array;
0 S8 S4 ?8 c( D5 o$ n
m=pMatrix1->Dim[0]; n=pMatrix1->Dim[1]; k=0;7 A% f0 f; I4 r, m5 N
for(i=0; i<m; i++) //输出矩阵( r6 u& ?8 V! a, G | w0 j& p
{
$ b. o O% \7 F# A
pMessage(L"\r\n"); k+=2;
) o( L+ D& p5 G7 H, H6 f F
for(j=0; j<n; j++)' x' O! |; t) i K
{
0 U\\" C$ [; @. [! {. j; F
_gcvt_s(chNum,pa[i*n+j],16);7 H' a7 X' P! g
for(u=0;chNum[u];u++) {wchNum[u]=chNum[u]; k++;}
\\" }$ {; H: R; J9 ^) R( d
wchNum[u]='\0';
+ W& i0 Z# H0 {+ [* z
pMessage(wchNum); pMessage(L" "); k+=2;
+ p# D7 q6 ] A8 o [2 m6 @
}
8 U( T7 d3 r; A% f9 e\\" k! Z
}5 h/ Z\\" `) {\\" v! k' K5 l\\" `
pMessage(L"\r\n"); k+=2;+ f; C% E& F) S- Q _$ J7 A
a.BType=luStaData_int64; a.VType=luStaData_int64; a.x=k; //按函数o的要求，返回输出的字符总数
break;
; I* ~\\" |* a) O+ E' j9 S( ~$ d* I
default:
2 ?\\" K( k9 b; S
break;$ j* h7 T9 w, i# `3 R& {- g
}\\" R+ p7 v# l$ N/ Q
return a;
' m. P1 D3 V7 f
}
( i2 r& m w0 I\\" p+ v( b( l# U
void main(void)
) S! Q! K! V9 _* M9 Z- s7 D
{
8 S) r5 B) n/ K2 b# s9 A; r
void *hFor; //表达式句柄
G6 X, e# p8 D
luINT nPara; //存放表达式的自变量个数. N2 m& ~0 w1 |- R7 X2 d5 ~
LuData *pPara; //存放输入自变量的数组指针
- N, f7 E. r4 m: y
luINT ErrBegin,ErrEnd; //表达式编译出错的初始位置和结束位置; F3 H k& N7 S# V% S
int ErrCode; //错误代码7 Z3 A5 `! H& s; I K, X
void *v;
1 M! C4 X) ^# C; [! V3 k, 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.]}";//字符串表达式，矩阵乘
1 [: r5 y\\" f6 G* [. S4 Z) n5 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.]}";//字符串表达式，矩阵点乘! a& e1 W. N! O& w8 {1 }' ~
LuData Val;# M7 Z1 O7 Z* |: @0 a( D
if(!InitLu()) return; //初始化Lu
\\" R7 W) N8 G0 h/ |* e
while(LockKey(Matrix,DelMatrix,OpMatrix)){Matrix--;} //锁定一个键，用于存储矩阵扩展类型
4 }/ x8 F% J; n- [* u6 [( z
/ \\\" }; }$ c+ o; Q6 ~
Val.BType=luStaData_int64; Val.VType=luStaData_int64; Val.x=Matrix; //定义整数常量7 P! Y1 L0 P% N, V7 D\\" q7 X\\" l
SetConst(L"matrix",&Val); //设置整数常量7 F* R$ p* Y, T# B7 k) S2 [: [+ @1 U
InsertKey("\0\0\0\0",4,luPubKey_User,LuMessage,NULL,NULL,1,v); //使Lu运行时可输出函数信息( f7 P* ^ Q* z
wcout.imbue(locale("chs")); //设置输出的locale为中文8 |) n9 m* c. R/ p
2 o! Q1 ~7 e9 I7 g3 a* W\\" ?
ErrCode=LuCom(ForStr,0,0,0,hFor,nPara,pPara,ErrBegin,ErrEnd); //编译表达式
6 G' ` j$ p: u3 W( ~$ ?
if(ErrCode)
# B* A7 k/ f( n* [; n V
{
. O$ `+ w4 I, ?: y+ @+ |. n6 v
wcout<<L"表达式有错误！错误代码："<<ErrCode<<endl;, u2 m8 w7 E) ?6 _4 ^$ R
}/ J9 Z* S8 j# g: S+ f! \) M
else6 E4 q) z) ] l$ }
{
8 a4 {8 B! I! ?+ p
LuCal(hFor,pPara); //计算表达式的值- ^& `7 }8 s5 S& h* E ^
}
\\" Y4 L$ F q [- Y- L9 K
LockKey(Matrix,NULL,OpMatrix);//解锁键Matrix，本例中，该函数可以不用7 q u4 D6 d' h, f
FreeLu(); //释放Lu o+ K1 v: V# `
}

#include <windows.h> 
* d- R6 n7 A5 F$ D- c; ]
#include <iostream>/ H: q1 {* G9 m8 N; f

#include <math.h>+ T: K/ p  N2 N% E; Y

#include "lu32.h" 
' c$ D$ `' A/ Q5 J
#pragma comment( lib, "lu32.lib" ) 
. E6 j2 Y' l4 D* `5 h! h
using namespace std; 
+ V+ u1 o\\" S2 ?+ ~7 K7 j
//自定义矩阵 
8 T0 y- w2 X6 \. H
class myMatrix  A9 _4 {8 H* I: {6 x8 J# r  I

{ 
/ [\\" q) C) l# O/ z% F
public: 
& m/ Q- }4 q, ~$ {3 M1 K
        double *Array;        //数据缓冲区8 d0 c9 g3 F. b4 @; z' h( w

luVOID ArrayLen;        //数据缓冲区长度 
6 u! A3 E+ {1 }9 z* K. X
        luVOID Dim[2];        //矩阵维数 
6 ^  X+ k+ @\\" |* t7 y
        myMatrix(){Array=NULL; ArrayLen=0; Dim[0]=0; Dim[1]=0;} 
% E5 Q' x. N+ Q' A' T
        ~myMatrix() 
8 }8 i8 I) J, Y\\" X3 r, S! E
        {7 h: U1 W2 r: ~7 C7 f

if(Array) delete[] Array;! e/ V: D% r0 w

}; m$ d+ p' `/ t* D2 ]$ ?

};# `6 E' I: K  ~, D: A/ h

luKEY Matrix=-1000;        //标识矩阵类型，最终的Matrix由LockKey决定 
7 o$ t( o\\" p3 G- f' ^& O
void _stdcall LuMessage(wchar_t *pch)//输出动态库信息，该函数注册到Lu，由Lu二级函数调用 
5 _# N# ^! ]\\" e3 o/ O% \* |) q
{8 t: F; H( l' \

wcout<<pch;8 N\\" q& E3 G5 T! |9 s

}: A5 s- R, N2 v+ z

void _stdcall DelMatrix(void *me)        //用于LockKey函数及InsertKey函数，使Lu能自动销毁myMatrix对象 
7 K& @8 a% ^) u+ s$ v. W
{' r4 n- _  J* Z\\" D

delete (myMatrix *)me; 
9 w9 W. z! P; s2 j9 K; K' J
}; l! y* v- l+ l( P+ w* U

myMatrix * _stdcall NewMatrix(luVOID m,luVOID n)        //生成一个myMatrix对象% W! V. p* ^! `

{ 
9 S% [7 c6 |3 a; ^: t  v
        myMatrix *pMatrix;8 E( w! `: c6 ^$ M7 o\\" p

luVOID k;\\" W, `\\" V8 h3 z

double *pa; 
/ r, T4 J$ _4 J/ k9 P, y! r2 Q  h& q
        char keyname[sizeof(luVOID)];$ [5 J# e\\" w' |3 @6 P- D- [+ N

void *NowKey;$ `5 Y3 B( v\\" d3 M; T* W

k=m*n;+ w* R, p- [, }

pMatrix=(myMatrix *)GetBufObj(Matrix,keyname);//先尝试从缓冲区中获取一个矩阵对象 
/ E8 ?  Q$ H! h( v) ]7 Q
        if(pMatrix) 
3 {( G4 P; S) h# Q- ?: w6 i- r
        {0 ?3 b4 A6 d6 G' q6 u7 p3 T3 c; \6 |

if(pMatrix->ArrayLen!=k)        //重置矩阵的大小5 G6 b0 G; c0 R: z* T

{ 
0 W- q6 P; f+ _
                        pa=new double[k]; 
5 E/ v, R9 j/ Z\\" L) a
                        if(!pa)8 }% f: M, ^0 k% I

{+ e, r2 t, H: [) V

DeleteKey(keyname,sizeof(luVOID),Matrix,DelMatrix,1);        //将矩阵对象放回缓冲区/ W. t\\" k' K: e# Z

return NULL;3 g! l+ L; M0 X\\" s1 k

} 
8 n- ?$ `( U* d! j0 B
                        delete[] pMatrix->Array;% p8 M  T+ L, v$ [* I

pMatrix->Array=pa; 
( o( v, F7 b& V% Y
                } 
# E# N( ^# @! x2 g' j% |: v
        } 
: k3 P( o2 q: N: t& T. T- K
        else 
! |; n, N3 P; M. O2 ^) N
        { 
9 K8 }3 h# w' @% A- q6 ?( k
                pMatrix=new myMatrix;        //创建矩阵对象 
# P4 R9 h3 V# N# h# {2 n; e4 r
                if(!pMatrix) return NULL; 
# k/ m9 _$ m- L7 O; w+ f+ G
                pMatrix->Array=new double[k];+ S- Q# D9 b) V$ p7 S

if(!pMatrix->Array) 
7 N& W  x! Z7 c8 E- B* |
                { 
) S0 ?3 a4 O' u) C4 `
                        delete pMatrix;2 g/ a( M; Z& g0 q0 C. L2 N' N

return NULL;. k9 g6 z+ o/ }! V0 ?3 h

} 
  P8 W- x; M6 d9 ]: o5 P, g
                if(InsertKey((char *)&pMatrix,-1,Matrix,pMatrix,DelMatrix,NULL,0,NowKey))        //将矩阵对象注册到Lu# d8 g) M& r+ Y

{\\" d3 U3 @: ~4 w+ Y; Z( V; N5 P

delete pMatrix;- @2 L$ L3 D5 A+ [

return NULL;( o: F) a& R: ^! G) Q

} 
$ X* ~$ m  i% o6 E' i, e; A; R' W
        } 
: Y# V8 I\\" b. s) g) [
        pMatrix->ArrayLen=k; pMatrix->Dim[0]=m; pMatrix->Dim[1]=n; 
: F. N8 s1 [; s9 E
        return pMatrix;: F7 ?+ h% e( r) {

} 
9 @; X; j( v* G2 ?5 E6 y
LuData _stdcall OpMatrix(luINT mm,LuData *xx,void *hFor,int theOperator)        //运算符重载函数，用于LockKey函数 
5 n/ l4 f8 X1 E, d$ t0 X9 n. u
{ 
6 c' v0 C' |! q5 y\\" e7 C
        LuData a;( C! e. ]4 V/ t/ v# \0 n

myMatrix *pMatrix1,*pMatrix2,*pMatrix3;\\" E6 a8 C- r5 u4 d5 x7 ?

luVOID i,j,k,m,n,u,v;\\" y3 W9 b: k7 W  C\\" O; b% c! `( m

double *pa,*pb,*pc; 
7 H7 k2 \5 w$ T' y
        luMessage pMessage; 
8 W# N) d& e' E( h* ^# H6 d: {. q
        wchar_t wchNum[32];! j, o1 {/ p\\" J\\" }9 x6 d4 x4 v

char chNum[32];' q8 g) P  M! s# t

a.BType=luStaData_nil; a.VType=luStaData_nil; a.x=0;: y! t\\" v+ t0 O

switch(theOperator); M0 Z6 {\\" @/ Q2 E% I2 p* p

{\\" }; k2 @. r) Z0 X* v/ \; `

case 2:        //重载运算符*! ?) ~1 o, {- q8 }& t4 t$ i3 N

pMatrix1=(myMatrix *)SearchKey((char *)&(xx->x),sizeof(luVOID),Matrix); 
+ U1 b  a; H. _5 O\\" ^% \+ B6 z
                pMatrix2=(myMatrix *)SearchKey((char *)&((xx+1)->x),sizeof(luVOID),Matrix);: V  ]: X! U( \. e\\" t# G# }6 k

if(!pMatrix1 || !pMatrix2) break;        //对象句柄无效，不是矩阵 
6 B8 U* e- z4 d( J7 W1 i\\" @
                if(pMatrix1->Dim[1]!=pMatrix2->Dim[0]) break;        //维数不匹配* F1 X* p\\" K9 ?

pMatrix3=NewMatrix(pMatrix1->Dim[0],pMatrix2->Dim[1]);        //生成新矩阵 
9 n% |: f* ~- W4 W2 Z, U# ?2 ^
                if(!pMatrix3) break;6 |$ ^% O5 z9 V( a3 ^1 ]7 \

pa=pMatrix1->Array; pb=pMatrix2->Array; pc=pMatrix3->Array;3 f( c. z  T/ d, c# R

m=pMatrix1->Dim[0]; n=pMatrix1->Dim[1]; k=pMatrix2->Dim[1]; 
: d! Y. L\\" M$ e8 Z3 t6 y9 s7 V8 \
                for(i=0; i<m; i++)        //矩阵乘 
0 w0 S# l$ ^$ ?% Z7 f) w
                { 
! \4 D8 z0 t% e. g) Y9 l* q0 n: r
                        for(j=0; j<k; j++)& j\\" Y; _- y, Y' \. q& _- R

{ 
$ e7 d$ n! i. @- P
                                u=i*k+j; pc[u]=0.0;/ m5 \; B7 x/ L8 O/ w7 k

for (v=0; v<n; v++) 
$ {; Q5 o  w5 D+ Y0 e& y3 [
                                {% W4 T/ l; u* Y- ]# s* n: I1 w

pc[u]=pc[u]+pa[i*n+v]*pb[v*k+j]; 
6 F9 w% T5 Q) R1 f# e
                                } 
+ [  C1 Q9 e  H3 g. ]# j
                        } 
\\" n( J* v# c% d3 K$ e2 z7 N5 O
                } 
' m8 R& V- K0 X\\" \( B
                FunReObj(hFor);        //告诉Lu，返回一个动态对象* w8 `+ c% i. ?6 A9 b6 f

a.BType=Matrix; a.VType=Matrix; a.x=0; *(luVOID *)&(a.x)=(luVOID)pMatrix3;/ W& @( t2 n/ t; c: n* P

break;; [  f+ t3 T% t2 }

case 25:        //重载运算符.* 
3 ]! }\\" |  k\\" B: Q! w! P
                pMatrix1=(myMatrix *)SearchKey((char *)&(xx->x),sizeof(luVOID),Matrix);7 |3 _/ a# t8 N: t; c2 k1 w

pMatrix2=(myMatrix *)SearchKey((char *)&((xx+1)->x),sizeof(luVOID),Matrix); 
% R4 A7 `4 S' Y( i. J
                if(!pMatrix1 || !pMatrix2) break;        //对象句柄无效，不是矩阵 
6 e$ r8 j) _; w9 L# n) n6 p
                if(pMatrix1->Dim[0]!=pMatrix2->Dim[0] || pMatrix1->Dim[1]!=pMatrix2->Dim[1]) break;        //维数不相同 
8 r9 S6 |1 C7 B/ ?2 W- Z' C+ B
                pMatrix3=NewMatrix(pMatrix1->Dim[0],pMatrix1->Dim[1]);        //生成新矩阵 
+ b# p* @0 `- s8 S5 y
                if(!pMatrix3) break; 
9 A( X' I: x\\" |& X  [$ K
                for(i=0;i<pMatrix1->ArrayLen;i++) pMatrix3->Array[i]=pMatrix1->Array[i]*pMatrix2->Array[i];        //矩阵点乘* d: a5 f' t; U/ M8 E% b* h

FunReObj(hFor);        //告诉Lu，返回一个动态对象 
) Z1 p2 _) P  U+ E, r3 S2 U) u
                a.BType=Matrix; a.VType=Matrix; a.x=0; *(luVOID *)&(a.x)=(luVOID)pMatrix3; 
( I( G8 K5 N/ e! e; h+ V$ Y& w- o
                break; 
: Q- o1 h: q  M0 ?' M\\" D\\" h7 u
        case 46:        //重载函数new 
0 j! E: g' D/ y4 \5 ?
                if(mm<2) break; 
* p; a: O5 }1 z; y+ b
                if((xx+1)->x<1 || (xx+2)->x<1 || (xx+1)->BType!=luStaData_int64 || (xx+2)->BType!=luStaData_int64) break;* s0 _5 ]: Q6 t$ `; R0 W

pMatrix3=NewMatrix((luVOID)(xx+1)->x,(luVOID)(xx+2)->x);//生成新矩阵 
2 P, S$ M4 q. T2 O4 f9 T
                if(!pMatrix3) break;6 Y+ ]4 Y* T6 B6 \% ~3 X

for(j=0,i=3;i<=mm;i++,j++)        //赋初值& N3 e! q: f, Z' ?+ G

{ 
3 q% H- ]\\" u: O( P3 y; [2 r* N' E- U2 \
                        if(j>=pMatrix3->ArrayLen) break;5 t5 i7 k& w$ I9 l6 h- g6 O9 \

if((xx+i)->BType!=luStaData_double) break;        //只接受实数参数* K2 p4 u& y1 F1 H3 i, v! t3 J

pMatrix3->Array[j]=*(double *)&((xx+i)->x); 
+ m+ v; e* C0 A' x, T
                }- k8 Q# W! b$ n% j( \

FunReObj(hFor);        //告诉Lu，返回一个动态对象5 V$ q7 w4 K! G$ ~8 O

a.BType=Matrix; a.VType=Matrix; a.x=0; *(luVOID *)&(a.x)=(luVOID)pMatrix3;/ V! T3 ]7 V/ |& @8 ^1 U

break; 
  P8 W+ C* S1 n
        case 49:        //重载函数o4 A0 A9 G6 y7 P

pMessage=(luMessage)SearchKey("\0\0\0\0",sizeof(luVOID),luPubKey_User); 
& E( c  }) S, D1 W2 m$ z6 g
                if(!pMessage) break;- s* B, W+ S\\" M: r. N

pMatrix1=(myMatrix *)SearchKey((char *)&(xx->x),sizeof(luVOID),Matrix);5 W% k& b& ^& ~4 }$ O* y

if(!pMatrix1) break;        //对象句柄无效，不是矩阵 
! K0 o% K9 E% h  j1 T- H, `8 D
                pa=pMatrix1->Array; 
0 S8 S4 ?8 c( D5 o$ n
                m=pMatrix1->Dim[0]; n=pMatrix1->Dim[1]; k=0;7 A% f0 f; I4 r, m5 N

for(i=0; i<m; i++)        //输出矩阵( r6 u& ?8 V! a, G  |  w0 j& p

{ 
$ b. o  O% \7 F# A
                        pMessage(L"\r\n"); k+=2; 
) o( L+ D& p5 G7 H, H6 f  F
                        for(j=0; j<n; j++)' x' O! |; t) i  K

{ 
0 U\\" C$ [; @. [! {. j; F
                                _gcvt_s(chNum,pa[i*n+j],16);7 H' a7 X' P! g

for(u=0;chNum[u];u++) {wchNum[u]=chNum[u]; k++;} 
\\" }$ {; H: R; J9 ^) R( d
                                wchNum[u]='\0'; 
+ W& i0 Z# H0 {+ [* z
                                pMessage(wchNum); pMessage(L"  "); k+=2; 
+ p# D7 q6 ]  A8 o  [2 m6 @
                        } 
8 U( T7 d3 r; A% f9 e\\" k! Z
                }5 h/ Z\\" `) {\\" v! k' K5 l\\" `

pMessage(L"\r\n"); k+=2;+ f; C% E& F) S- Q  _$ J7 A

a.BType=luStaData_int64; a.VType=luStaData_int64; a.x=k;        //按函数o的要求，返回输出的字符总数 
* T2 @* @) S! T2 w( T# t  i( p9 f  s! K
                break; 
; I* ~\\" |* a) O+ E' j9 S( ~$ d* I
        default: 
2 ?\\" K( k9 b; S
                break;$ j* h7 T9 w, i# `3 R& {- g

}\\" R+ p7 v# l$ N/ Q

return a; 
' m. P1 D3 V7 f
} 
( i2 r& m  w0 I\\" p+ v( b( l# U
void main(void) 
) S! Q! K! V9 _* M9 Z- s7 D
{ 
8 S) r5 B) n/ K2 b# s9 A; r
        void *hFor;                //表达式句柄 
  G6 X, e# p8 D
        luINT nPara;                //存放表达式的自变量个数. N2 m& ~0 w1 |- R7 X2 d5 ~

LuData *pPara;                //存放输入自变量的数组指针 
- N, f7 E. r4 m: y
        luINT ErrBegin,ErrEnd;        //表达式编译出错的初始位置和结束位置; F3 H  k& N7 S# V% S

int ErrCode;                //错误代码7 Z3 A5 `! H& s; I  K, X

void *v; 
1 M! C4 X) ^# C; [! V3 k, 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.]}";//字符串表达式，矩阵乘 
1 [: r5 y\\" f6 G* [. S4 Z) n5 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.]}";//字符串表达式，矩阵点乘! a& e1 W. N! O& w8 {1 }' ~

LuData Val;# M7 Z1 O7 Z* |: @0 a( D

if(!InitLu()) return;        //初始化Lu 
\\" R7 W) N8 G0 h/ |* e
        while(LockKey(Matrix,DelMatrix,OpMatrix)){Matrix--;}        //锁定一个键，用于存储矩阵扩展类型 
4 }/ x8 F% J; n- [* u6 [( z
 
/ \\\" }; }$ c+ o; Q6 ~
        Val.BType=luStaData_int64; Val.VType=luStaData_int64; Val.x=Matrix;        //定义整数常量7 P! Y1 L0 P% N, V7 D\\" q7 X\\" l

SetConst(L"matrix",&Val);        //设置整数常量7 F* R$ p* Y, T# B7 k) S2 [: [+ @1 U

InsertKey("\0\0\0\0",4,luPubKey_User,LuMessage,NULL,NULL,1,v); //使Lu运行时可输出函数信息( f7 P* ^  Q* z

wcout.imbue(locale("chs"));        //设置输出的locale为中文8 |) n9 m* c. R/ p

2 o! Q1 ~7 e9 I7 g3 a* W\\" ?
        ErrCode=LuCom(ForStr,0,0,0,hFor,nPara,pPara,ErrBegin,ErrEnd); //编译表达式 
6 G' `  j$ p: u3 W( ~$ ?
        if(ErrCode) 
# B* A7 k/ f( n* [; n  V
        { 
. O$ `+ w4 I, ?: y+ @+ |. n6 v
                wcout<<L"表达式有错误！错误代码："<<ErrCode<<endl;, u2 m8 w7 E) ?6 _4 ^$ R

}/ J9 Z* S8 j# g: S+ f! \) M

else6 E4 q) z) ]  l$ }

{ 
8 a4 {8 B! I! ?+ p
                LuCal(hFor,pPara);        //计算表达式的值- ^& `7 }8 s5 S& h* E  ^

} 
\\" Y4 L$ F  q  [- Y- L9 K
        LockKey(Matrix,NULL,OpMatrix);//解锁键Matrix，本例中，该函数可以不用7 q  u4 D6 d' h, f

FreeLu();                        //释放Lu  o+ K1 v: V# `

}

习题：

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

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

main(:a,b,c,d,t,i)=# f) M( \8 Q2 o' M\" j
a=new[matrix,2,2: 1.,2.,2.,1.],
6 A4 }; Q. t- d6 x( U1 \' \
b=new[matrix,2,2: 2.,1.,1.,2.],
/ i2 e' u( C$ i S: V$ E, d
c=new[matrix,2,2: 2/3.,-1/3.,-1/3.,2/3.],4 q2 e' D: Y% `\" j9 y8 x$ y& F
t=clock(),
- h\" _2 }* H$ B8 s( C
d=a*b, i=0, while{i<1000000, d=d*c*b, i++},* ]* @, g- ?3 o, l\" A
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\"}";//字符串表达式

复制代码

结果：