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

查看: 9059|回复: 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>$ B! q3 Q/ _6 A( ~+ Y
#include <iostream>
) m\\" I0 d* N$ {5 S8 A) Z/ R8 a
#include <math.h>
8 \9 q3 p0 k$ |/ z& d
#include "lu32.h"
( b2 o0 w3 f3 i: |
#pragma comment( lib, "lu32.lib" )
; ]1 `: D+ D: b+ |
using namespace std;. F g ^8 E. p
//自定义矩阵8 o- J1 A' q( N3 \# A
class myMatrix
. ^! x. k6 d( ?$ X1 Q! m
{, U# J$ B5 k! e! E
public:
7 x h$ H8 s3 H8 _& Q9 S
double *Array; //数据缓冲区
& Z, S# p% F2 x2 o+ v- H* ~5 @; |
luVOID ArrayLen; //数据缓冲区长度
5 O. {3 Y) v. t
luVOID Dim[2]; //矩阵维数
; _6 t$ w3 ]/ S) Z, N4 F4 }
myMatrix(){Array=NULL; ArrayLen=0; Dim[0]=0; Dim[1]=0;}
* ^\\" c/ g2 c% c& D7 c+ K
~myMatrix()
8 ?- @; E$ s- m
{ l. x2 z! p$ W8 L
if(Array) delete[] Array;
- J, r( v P7 n7 A( v% Z: Q
} S# T$ S( i/ h) U' e8 {/ c( r
};9 B- @% }5 ?! a* j9 K\\" h
luKEY Matrix=-1000; //标识矩阵类型，最终的Matrix由LockKey决定. c: s0 t7 r- r, L- H
void _stdcall LuMessage(wchar_t *pch)//输出动态库信息，该函数注册到Lu，由Lu二级函数调用
4 `: i# d) ^, X( J
{
* E2 s, \+ R) Z% g, s
wcout<<pch;0 K F* s( N- B- y
}
# F0 \3 q\\" c U( _
void _stdcall DelMatrix(void *me) //用于LockKey函数及InsertKey函数，使Lu能自动销毁myMatrix对象/ Z& [/ p: e( u1 e3 u' x$ I2 F
{
F' q9 M8 x7 P$ ]
delete (myMatrix *)me;
$ P( s6 I5 @$ E {8 [: a
}
) X% m- `# `* T
myMatrix * _stdcall NewMatrix(luVOID m,luVOID n) //生成一个myMatrix对象, _2 o; @8 y2 v* s8 g2 Q: v! }
{/ f/ p/ I. e, U9 }. R# B2 J; l, G
myMatrix *pMatrix;/ l* V; W8 Y3 ]2 n; Y& z
luVOID k;. K2 g0 ]; o; B* `. t( m
double *pa;
' @3 E' k2 Z- a# {9 y D5 P
char keyname[sizeof(luVOID)];\\" Y: ]. j! z7 [. N% ?
void *NowKey;& v8 t3 E& U9 i
k=m*n;
$ z3 w! k5 S5 U3 h0 O: T4 `
pMatrix=(myMatrix *)GetBufObj(Matrix,keyname);//先尝试从缓冲区中获取一个矩阵对象' E. O7 M$ }1 z6 K, N+ S
if(pMatrix); t. f Y\\" Z) s
{: ^( j6 U8 m ` g) j
if(pMatrix->ArrayLen!=k) //重置矩阵的大小
1 x3 q' e/ C) D* L! ]; ~
{$ |8 v6 A' w, e7 \4 [
pa=new double[k];
! |7 g# c0 q1 w( }( H& ~
if(!pa)
1 J! W* H8 K8 g% ` h
{
7 @. l( N3 m+ ?4 Q/ }0 _/ }# r
DeleteKey(keyname,sizeof(luVOID),Matrix,DelMatrix,1); //将矩阵对象放回缓冲区
) n! N5 O) ^, r$ C
return NULL;\\" J- z- s( R& [ c' b8 l1 ~4 e0 P
}
5 |3 c ?8 k1 w1 a2 u
delete[] pMatrix->Array;6 S9 \- z f0 ^% ~7 R
pMatrix->Array=pa;\\" r% q7 g# ~# K( x8 {; ?* ], x1 j
}
7 Q' W% R) |7 m: M q5 }0 l
}\\" b4 a9 z# K' D# |' A( d) H! m! k
else
) Q9 _2 S5 i8 [$ U9 I8 p1 K
{
; O! t6 e/ Q5 [
pMatrix=new myMatrix; //创建矩阵对象
Z& h$ ~6 E$ ~5 o' R, x9 L0 }
if(!pMatrix) return NULL;
/ c2 a, `& P/ }3 n
pMatrix->Array=new double[k];4 K: L- {, d8 F2 ?# J5 C
if(!pMatrix->Array)
4 F5 M; f0 ^3 |$ O# B2 [5 B3 _. R
{
$ E9 J- F( |$ Z; V% h
delete pMatrix;0 M o- j8 d# z
return NULL;
# `& z! S1 t5 i. O\\" ?
}6 O, K) p; B2 f% O2 _ L
if(InsertKey((char *)&pMatrix,-1,Matrix,pMatrix,DelMatrix,NULL,0,NowKey)) //将矩阵对象注册到Lu, P. e9 I Z* ~2 N2 R
{+ ~4 E& q0 b- ^( h: L. I6 K
delete pMatrix;
# \. T; x) X\\" A' A7 I
return NULL;
\\" d% O* f9 m& x) @/ Q) i' _
}
+ W- T4 {$ ^/ P) S! W\\" `- Q
}
9 F4 ~5 y3 F, ^' b
pMatrix->ArrayLen=k; pMatrix->Dim[0]=m; pMatrix->Dim[1]=n;/ H; C7 i\\" G/ R* f/ G+ w
return pMatrix;. G! Q0 z/ C2 x
}
3 Q; p\\" Z, p, |4 D) B& R
LuData _stdcall OpMatrix(luINT mm,LuData *xx,void *hFor,int theOperator) //运算符重载函数，用于LockKey函数7 Q, l8 d: D. B1 {( h9 w4 D+ o
{. q8 p2 ~$ _4 m# g. K) g1 Q* A
LuData a;
9 Z3 R. [5 q7 O/ O
myMatrix *pMatrix1,*pMatrix2,*pMatrix3;
. [# i r2 b& y) {2 ?# n6 G3 w
luVOID i,j,k,m,n,u,v;
. H% X0 ?\\" C+ N
double *pa,*pb,*pc;1 b \+ D\\" j/ P7 u; q, M
luMessage pMessage;
# z i9 Q) ~% D) v `
wchar_t wchNum[32];
6 u( a- Y; ^' l6 s; N+ i
char chNum[32];
' s5 y& R! F$ X! Y) O
a.BType=luStaData_nil; a.VType=luStaData_nil; a.x=0;0 P% ~! E6 h, X% `: Y0 j
switch(theOperator)
; S% x1 F. j! {2 [; X
{
) p j9 Z& Z6 \( ^
case 2: //重载运算符*
\\" [# O. U1 d1 c/ A% ]: ^0 o
pMatrix1=(myMatrix *)SearchKey((char *)&(xx->x),sizeof(luVOID),Matrix);
( W- H$ E5 e+ W: n; Q4 B
pMatrix2=(myMatrix *)SearchKey((char *)&((xx+1)->x),sizeof(luVOID),Matrix);
, J' I: J7 @9 W: g
if(!pMatrix1 || !pMatrix2) break; //对象句柄无效，不是矩阵
( k2 `- l) S- Y2 H3 c! Q
if(pMatrix1->Dim[1]!=pMatrix2->Dim[0]) break; //维数不匹配) I7 M, ~4 T( G1 O- P+ v
pMatrix3=NewMatrix(pMatrix1->Dim[0],pMatrix2->Dim[1]); //生成新矩阵
3 o, T& W6 P; R
if(!pMatrix3) break;% u8 g8 [$ f& o5 \' m\\" r
pa=pMatrix1->Array; pb=pMatrix2->Array; pc=pMatrix3->Array;
/ A; f$ \- F* p/ U6 d
m=pMatrix1->Dim[0]; n=pMatrix1->Dim[1]; k=pMatrix2->Dim[1];
( k( Q. G* ?9 {4 E8 j4 p# R1 I
for(i=0; i<m; i++) //矩阵乘
+ X1 P% J) @( d( ^. v5 D! a
{; s8 ]) v/ U% H; r: \
for(j=0; j<k; j++)& c! i. G5 s7 l; Q, T! k% e
{
( ]; z' X* n# _: k& `2 w- w7 R9 L
u=i*k+j; pc[u]=0.0;2 Y; _. x- v) X% K- y$ t+ e! G. s
for (v=0; v<n; v++)
8 Z: W& D% Y* I$ _- u( Z% j
{5 a# J9 N1 u' k; O3 h( D! E; D h9 E
pc[u]=pc[u]+pa[i*n+v]*pb[v*k+j];7 e, f. o+ w, S w8 o* k\\" r: @! \
}' }- j8 f* i4 X
}
V/ F% f1 Q C\\" p2 c6 L9 I
}4 a4 v9 b$ f' k& x
FunReObj(hFor); //告诉Lu，返回一个动态对象& Z. V. ?( g6 o( a# `# A' C
a.BType=Matrix; a.VType=Matrix; a.x=0; *(luVOID *)&(a.x)=(luVOID)pMatrix3;
: f) U1 i7 W) W4 ?: T5 d
break;
( I' x0 C4 a, b; S! N' _
case 25: //重载运算符.*
: \/ h+ ?. f' X3 B1 c/ t
pMatrix1=(myMatrix *)SearchKey((char *)&(xx->x),sizeof(luVOID),Matrix);
2 t6 F& ^/ F+ `3 O; q. ]$ i/ Z\\" B+ G
pMatrix2=(myMatrix *)SearchKey((char *)&((xx+1)->x),sizeof(luVOID),Matrix);
) j( b8 T# f1 ^3 q\\" k# p; U2 }
if(!pMatrix1 || !pMatrix2) break; //对象句柄无效，不是矩阵
: O' g6 J T! I
if(pMatrix1->Dim[0]!=pMatrix2->Dim[0] || pMatrix1->Dim[1]!=pMatrix2->Dim[1]) break; //维数不相同4 ~% m5 T- P: g6 y
pMatrix3=NewMatrix(pMatrix1->Dim[0],pMatrix1->Dim[1]); //生成新矩阵
% \8 X! k6 [4 }\\" P% ]\\" o. p0 W
if(!pMatrix3) break;
1 M* F& a$ v4 Z3 |& T) J* }/ s
for(i=0;i<pMatrix1->ArrayLen;i++) pMatrix3->Array[i]=pMatrix1->Array[i]*pMatrix2->Array[i]; //矩阵点乘* ` n/ A( i9 d$ `6 q% v% ^ R ~& d/ H
FunReObj(hFor); //告诉Lu，返回一个动态对象
2 l3 G9 f: `7 F0 h& ]; |9 J5 o/ W
a.BType=Matrix; a.VType=Matrix; a.x=0; *(luVOID *)&(a.x)=(luVOID)pMatrix3;
# v1 ]$ E2 u. Z& M
break;+ F5 B: X, A# I5 a' {# `) B: o
case 46: //重载函数new
; g( Y6 x% O# Q# a) |% F
if(mm<2) break;3 e$ Q- k( ^* U. k
if((xx+1)->x<1 || (xx+2)->x<1 || (xx+1)->BType!=luStaData_int64 || (xx+2)->BType!=luStaData_int64) break;
0 Z/ _- ~\\" M2 ~7 x
pMatrix3=NewMatrix((luVOID)(xx+1)->x,(luVOID)(xx+2)->x);//生成新矩阵
4 r9 [$ Q8 D% e( g% A# R* A
if(!pMatrix3) break;
3 \8 a6 [7 B7 U0 |+ |7 l% a
for(j=0,i=3;i<=mm;i++,j++) //赋初值/ |' e& X5 l0 O* U1 g7 Q) l\\" _0 \+ L
{2 i, \4 @/ [. p* F9 s3 a
if(j>=pMatrix3->ArrayLen) break;
1 P3 m8 X4 q% c% i
if((xx+i)->BType!=luStaData_double) break; //只接受实数参数
5 {8 n/ K0 s* m6 g( }/ a% m
pMatrix3->Array[j]=*(double *)&((xx+i)->x);
* y6 A l0 [+ e
}* Y6 ?# d, R j1 w; ^& Z
FunReObj(hFor); //告诉Lu，返回一个动态对象
. O' N* g9 ^4 [
a.BType=Matrix; a.VType=Matrix; a.x=0; *(luVOID *)&(a.x)=(luVOID)pMatrix3; U+ @: @6 n! A2 e1 ^& C) O
break;
/ V1 u, S: ~, P- Z: \
case 49: //重载函数o
* O! ? M3 L( a
pMessage=(luMessage)SearchKey("\0\0\0\0",sizeof(luVOID),luPubKey_User);
* i s& i. `5 G\\" q% t
if(!pMessage) break;
0 U; i2 {* ]; _2 c, O) U
pMatrix1=(myMatrix *)SearchKey((char *)&(xx->x),sizeof(luVOID),Matrix);& t% H c1 a' l. n
if(!pMatrix1) break; //对象句柄无效，不是矩阵& R7 s r; q% Q2 D6 U k6 u
pa=pMatrix1->Array;, [\\" ^4 Q6 L; B
m=pMatrix1->Dim[0]; n=pMatrix1->Dim[1]; k=0;# |. L$ _( ~1 I2 D6 h
for(i=0; i<m; i++) //输出矩阵0 ?) K# W; n7 t. x% h
{
' k0 W# D; @7 x; }6 T' f, z
pMessage(L"\r\n"); k+=2;
# p6 D\\" Q3 P$ Y. c6 ]
for(j=0; j<n; j++)
5 V; @# g! V\\" I8 `1 `) X2 [
{, A+ Y# w: L. U\\" z6 s, I
_gcvt_s(chNum,pa[i*n+j],16);
for(u=0;chNum[u];u++) {wchNum[u]=chNum[u]; k++;}
; [* Y4 {- n5 u
wchNum[u]='\0';
3 V6 i/ X7 x* J `9 _
pMessage(wchNum); pMessage(L" "); k+=2;
* X2 Z* @3 Q+ f6 v
}
2 _' u: g& b2 f1 l: ~' V, F4 D0 n, t
}
0 c! f1 L/ B* u2 \
pMessage(L"\r\n"); k+=2;
: t: E8 ~7 t, Y2 X: p
a.BType=luStaData_int64; a.VType=luStaData_int64; a.x=k; //按函数o的要求，返回输出的字符总数, \ g; @/ l% y& V& d
break;! R4 `, P4 f2 m
default:
2 C% \! S# W. S
break;
& h7 r8 w6 ~6 _+ o$ x: t0 @+ b
}
/ b% B' d% a* B0 B1 E( I
return a;
! Y; H% }) U! b; W1 t: G3 }
}9 t7 t2 }- ?9 X) Z+ Z+ ~
void main(void)5 p: F% C/ l9 M' }+ h9 U
{6 J\\" B' Q% W\\" U$ e1 ^% N( [
void *hFor; //表达式句柄( e\\" {5 R5 ~1 E7 ~
luINT nPara; //存放表达式的自变量个数
) r' A/ O7 }2 z: E2 F% ?
LuData *pPara; //存放输入自变量的数组指针
* F' R) k* z2 ]( r ^( L
luINT ErrBegin,ErrEnd; //表达式编译出错的初始位置和结束位置
! U+ B- @+ v0 I& n; V
int ErrCode; //错误代码& N2 f0 B& L# b2 J+ Z
void *v;! G8 z$ ?6 d* v% ?3 w
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.]}";//字符串表达式，矩阵乘0 z5 A5 u9 R/ R/ P! ]8 {- 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.]}";//字符串表达式，矩阵点乘
9 r& j& z' Y/ H c$ _* ^& n: u5 y
LuData Val;: w: |$ l/ G: t8 [
if(!InitLu()) return; //初始化Lu\\" c/ t' p8 v7 z; }1 r! A L, c\\" c
while(LockKey(Matrix,DelMatrix,OpMatrix)){Matrix--;} //锁定一个键，用于存储矩阵扩展类型
0 o* c9 Q4 N+ r# J) l9 l. g
/ k* u0 W; ]9 h/ r$ n, ~
Val.BType=luStaData_int64; Val.VType=luStaData_int64; Val.x=Matrix; //定义整数常量5 {3 P# u4 w, C& N; L
SetConst(L"matrix",&Val); //设置整数常量
8 F5 |\\" p$ U$ t\\" E' ]9 x: c
InsertKey("\0\0\0\0",4,luPubKey_User,LuMessage,NULL,NULL,1,v); //使Lu运行时可输出函数信息8 h+ P& I/ V Q
wcout.imbue(locale("chs")); //设置输出的locale为中文; Y! J; l3 {& d6 A& r4 Q3 D
9 E! P, W- X0 |- I% A6 x
ErrCode=LuCom(ForStr,0,0,0,hFor,nPara,pPara,ErrBegin,ErrEnd); //编译表达式7 w/ O3 ~) j* ]$ `: O\\" C' L+ j
if(ErrCode)
/ D! S! c& Z4 M/ p5 I. Z
{
' c. O; y6 P2 L
wcout<<L"表达式有错误！错误代码："<<ErrCode<<endl;6 L3 u o& O: V6 K; }2 y* J$ j( c1 B
}$ Q/ o; x7 @' M _ W( T
else
& L& J- _, Q1 p' D6 W
{: {% ?8 N o/ X7 v9 u4 D d% C
LuCal(hFor,pPara); //计算表达式的值
}1 t; x; H' ]- Z/ h! [
LockKey(Matrix,NULL,OpMatrix);//解锁键Matrix，本例中，该函数可以不用
4 |: p7 ~1 D- c4 q& [; q( z\\" N, q
FreeLu(); //释放Lu( v r1 x' V/ s0 F6 e- v
}

#include <windows.h>$ B! q3 Q/ _6 A( ~+ Y

#include <iostream> 
) m\\" I0 d* N$ {5 S8 A) Z/ R8 a
#include <math.h> 
8 \9 q3 p0 k$ |/ z& d
#include "lu32.h" 
( b2 o0 w3 f3 i: |
#pragma comment( lib, "lu32.lib" ) 
; ]1 `: D+ D: b+ |
using namespace std;. F  g  ^8 E. p

//自定义矩阵8 o- J1 A' q( N3 \# A

class myMatrix 
. ^! x. k6 d( ?$ X1 Q! m
{, U# J$ B5 k! e! E

public: 
7 x  h$ H8 s3 H8 _& Q9 S
        double *Array;        //数据缓冲区 
& Z, S# p% F2 x2 o+ v- H* ~5 @; |
        luVOID ArrayLen;        //数据缓冲区长度 
5 O. {3 Y) v. t
        luVOID Dim[2];        //矩阵维数 
; _6 t$ w3 ]/ S) Z, N4 F4 }
        myMatrix(){Array=NULL; ArrayLen=0; Dim[0]=0; Dim[1]=0;} 
* ^\\" c/ g2 c% c& D7 c+ K
        ~myMatrix() 
8 ?- @; E$ s- m
        {  l. x2 z! p$ W8 L

if(Array) delete[] Array; 
- J, r( v  P7 n7 A( v% Z: Q
        }  S# T$ S( i/ h) U' e8 {/ c( r

};9 B- @% }5 ?! a* j9 K\\" h

luKEY Matrix=-1000;        //标识矩阵类型，最终的Matrix由LockKey决定. c: s0 t7 r- r, L- H

void _stdcall LuMessage(wchar_t *pch)//输出动态库信息，该函数注册到Lu，由Lu二级函数调用 
4 `: i# d) ^, X( J
{ 
* E2 s, \+ R) Z% g, s
        wcout<<pch;0 K  F* s( N- B- y

} 
# F0 \3 q\\" c  U( _
void _stdcall DelMatrix(void *me)        //用于LockKey函数及InsertKey函数，使Lu能自动销毁myMatrix对象/ Z& [/ p: e( u1 e3 u' x$ I2 F

{ 
  F' q9 M8 x7 P$ ]
        delete (myMatrix *)me; 
$ P( s6 I5 @$ E  {8 [: a
} 
) X% m- `# `* T
myMatrix * _stdcall NewMatrix(luVOID m,luVOID n)        //生成一个myMatrix对象, _2 o; @8 y2 v* s8 g2 Q: v! }

{/ f/ p/ I. e, U9 }. R# B2 J; l, G

myMatrix *pMatrix;/ l* V; W8 Y3 ]2 n; Y& z

luVOID k;. K2 g0 ]; o; B* `. t( m

double *pa; 
' @3 E' k2 Z- a# {9 y  D5 P
        char keyname[sizeof(luVOID)];\\" Y: ]. j! z7 [. N% ?

void *NowKey;& v8 t3 E& U9 i

k=m*n; 
$ z3 w! k5 S5 U3 h0 O: T4 `
        pMatrix=(myMatrix *)GetBufObj(Matrix,keyname);//先尝试从缓冲区中获取一个矩阵对象' E. O7 M$ }1 z6 K, N+ S

if(pMatrix); t. f  Y\\" Z) s

{: ^( j6 U8 m  `  g) j

if(pMatrix->ArrayLen!=k)        //重置矩阵的大小 
1 x3 q' e/ C) D* L! ]; ~
                {$ |8 v6 A' w, e7 \4 [

pa=new double[k]; 
! |7 g# c0 q1 w( }( H& ~
                        if(!pa) 
1 J! W* H8 K8 g% `  h
                        { 
7 @. l( N3 m+ ?4 Q/ }0 _/ }# r
                                DeleteKey(keyname,sizeof(luVOID),Matrix,DelMatrix,1);        //将矩阵对象放回缓冲区 
) n! N5 O) ^, r$ C
                                return NULL;\\" J- z- s( R& [  c' b8 l1 ~4 e0 P

} 
5 |3 c  ?8 k1 w1 a2 u
                        delete[] pMatrix->Array;6 S9 \- z  f0 ^% ~7 R

pMatrix->Array=pa;\\" r% q7 g# ~# K( x8 {; ?* ], x1 j

} 
7 Q' W% R) |7 m: M  q5 }0 l
        }\\" b4 a9 z# K' D# |' A( d) H! m! k

else 
) Q9 _2 S5 i8 [$ U9 I8 p1 K
        { 
; O! t6 e/ Q5 [
                pMatrix=new myMatrix;        //创建矩阵对象 
  Z& h$ ~6 E$ ~5 o' R, x9 L0 }
                if(!pMatrix) return NULL; 
/ c2 a, `& P/ }3 n
                pMatrix->Array=new double[k];4 K: L- {, d8 F2 ?# J5 C

if(!pMatrix->Array) 
4 F5 M; f0 ^3 |$ O# B2 [5 B3 _. R
                { 
$ E9 J- F( |$ Z; V% h
                        delete pMatrix;0 M  o- j8 d# z

return NULL; 
# `& z! S1 t5 i. O\\" ?
                }6 O, K) p; B2 f% O2 _  L

if(InsertKey((char *)&pMatrix,-1,Matrix,pMatrix,DelMatrix,NULL,0,NowKey))        //将矩阵对象注册到Lu, P. e9 I  Z* ~2 N2 R

{+ ~4 E& q0 b- ^( h: L. I6 K

delete pMatrix; 
# \. T; x) X\\" A' A7 I
                        return NULL; 
\\" d% O* f9 m& x) @/ Q) i' _
                } 
+ W- T4 {$ ^/ P) S! W\\" `- Q
        } 
9 F4 ~5 y3 F, ^' b
        pMatrix->ArrayLen=k; pMatrix->Dim[0]=m; pMatrix->Dim[1]=n;/ H; C7 i\\" G/ R* f/ G+ w

return pMatrix;. G! Q0 z/ C2 x

} 
3 Q; p\\" Z, p, |4 D) B& R
LuData _stdcall OpMatrix(luINT mm,LuData *xx,void *hFor,int theOperator)        //运算符重载函数，用于LockKey函数7 Q, l8 d: D. B1 {( h9 w4 D+ o

{. q8 p2 ~$ _4 m# g. K) g1 Q* A

LuData a; 
9 Z3 R. [5 q7 O/ O
        myMatrix *pMatrix1,*pMatrix2,*pMatrix3; 
. [# i  r2 b& y) {2 ?# n6 G3 w
        luVOID i,j,k,m,n,u,v; 
. H% X0 ?\\" C+ N
        double *pa,*pb,*pc;1 b  \+ D\\" j/ P7 u; q, M

luMessage pMessage; 
# z  i9 Q) ~% D) v  `
        wchar_t wchNum[32]; 
6 u( a- Y; ^' l6 s; N+ i
        char chNum[32]; 
' s5 y& R! F$ X! Y) O
        a.BType=luStaData_nil; a.VType=luStaData_nil; a.x=0;0 P% ~! E6 h, X% `: Y0 j

switch(theOperator) 
; S% x1 F. j! {2 [; X
        { 
) p  j9 Z& Z6 \( ^
        case 2:        //重载运算符* 
\\" [# O. U1 d1 c/ A% ]: ^0 o
                pMatrix1=(myMatrix *)SearchKey((char *)&(xx->x),sizeof(luVOID),Matrix); 
( W- H$ E5 e+ W: n; Q4 B
                pMatrix2=(myMatrix *)SearchKey((char *)&((xx+1)->x),sizeof(luVOID),Matrix); 
, J' I: J7 @9 W: g
                if(!pMatrix1 || !pMatrix2) break;        //对象句柄无效，不是矩阵 
( k2 `- l) S- Y2 H3 c! Q
                if(pMatrix1->Dim[1]!=pMatrix2->Dim[0]) break;        //维数不匹配) I7 M, ~4 T( G1 O- P+ v

pMatrix3=NewMatrix(pMatrix1->Dim[0],pMatrix2->Dim[1]);        //生成新矩阵 
3 o, T& W6 P; R
                if(!pMatrix3) break;% u8 g8 [$ f& o5 \' m\\" r

pa=pMatrix1->Array; pb=pMatrix2->Array; pc=pMatrix3->Array; 
/ A; f$ \- F* p/ U6 d
                m=pMatrix1->Dim[0]; n=pMatrix1->Dim[1]; k=pMatrix2->Dim[1]; 
( k( Q. G* ?9 {4 E8 j4 p# R1 I
                for(i=0; i<m; i++)        //矩阵乘 
+ X1 P% J) @( d( ^. v5 D! a
                {; s8 ]) v/ U% H; r: \

for(j=0; j<k; j++)& c! i. G5 s7 l; Q, T! k% e

{ 
( ]; z' X* n# _: k& `2 w- w7 R9 L
                                u=i*k+j; pc[u]=0.0;2 Y; _. x- v) X% K- y$ t+ e! G. s

for (v=0; v<n; v++) 
8 Z: W& D% Y* I$ _- u( Z% j
                                {5 a# J9 N1 u' k; O3 h( D! E; D  h9 E

pc[u]=pc[u]+pa[i*n+v]*pb[v*k+j];7 e, f. o+ w, S  w8 o* k\\" r: @! \

}' }- j8 f* i4 X

} 
  V/ F% f1 Q  C\\" p2 c6 L9 I
                }4 a4 v9 b$ f' k& x

FunReObj(hFor);        //告诉Lu，返回一个动态对象& Z. V. ?( g6 o( a# `# A' C

a.BType=Matrix; a.VType=Matrix; a.x=0; *(luVOID *)&(a.x)=(luVOID)pMatrix3; 
: f) U1 i7 W) W4 ?: T5 d
                break; 
( I' x0 C4 a, b; S! N' _
        case 25:        //重载运算符.* 
: \/ h+ ?. f' X3 B1 c/ t
                pMatrix1=(myMatrix *)SearchKey((char *)&(xx->x),sizeof(luVOID),Matrix); 
2 t6 F& ^/ F+ `3 O; q. ]$ i/ Z\\" B+ G
                pMatrix2=(myMatrix *)SearchKey((char *)&((xx+1)->x),sizeof(luVOID),Matrix); 
) j( b8 T# f1 ^3 q\\" k# p; U2 }
                if(!pMatrix1 || !pMatrix2) break;        //对象句柄无效，不是矩阵 
: O' g6 J  T! I
                if(pMatrix1->Dim[0]!=pMatrix2->Dim[0] || pMatrix1->Dim[1]!=pMatrix2->Dim[1]) break;        //维数不相同4 ~% m5 T- P: g6 y

pMatrix3=NewMatrix(pMatrix1->Dim[0],pMatrix1->Dim[1]);        //生成新矩阵 
% \8 X! k6 [4 }\\" P% ]\\" o. p0 W
                if(!pMatrix3) break; 
1 M* F& a$ v4 Z3 |& T) J* }/ s
                for(i=0;i<pMatrix1->ArrayLen;i++) pMatrix3->Array[i]=pMatrix1->Array[i]*pMatrix2->Array[i];        //矩阵点乘* `  n/ A( i9 d$ `6 q% v% ^  R  ~& d/ H

FunReObj(hFor);        //告诉Lu，返回一个动态对象 
2 l3 G9 f: `7 F0 h& ]; |9 J5 o/ W
                a.BType=Matrix; a.VType=Matrix; a.x=0; *(luVOID *)&(a.x)=(luVOID)pMatrix3; 
# v1 ]$ E2 u. Z& M
                break;+ F5 B: X, A# I5 a' {# `) B: o

case 46:        //重载函数new 
; g( Y6 x% O# Q# a) |% F
                if(mm<2) break;3 e$ Q- k( ^* U. k

if((xx+1)->x<1 || (xx+2)->x<1 || (xx+1)->BType!=luStaData_int64 || (xx+2)->BType!=luStaData_int64) break; 
0 Z/ _- ~\\" M2 ~7 x
                pMatrix3=NewMatrix((luVOID)(xx+1)->x,(luVOID)(xx+2)->x);//生成新矩阵 
4 r9 [$ Q8 D% e( g% A# R* A
                if(!pMatrix3) break; 
3 \8 a6 [7 B7 U0 |+ |7 l% a
                for(j=0,i=3;i<=mm;i++,j++)        //赋初值/ |' e& X5 l0 O* U1 g7 Q) l\\" _0 \+ L

{2 i, \4 @/ [. p* F9 s3 a

if(j>=pMatrix3->ArrayLen) break; 
1 P3 m8 X4 q% c% i
                        if((xx+i)->BType!=luStaData_double) break;        //只接受实数参数 
5 {8 n/ K0 s* m6 g( }/ a% m
                        pMatrix3->Array[j]=*(double *)&((xx+i)->x); 
* y6 A  l0 [+ e
                }* Y6 ?# d, R  j1 w; ^& Z

FunReObj(hFor);        //告诉Lu，返回一个动态对象 
. O' N* g9 ^4 [
                a.BType=Matrix; a.VType=Matrix; a.x=0; *(luVOID *)&(a.x)=(luVOID)pMatrix3;  U+ @: @6 n! A2 e1 ^& C) O

break; 
/ V1 u, S: ~, P- Z: \
        case 49:        //重载函数o 
* O! ?  M3 L( a
                pMessage=(luMessage)SearchKey("\0\0\0\0",sizeof(luVOID),luPubKey_User); 
* i  s& i. `5 G\\" q% t
                if(!pMessage) break; 
0 U; i2 {* ]; _2 c, O) U
                pMatrix1=(myMatrix *)SearchKey((char *)&(xx->x),sizeof(luVOID),Matrix);& t% H  c1 a' l. n

if(!pMatrix1) break;        //对象句柄无效，不是矩阵& R7 s  r; q% Q2 D6 U  k6 u

pa=pMatrix1->Array;, [\\" ^4 Q6 L; B

m=pMatrix1->Dim[0]; n=pMatrix1->Dim[1]; k=0;# |. L$ _( ~1 I2 D6 h

for(i=0; i<m; i++)        //输出矩阵0 ?) K# W; n7 t. x% h

{ 
' k0 W# D; @7 x; }6 T' f, z
                        pMessage(L"\r\n"); k+=2; 
# p6 D\\" Q3 P$ Y. c6 ]
                        for(j=0; j<n; j++) 
5 V; @# g! V\\" I8 `1 `) X2 [
                        {, A+ Y# w: L. U\\" z6 s, I

_gcvt_s(chNum,pa[i*n+j],16); 
* T( G6 h- o: q& C0 h0 z0 \\\" U; g  m
                                for(u=0;chNum[u];u++) {wchNum[u]=chNum[u]; k++;} 
; [* Y4 {- n5 u
                                wchNum[u]='\0'; 
3 V6 i/ X7 x* J  `9 _
                                pMessage(wchNum); pMessage(L"  "); k+=2; 
* X2 Z* @3 Q+ f6 v
                        } 
2 _' u: g& b2 f1 l: ~' V, F4 D0 n, t
                } 
0 c! f1 L/ B* u2 \
                pMessage(L"\r\n"); k+=2; 
: t: E8 ~7 t, Y2 X: p
                a.BType=luStaData_int64; a.VType=luStaData_int64; a.x=k;        //按函数o的要求，返回输出的字符总数, \  g; @/ l% y& V& d

break;! R4 `, P4 f2 m

default: 
2 C% \! S# W. S
                break; 
& h7 r8 w6 ~6 _+ o$ x: t0 @+ b
        } 
/ b% B' d% a* B0 B1 E( I
        return a; 
! Y; H% }) U! b; W1 t: G3 }
}9 t7 t2 }- ?9 X) Z+ Z+ ~

void main(void)5 p: F% C/ l9 M' }+ h9 U

{6 J\\" B' Q% W\\" U$ e1 ^% N( [

void *hFor;                //表达式句柄( e\\" {5 R5 ~1 E7 ~

luINT nPara;                //存放表达式的自变量个数 
) r' A/ O7 }2 z: E2 F% ?
        LuData *pPara;                //存放输入自变量的数组指针 
* F' R) k* z2 ]( r  ^( L
        luINT ErrBegin,ErrEnd;        //表达式编译出错的初始位置和结束位置 
! U+ B- @+ v0 I& n; V
        int ErrCode;                //错误代码& N2 f0 B& L# b2 J+ Z

void *v;! G8 z$ ?6 d* v% ?3 w

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.]}";//字符串表达式，矩阵乘0 z5 A5 u9 R/ R/ P! ]8 {- 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.]}";//字符串表达式，矩阵点乘 
9 r& j& z' Y/ H  c$ _* ^& n: u5 y
        LuData Val;: w: |$ l/ G: t8 [

if(!InitLu()) return;        //初始化Lu\\" c/ t' p8 v7 z; }1 r! A  L, c\\" c

while(LockKey(Matrix,DelMatrix,OpMatrix)){Matrix--;}        //锁定一个键，用于存储矩阵扩展类型 
0 o* c9 Q4 N+ r# J) l9 l. g
/ k* u0 W; ]9 h/ r$ n, ~

Val.BType=luStaData_int64; Val.VType=luStaData_int64; Val.x=Matrix;        //定义整数常量5 {3 P# u4 w, C& N; L

SetConst(L"matrix",&Val);        //设置整数常量 
8 F5 |\\" p$ U$ t\\" E' ]9 x: c
        InsertKey("\0\0\0\0",4,luPubKey_User,LuMessage,NULL,NULL,1,v); //使Lu运行时可输出函数信息8 h+ P& I/ V  Q

wcout.imbue(locale("chs"));        //设置输出的locale为中文; Y! J; l3 {& d6 A& r4 Q3 D

9 E! P, W- X0 |- I% A6 x

ErrCode=LuCom(ForStr,0,0,0,hFor,nPara,pPara,ErrBegin,ErrEnd); //编译表达式7 w/ O3 ~) j* ]$ `: O\\" C' L+ j

if(ErrCode) 
/ D! S! c& Z4 M/ p5 I. Z
        { 
' c. O; y6 P2 L
                wcout<<L"表达式有错误！错误代码："<<ErrCode<<endl;6 L3 u  o& O: V6 K; }2 y* J$ j( c1 B

}$ Q/ o; x7 @' M  _  W( T

else 
& L& J- _, Q1 p' D6 W
        {: {% ?8 N  o/ X7 v9 u4 D  d% C

LuCal(hFor,pPara);        //计算表达式的值 
2 ?( Y  x1 A  p/ J2 ~# U/ M3 n3 N% m5 u
        }1 t; x; H' ]- Z/ h! [

LockKey(Matrix,NULL,OpMatrix);//解锁键Matrix，本例中，该函数可以不用 
4 |: p7 ~1 D- c4 q& [; q( z\\" N, q
        FreeLu();                        //释放Lu( v  r1 x' V/ s0 F6 e- v

}

习题：

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

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

main(:a,b,c,d,t,i)=
\" s- m/ ]. r5 u* i6 U
a=new[matrix,2,2: 1.,2.,2.,1.],
, G( o0 [6 M8 @
b=new[matrix,2,2: 2.,1.,1.,2.],; g9 K( j/ b5 j0 g7 {: X4 b- S
c=new[matrix,2,2: 2/3.,-1/3.,-1/3.,2/3.],
, l: }1 ]9 u0 S* S+ I7 d
t=clock(),& d: Q- M4 N' d! f
d=a*b, i=0, while{i<1000000, d=d*c*b, i++},
) [7 ~4 h* P: K% N! W6 _
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\"}";//字符串表达式

复制代码

结果：