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

查看: 9051|回复: 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>
* {- g f1 D5 t/ h% z
#include <iostream>. g+ n3 |; N# C
#include <math.h>1 g7 _: K7 n4 A+ @
#include "lu32.h"
! }* Z q. R2 J
#pragma comment( lib, "lu32.lib" )3 @+ R. P/ S; W8 \6 `
using namespace std;
/ E& t! `8 R! Q3 g K0 \
//自定义矩阵
, R8 y0 W9 H# ~1 h9 w( A9 g
class myMatrix. G+ L& X* Z8 {! H% q4 W
{
1 N/ T6 r/ Y. \- t. C( ^
public:
1 z4 |7 `1 J' x, o
double *Array; //数据缓冲区- a2 k& b/ ]\\" a1 C/ i y* d
luVOID ArrayLen; //数据缓冲区长度
. \* E% |, h+ `
luVOID Dim[2]; //矩阵维数
+ E5 ]2 k0 K% S2 u5 E5 P
myMatrix(){Array=NULL; ArrayLen=0; Dim[0]=0; Dim[1]=0;}
0 J0 H% M \1 ?9 V$ E+ U3 G
~myMatrix() Q# I# S- z6 P# I! K( C3 ]- C* X
{
7 z# n/ |, K' C8 g) L
if(Array) delete[] Array;
1 P; g5 N% Q6 z
}\\" Y, l+ `1 m. Z; i\\" G, [& g4 H# X: ^
};' U& j9 X\\" v2 \( F7 ^
luKEY Matrix=-1000; //标识矩阵类型，最终的Matrix由LockKey决定 B$ y0 [. l5 T+ N
void _stdcall LuMessage(wchar_t *pch)//输出动态库信息，该函数注册到Lu，由Lu二级函数调用 % o, n! @( `. \4 e: ?; s% p
{: N8 k; V: D4 F: S& B8 H
wcout<<pch;
\\" Z5 B% |# K0 {: c+ X; A
}2 b& r& ]. S( l, z
void _stdcall DelMatrix(void *me) //用于LockKey函数及InsertKey函数，使Lu能自动销毁myMatrix对象# q- C- P0 S! _9 d
{
7 ` |3 i( ^3 P, w
delete (myMatrix *)me;4 w6 b ]6 h4 n+ O9 l
}- [- s9 h! [- o/ ?2 U
myMatrix * _stdcall NewMatrix(luVOID m,luVOID n) //生成一个myMatrix对象3 G8 g' N9 ]% j$ f
{8 I9 [& L( W. E
myMatrix *pMatrix;
/ b\\" i1 |! H; h* V+ l
luVOID k;
7 J1 r: w1 q: M5 ?
double *pa;3 o/ x6 j$ w- J: e) N\\" G
char keyname[sizeof(luVOID)];, N- A# m2 j2 w0 K
void *NowKey;- E5 R: y1 D! M8 h
k=m*n;
. o% `1 @) f2 f8 Y) r
pMatrix=(myMatrix *)GetBufObj(Matrix,keyname);//先尝试从缓冲区中获取一个矩阵对象\\" D+ h$ f8 P7 [+ [& V9 q9 v
if(pMatrix)
# }. Z+ k# L/ b\\" y. J& J
{
: [, S* F7 ]0 C2 k8 L/ B9 P& } l3 G
if(pMatrix->ArrayLen!=k) //重置矩阵的大小
e, }' X: p( a\\" E& w
{
% M# l; P: m$ {6 U; M I, q
pa=new double[k];/ o: e. o$ E3 K. o! V/ I
if(!pa)
& ^- @1 o9 h1 ]; K. o6 F' F, L\\" r
{
Z- N& A& e* |* ~* Y+ R
DeleteKey(keyname,sizeof(luVOID),Matrix,DelMatrix,1); //将矩阵对象放回缓冲区1 V& }& a0 H3 ^) b
return NULL;
' i) T7 @( {5 N! N# g/ M
}5 s( w8 @4 l, `
delete[] pMatrix->Array;
& N) y) A& a3 ^+ N3 |2 F
pMatrix->Array=pa;' a5 B) X& `! K/ k' }9 x# i
}
% }- M2 ~& Z) [3 P
}
' t. Q l7 Z3 @7 Q/ O _
else
7 |2 E4 D# u8 Q# C6 w
{; q0 r2 Q+ S: _- c6 e& j\\" o
pMatrix=new myMatrix; //创建矩阵对象0 `6 B4 I\\" m! {
if(!pMatrix) return NULL;
3 l5 W3 G' R( G7 v# F1 r, m' W$ q
pMatrix->Array=new double[k];
! w& y2 ~) D( y7 A3 H
if(!pMatrix->Array)' h; P0 H7 @/ y3 g. v
{% c# J. w% c! b
delete pMatrix;3 O, _5 Z2 @. [- r X1 n
return NULL;
6 n R) A. S0 s) I
}5 a* U2 U: N\\" E5 X3 }
if(InsertKey((char *)&pMatrix,-1,Matrix,pMatrix,DelMatrix,NULL,0,NowKey)) //将矩阵对象注册到Lu
- i' h; ?8 F# Q* h6 E* i
{
! R5 c, g: G: M C5 s; G
delete pMatrix;( r+ }\\" k\\" J! _: b3 o
return NULL;
\\" X' c! u3 |# I
}
, W+ Q- t* c p% I
}4 F( c. O: V5 p- |& {
pMatrix->ArrayLen=k; pMatrix->Dim[0]=m; pMatrix->Dim[1]=n;3 `. }' H4 f0 J0 U! j, `) G
return pMatrix;# r7 F% ^& z, o6 r* [$ \; K3 x- K
}) w1 p% M) G6 A+ i* S
LuData _stdcall OpMatrix(luINT mm,LuData *xx,void *hFor,int theOperator) //运算符重载函数，用于LockKey函数
! L% Z0 M\\" o, x9 [4 Y& S
{5 F! W8 z! ]) L: f. a( R; A
LuData a;4 T1 B( C) G, l( j9 U* n! X) D
myMatrix *pMatrix1,*pMatrix2,*pMatrix3;* s7 B* E$ u T9 W4 J9 R$ q
luVOID i,j,k,m,n,u,v;
$ p1 h% A6 ~ a9 H
double *pa,*pb,*pc;) P$ N9 b( k0 o2 r% |$ }- }
luMessage pMessage;& [( @7 z: v7 l* i | R2 H
wchar_t wchNum[32];; m' S$ ^\\" b* p* w# Q) H
char chNum[32];! f% L. w! y3 I' k
a.BType=luStaData_nil; a.VType=luStaData_nil; a.x=0;9 d- W4 n1 L/ n( ~\\" c\\" U
switch(theOperator)- v, o0 l1 M9 s5 |% J* i5 n
{2 G+ Q0 v% ?3 ~% d) Q
case 2: //重载运算符** b! x7 D e# D\\" d {0 C3 S/ Y
pMatrix1=(myMatrix *)SearchKey((char *)&(xx->x),sizeof(luVOID),Matrix);. ?) o$ N, K% H0 H5 i7 I
pMatrix2=(myMatrix *)SearchKey((char *)&((xx+1)->x),sizeof(luVOID),Matrix);
/ }1 U/ {8 y$ J/ y: S6 @; }
if(!pMatrix1 || !pMatrix2) break; //对象句柄无效，不是矩阵
8 o7 Q5 y6 y/ \1 u1 M1 A9 r3 i
if(pMatrix1->Dim[1]!=pMatrix2->Dim[0]) break; //维数不匹配
* k* ]/ u) U: G4 Q6 X
pMatrix3=NewMatrix(pMatrix1->Dim[0],pMatrix2->Dim[1]); //生成新矩阵6 n* K' E6 i( Q# n( H
if(!pMatrix3) break;
4 H9 s6 o) D* C( p
pa=pMatrix1->Array; pb=pMatrix2->Array; pc=pMatrix3->Array;
, n! V9 `0 m2 `
m=pMatrix1->Dim[0]; n=pMatrix1->Dim[1]; k=pMatrix2->Dim[1];7 a! ~8 `* H1 n6 J0 s
for(i=0; i<m; i++) //矩阵乘3 ?' @! v% z: {\\" l5 N; V
{. U, F) o4 ~6 M/ g6 I% Q
for(j=0; j<k; j++); c$ C) w7 s/ ]2 V8 o/ I! ~$ W
{+ a# D+ I7 q5 g8 X6 j6 c! t
u=i*k+j; pc[u]=0.0;\\" O6 ?7 N. P+ C' Q' s5 ~# V
for (v=0; v<n; v++)& _% J\\" Q1 G' l
{
: o+ Y, H5 ?: R2 l) L* U$ J0 t* c, k6 C
pc[u]=pc[u]+pa[i*n+v]*pb[v*k+j];
8 @) L5 ?3 Z' c% }) S5 q3 f
}5 Z6 f2 z5 u8 f+ V y# Y
}
5 m+ S# @1 g# n+ k& |* g$ J& D
}
~6 C( D$ ]$ P1 i5 ^4 G* s* n
FunReObj(hFor); //告诉Lu，返回一个动态对象
0 J5 x% c9 k! F+ B- X
a.BType=Matrix; a.VType=Matrix; a.x=0; *(luVOID *)&(a.x)=(luVOID)pMatrix3;, b% x2 H& [\\" C7 b6 v: e/ A
break;. D: {) i$ P' l5 p S8 {+ z3 r
case 25: //重载运算符.*
+ s* C9 ^ _0 v
pMatrix1=(myMatrix *)SearchKey((char *)&(xx->x),sizeof(luVOID),Matrix);
# z( j& h6 P+ k- \3 X/ o
pMatrix2=(myMatrix *)SearchKey((char *)&((xx+1)->x),sizeof(luVOID),Matrix);. ]: W9 Z$ Q1 p; j- T
if(!pMatrix1 || !pMatrix2) break; //对象句柄无效，不是矩阵/ S) [. f# E/ b% H& p* y3 G
if(pMatrix1->Dim[0]!=pMatrix2->Dim[0] || pMatrix1->Dim[1]!=pMatrix2->Dim[1]) break; //维数不相同
) C( a# \2 q5 n( I2 |# r
pMatrix3=NewMatrix(pMatrix1->Dim[0],pMatrix1->Dim[1]); //生成新矩阵% z5 `6 x- @ P/ p
if(!pMatrix3) break;
& T7 ?3 ~6 W# ]; C( I( x
for(i=0;i<pMatrix1->ArrayLen;i++) pMatrix3->Array[i]=pMatrix1->Array[i]*pMatrix2->Array[i]; //矩阵点乘
+ ]+ k# F; ?7 x3 D
FunReObj(hFor); //告诉Lu，返回一个动态对象
a.BType=Matrix; a.VType=Matrix; a.x=0; *(luVOID *)&(a.x)=(luVOID)pMatrix3;
& ^$ L( _$ A( }
break;
( w3 r3 j8 r5 i z' _ m! q
case 46: //重载函数new( q# C: L1 k* p5 E3 l( c
if(mm<2) break;
+ X. n; {7 ?3 h( n
if((xx+1)->x<1 || (xx+2)->x<1 || (xx+1)->BType!=luStaData_int64 || (xx+2)->BType!=luStaData_int64) break;
A% S5 e+ i1 T6 q
pMatrix3=NewMatrix((luVOID)(xx+1)->x,(luVOID)(xx+2)->x);//生成新矩阵; R( w) S( F8 y, r3 v
if(!pMatrix3) break;
7 \' ^4 v8 D x# F% L
for(j=0,i=3;i<=mm;i++,j++) //赋初值
- [! ~ W: H' H$ n1 z
{
4 C' v: P6 v- C, I
if(j>=pMatrix3->ArrayLen) break;% I$ Y1 o( Z* s6 ]
if((xx+i)->BType!=luStaData_double) break; //只接受实数参数% n\\" c2 U6 c+ U9 c* c M9 r
pMatrix3->Array[j]=*(double *)&((xx+i)->x);; L9 D: n. q2 t
}# R4 ~6 n) b/ K, N' b N% R# v& ~
FunReObj(hFor); //告诉Lu，返回一个动态对象. E' e! X! C: [1 y/ F' Z
a.BType=Matrix; a.VType=Matrix; a.x=0; *(luVOID *)&(a.x)=(luVOID)pMatrix3;8 J3 X9 `/ W/ N9 l7 i
break;
$ c9 x/ S j& q# ]8 [4 e7 v E
case 49: //重载函数o6 D& k& h\\" L' ]) R( A0 b
pMessage=(luMessage)SearchKey("\0\0\0\0",sizeof(luVOID),luPubKey_User);
O0 {5 l n6 y
if(!pMessage) break;: i0 B7 |% K+ o0 t) L
pMatrix1=(myMatrix *)SearchKey((char *)&(xx->x),sizeof(luVOID),Matrix);
) ]! F3 T. H/ [6 m: ~
if(!pMatrix1) break; //对象句柄无效，不是矩阵, I& q z2 j4 P) o9 {% e* B
pa=pMatrix1->Array;. ]. B( {! b/ ^) t% k
m=pMatrix1->Dim[0]; n=pMatrix1->Dim[1]; k=0;3 `; l; U. @+ X& U6 J: l: ^) @
for(i=0; i<m; i++) //输出矩阵
8 L6 W4 ~; r+ r
{
+ H% x0 t& {7 C' ~\\" N$ A. C
pMessage(L"\r\n"); k+=2;
9 G4 z! `( f- |2 r\\" }7 }
for(j=0; j<n; j++)1 r: G5 C3 N1 ?; Z% [8 Z
{% } j7 ?2 E# V: @. T+ \
_gcvt_s(chNum,pa[i*n+j],16);\\" W- [1 B5 `4 g
for(u=0;chNum[u];u++) {wchNum[u]=chNum[u]; k++;}
2 C9 P# f; a5 n: E
wchNum[u]='\0';
& X' y6 o& j1 P$ H4 H. V- Q& I
pMessage(wchNum); pMessage(L" "); k+=2;
\\" W( @; R& ~2 b* M3 H
}( i, D/ K6 A$ m, Z# A Z
}
, o+ r+ t1 d/ p0 Z8 b7 `4 P
pMessage(L"\r\n"); k+=2;* h1 N! b! D\\" J9 z# l0 a) g3 j
a.BType=luStaData_int64; a.VType=luStaData_int64; a.x=k; //按函数o的要求，返回输出的字符总数1 z; P2 A( R2 I4 r
break;2 v* S4 N+ Y }3 ~
default:
8 z2 c1 ^% e: a# g6 b1 z
break;
( k: e& G# D9 l
}
0 u! H, t% L e9 g
return a;
, Q' S' O1 t\\" `
}
* I/ u- o \! C
void main(void)' P. n! D5 \* c7 T
{' A) K0 u\\" }8 n, E- ?5 p' d1 D
void *hFor; //表达式句柄
: |0 ]( R+ c4 e, S, }$ [2 T8 ^2 ~
luINT nPara; //存放表达式的自变量个数
6 e% a: U5 ^: Z& @
LuData *pPara; //存放输入自变量的数组指针* B& s5 B4 u' q4 c) c, K* \\\" |
luINT ErrBegin,ErrEnd; //表达式编译出错的初始位置和结束位置\\" i# u. }; u7 S5 [( ?, R
int ErrCode; //错误代码6 s8 S B+ K }/ Y
void *v;. y1 ]: g4 l$ K% M
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.]}";//字符串表达式，矩阵乘
- |' V( f4 }1 K2 h
//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.]}";//字符串表达式，矩阵点乘
3 `4 ^2 A, d$ w- J2 B$ |
LuData Val; f( f* ]' S9 y. m* ]8 m
if(!InitLu()) return; //初始化Lu, n, g+ z9 {, ^$ C1 q
while(LockKey(Matrix,DelMatrix,OpMatrix)){Matrix--;} //锁定一个键，用于存储矩阵扩展类型
! O3 k7 V V: M2 B
/ t6 C f& K4 t+ X9 R
Val.BType=luStaData_int64; Val.VType=luStaData_int64; Val.x=Matrix; //定义整数常量
4 o( k& ~' k: |, q( L
SetConst(L"matrix",&Val); //设置整数常量
) m5 P( M) x; k o
InsertKey("\0\0\0\0",4,luPubKey_User,LuMessage,NULL,NULL,1,v); //使Lu运行时可输出函数信息
8 A9 g% D5 |0 Y& e# P
wcout.imbue(locale("chs")); //设置输出的locale为中文
! V: } a6 v; z6 f k) K7 t, O
5 V W5 k, N3 F9 N! w% g
ErrCode=LuCom(ForStr,0,0,0,hFor,nPara,pPara,ErrBegin,ErrEnd); //编译表达式' [, Z& j% e/ B* D) D8 L% A6 Q2 c8 o
if(ErrCode)
2 a3 ^9 M\\" e7 \0 x' A
{0 Z7 z' l8 x2 E\\" B, a! b
wcout<<L"表达式有错误！错误代码："<<ErrCode<<endl;
8 W6 N\\" X, X# Y- W2 H
}
+ \$ m2 I2 z W
else
\\" ]/ l8 ?% m7 _1 z, _2 c! H4 H
{
* ]7 z3 z* v1 e2 a; ^- }' r
LuCal(hFor,pPara); //计算表达式的值
}( i& N, V' D1 I
LockKey(Matrix,NULL,OpMatrix);//解锁键Matrix，本例中，该函数可以不用) Z- g* S, s l/ S2 f( G
FreeLu(); //释放Lu+ x: ^( @; S# I T3 [# J/ A
}

#include <windows.h> 
* {- g  f1 D5 t/ h% z
#include <iostream>. g+ n3 |; N# C

#include <math.h>1 g7 _: K7 n4 A+ @

#include "lu32.h" 
! }* Z  q. R2 J
#pragma comment( lib, "lu32.lib" )3 @+ R. P/ S; W8 \6 `

using namespace std; 
/ E& t! `8 R! Q3 g  K0 \
//自定义矩阵 
, R8 y0 W9 H# ~1 h9 w( A9 g
class myMatrix. G+ L& X* Z8 {! H% q4 W

{ 
1 N/ T6 r/ Y. \- t. C( ^
public: 
1 z4 |7 `1 J' x, o
        double *Array;        //数据缓冲区- a2 k& b/ ]\\" a1 C/ i  y* d

luVOID ArrayLen;        //数据缓冲区长度 
. \* E% |, h+ `
        luVOID Dim[2];        //矩阵维数 
+ E5 ]2 k0 K% S2 u5 E5 P
        myMatrix(){Array=NULL; ArrayLen=0; Dim[0]=0; Dim[1]=0;} 
0 J0 H% M  \1 ?9 V$ E+ U3 G
        ~myMatrix()  Q# I# S- z6 P# I! K( C3 ]- C* X

{ 
7 z# n/ |, K' C8 g) L
                if(Array) delete[] Array; 
1 P; g5 N% Q6 z
        }\\" Y, l+ `1 m. Z; i\\" G, [& g4 H# X: ^

};' U& j9 X\\" v2 \( F7 ^

luKEY Matrix=-1000;        //标识矩阵类型，最终的Matrix由LockKey决定  B$ y0 [. l5 T+ N

void _stdcall LuMessage(wchar_t *pch)//输出动态库信息，该函数注册到Lu，由Lu二级函数调用 % o, n! @( `. \4 e: ?; s% p

{: N8 k; V: D4 F: S& B8 H

wcout<<pch; 
\\" Z5 B% |# K0 {: c+ X; A
}2 b& r& ]. S( l, z

void _stdcall DelMatrix(void *me)        //用于LockKey函数及InsertKey函数，使Lu能自动销毁myMatrix对象# q- C- P0 S! _9 d

{ 
7 `  |3 i( ^3 P, w
        delete (myMatrix *)me;4 w6 b  ]6 h4 n+ O9 l

}- [- s9 h! [- o/ ?2 U

myMatrix * _stdcall NewMatrix(luVOID m,luVOID n)        //生成一个myMatrix对象3 G8 g' N9 ]% j$ f

{8 I9 [& L( W. E

myMatrix *pMatrix; 
/ b\\" i1 |! H; h* V+ l
        luVOID k; 
7 J1 r: w1 q: M5 ?
        double *pa;3 o/ x6 j$ w- J: e) N\\" G

char keyname[sizeof(luVOID)];, N- A# m2 j2 w0 K

void *NowKey;- E5 R: y1 D! M8 h

k=m*n; 
. o% `1 @) f2 f8 Y) r
        pMatrix=(myMatrix *)GetBufObj(Matrix,keyname);//先尝试从缓冲区中获取一个矩阵对象\\" D+ h$ f8 P7 [+ [& V9 q9 v

if(pMatrix) 
# }. Z+ k# L/ b\\" y. J& J
        { 
: [, S* F7 ]0 C2 k8 L/ B9 P& }  l3 G
                if(pMatrix->ArrayLen!=k)        //重置矩阵的大小 
  e, }' X: p( a\\" E& w
                { 
% M# l; P: m$ {6 U; M  I, q
                        pa=new double[k];/ o: e. o$ E3 K. o! V/ I

if(!pa) 
& ^- @1 o9 h1 ]; K. o6 F' F, L\\" r
                        { 
  Z- N& A& e* |* ~* Y+ R
                                DeleteKey(keyname,sizeof(luVOID),Matrix,DelMatrix,1);        //将矩阵对象放回缓冲区1 V& }& a0 H3 ^) b

return NULL; 
' i) T7 @( {5 N! N# g/ M
                        }5 s( w8 @4 l, `

delete[] pMatrix->Array; 
& N) y) A& a3 ^+ N3 |2 F
                        pMatrix->Array=pa;' a5 B) X& `! K/ k' }9 x# i

} 
% }- M2 ~& Z) [3 P
        } 
' t. Q  l7 Z3 @7 Q/ O  _
        else 
7 |2 E4 D# u8 Q# C6 w
        {; q0 r2 Q+ S: _- c6 e& j\\" o

pMatrix=new myMatrix;        //创建矩阵对象0 `6 B4 I\\" m! {

if(!pMatrix) return NULL; 
3 l5 W3 G' R( G7 v# F1 r, m' W$ q
                pMatrix->Array=new double[k]; 
! w& y2 ~) D( y7 A3 H
                if(!pMatrix->Array)' h; P0 H7 @/ y3 g. v

{% c# J. w% c! b

delete pMatrix;3 O, _5 Z2 @. [- r  X1 n

return NULL; 
6 n  R) A. S0 s) I
                }5 a* U2 U: N\\" E5 X3 }

if(InsertKey((char *)&pMatrix,-1,Matrix,pMatrix,DelMatrix,NULL,0,NowKey))        //将矩阵对象注册到Lu 
- i' h; ?8 F# Q* h6 E* i
                { 
! R5 c, g: G: M  C5 s; G
                        delete pMatrix;( r+ }\\" k\\" J! _: b3 o

return NULL; 
\\" X' c! u3 |# I
                } 
, W+ Q- t* c  p% I
        }4 F( c. O: V5 p- |& {

pMatrix->ArrayLen=k; pMatrix->Dim[0]=m; pMatrix->Dim[1]=n;3 `. }' H4 f0 J0 U! j, `) G

return pMatrix;# r7 F% ^& z, o6 r* [$ \; K3 x- K

}) w1 p% M) G6 A+ i* S

LuData _stdcall OpMatrix(luINT mm,LuData *xx,void *hFor,int theOperator)        //运算符重载函数，用于LockKey函数 
! L% Z0 M\\" o, x9 [4 Y& S
{5 F! W8 z! ]) L: f. a( R; A

LuData a;4 T1 B( C) G, l( j9 U* n! X) D

myMatrix *pMatrix1,*pMatrix2,*pMatrix3;* s7 B* E$ u  T9 W4 J9 R$ q

luVOID i,j,k,m,n,u,v; 
$ p1 h% A6 ~  a9 H
        double *pa,*pb,*pc;) P$ N9 b( k0 o2 r% |$ }- }

luMessage pMessage;& [( @7 z: v7 l* i  |  R2 H

wchar_t wchNum[32];; m' S$ ^\\" b* p* w# Q) H

char chNum[32];! f% L. w! y3 I' k

a.BType=luStaData_nil; a.VType=luStaData_nil; a.x=0;9 d- W4 n1 L/ n( ~\\" c\\" U

switch(theOperator)- v, o0 l1 M9 s5 |% J* i5 n

{2 G+ Q0 v% ?3 ~% d) Q

case 2:        //重载运算符** b! x7 D  e# D\\" d  {0 C3 S/ Y

pMatrix1=(myMatrix *)SearchKey((char *)&(xx->x),sizeof(luVOID),Matrix);. ?) o$ N, K% H0 H5 i7 I

pMatrix2=(myMatrix *)SearchKey((char *)&((xx+1)->x),sizeof(luVOID),Matrix); 
/ }1 U/ {8 y$ J/ y: S6 @; }
                if(!pMatrix1 || !pMatrix2) break;        //对象句柄无效，不是矩阵 
8 o7 Q5 y6 y/ \1 u1 M1 A9 r3 i
                if(pMatrix1->Dim[1]!=pMatrix2->Dim[0]) break;        //维数不匹配 
* k* ]/ u) U: G4 Q6 X
                pMatrix3=NewMatrix(pMatrix1->Dim[0],pMatrix2->Dim[1]);        //生成新矩阵6 n* K' E6 i( Q# n( H

if(!pMatrix3) break; 
4 H9 s6 o) D* C( p
                pa=pMatrix1->Array; pb=pMatrix2->Array; pc=pMatrix3->Array; 
, n! V9 `0 m2 `
                m=pMatrix1->Dim[0]; n=pMatrix1->Dim[1]; k=pMatrix2->Dim[1];7 a! ~8 `* H1 n6 J0 s

for(i=0; i<m; i++)        //矩阵乘3 ?' @! v% z: {\\" l5 N; V

{. U, F) o4 ~6 M/ g6 I% Q

for(j=0; j<k; j++); c$ C) w7 s/ ]2 V8 o/ I! ~$ W

{+ a# D+ I7 q5 g8 X6 j6 c! t

u=i*k+j; pc[u]=0.0;\\" O6 ?7 N. P+ C' Q' s5 ~# V

for (v=0; v<n; v++)& _% J\\" Q1 G' l

{ 
: o+ Y, H5 ?: R2 l) L* U$ J0 t* c, k6 C
                                        pc[u]=pc[u]+pa[i*n+v]*pb[v*k+j]; 
8 @) L5 ?3 Z' c% }) S5 q3 f
                                }5 Z6 f2 z5 u8 f+ V  y# Y

} 
5 m+ S# @1 g# n+ k& |* g$ J& D
                } 
  ~6 C( D$ ]$ P1 i5 ^4 G* s* n
                FunReObj(hFor);        //告诉Lu，返回一个动态对象 
0 J5 x% c9 k! F+ B- X
                a.BType=Matrix; a.VType=Matrix; a.x=0; *(luVOID *)&(a.x)=(luVOID)pMatrix3;, b% x2 H& [\\" C7 b6 v: e/ A

break;. D: {) i$ P' l5 p  S8 {+ z3 r

case 25:        //重载运算符.* 
+ s* C9 ^  _0 v
                pMatrix1=(myMatrix *)SearchKey((char *)&(xx->x),sizeof(luVOID),Matrix); 
# z( j& h6 P+ k- \3 X/ o
                pMatrix2=(myMatrix *)SearchKey((char *)&((xx+1)->x),sizeof(luVOID),Matrix);. ]: W9 Z$ Q1 p; j- T

if(!pMatrix1 || !pMatrix2) break;        //对象句柄无效，不是矩阵/ S) [. f# E/ b% H& p* y3 G

if(pMatrix1->Dim[0]!=pMatrix2->Dim[0] || pMatrix1->Dim[1]!=pMatrix2->Dim[1]) break;        //维数不相同 
) C( a# \2 q5 n( I2 |# r
                pMatrix3=NewMatrix(pMatrix1->Dim[0],pMatrix1->Dim[1]);        //生成新矩阵% z5 `6 x- @  P/ p

if(!pMatrix3) break; 
& T7 ?3 ~6 W# ]; C( I( x
                for(i=0;i<pMatrix1->ArrayLen;i++) pMatrix3->Array[i]=pMatrix1->Array[i]*pMatrix2->Array[i];        //矩阵点乘 
+ ]+ k# F; ?7 x3 D
                FunReObj(hFor);        //告诉Lu，返回一个动态对象 
& y0 P# m- h\\" \. e5 U$ m  M6 h; ^) ^
                a.BType=Matrix; a.VType=Matrix; a.x=0; *(luVOID *)&(a.x)=(luVOID)pMatrix3; 
& ^$ L( _$ A( }
                break; 
( w3 r3 j8 r5 i  z' _  m! q
        case 46:        //重载函数new( q# C: L1 k* p5 E3 l( c

if(mm<2) break; 
+ X. n; {7 ?3 h( n
                if((xx+1)->x<1 || (xx+2)->x<1 || (xx+1)->BType!=luStaData_int64 || (xx+2)->BType!=luStaData_int64) break; 
  A% S5 e+ i1 T6 q
                pMatrix3=NewMatrix((luVOID)(xx+1)->x,(luVOID)(xx+2)->x);//生成新矩阵; R( w) S( F8 y, r3 v

if(!pMatrix3) break; 
7 \' ^4 v8 D  x# F% L
                for(j=0,i=3;i<=mm;i++,j++)        //赋初值 
- [! ~  W: H' H$ n1 z
                { 
4 C' v: P6 v- C, I
                        if(j>=pMatrix3->ArrayLen) break;% I$ Y1 o( Z* s6 ]

if((xx+i)->BType!=luStaData_double) break;        //只接受实数参数% n\\" c2 U6 c+ U9 c* c  M9 r

pMatrix3->Array[j]=*(double *)&((xx+i)->x);; L9 D: n. q2 t

}# R4 ~6 n) b/ K, N' b  N% R# v& ~

FunReObj(hFor);        //告诉Lu，返回一个动态对象. E' e! X! C: [1 y/ F' Z

a.BType=Matrix; a.VType=Matrix; a.x=0; *(luVOID *)&(a.x)=(luVOID)pMatrix3;8 J3 X9 `/ W/ N9 l7 i

break; 
$ c9 x/ S  j& q# ]8 [4 e7 v  E
        case 49:        //重载函数o6 D& k& h\\" L' ]) R( A0 b

pMessage=(luMessage)SearchKey("\0\0\0\0",sizeof(luVOID),luPubKey_User); 
  O0 {5 l  n6 y
                if(!pMessage) break;: i0 B7 |% K+ o0 t) L

pMatrix1=(myMatrix *)SearchKey((char *)&(xx->x),sizeof(luVOID),Matrix); 
) ]! F3 T. H/ [6 m: ~
                if(!pMatrix1) break;        //对象句柄无效，不是矩阵, I& q  z2 j4 P) o9 {% e* B

pa=pMatrix1->Array;. ]. B( {! b/ ^) t% k

m=pMatrix1->Dim[0]; n=pMatrix1->Dim[1]; k=0;3 `; l; U. @+ X& U6 J: l: ^) @

for(i=0; i<m; i++)        //输出矩阵 
8 L6 W4 ~; r+ r
                { 
+ H% x0 t& {7 C' ~\\" N$ A. C
                        pMessage(L"\r\n"); k+=2; 
9 G4 z! `( f- |2 r\\" }7 }
                        for(j=0; j<n; j++)1 r: G5 C3 N1 ?; Z% [8 Z

{% }  j7 ?2 E# V: @. T+ \

_gcvt_s(chNum,pa[i*n+j],16);\\" W- [1 B5 `4 g

for(u=0;chNum[u];u++) {wchNum[u]=chNum[u]; k++;} 
2 C9 P# f; a5 n: E
                                wchNum[u]='\0'; 
& X' y6 o& j1 P$ H4 H. V- Q& I
                                pMessage(wchNum); pMessage(L"  "); k+=2; 
\\" W( @; R& ~2 b* M3 H
                        }( i, D/ K6 A$ m, Z# A  Z

} 
, o+ r+ t1 d/ p0 Z8 b7 `4 P
                pMessage(L"\r\n"); k+=2;* h1 N! b! D\\" J9 z# l0 a) g3 j

a.BType=luStaData_int64; a.VType=luStaData_int64; a.x=k;        //按函数o的要求，返回输出的字符总数1 z; P2 A( R2 I4 r

break;2 v* S4 N+ Y  }3 ~

default: 
8 z2 c1 ^% e: a# g6 b1 z
                break; 
( k: e& G# D9 l
        } 
0 u! H, t% L  e9 g
        return a; 
, Q' S' O1 t\\" `
} 
* I/ u- o  \! C
void main(void)' P. n! D5 \* c7 T

{' A) K0 u\\" }8 n, E- ?5 p' d1 D

void *hFor;                //表达式句柄 
: |0 ]( R+ c4 e, S, }$ [2 T8 ^2 ~
        luINT nPara;                //存放表达式的自变量个数 
6 e% a: U5 ^: Z& @
        LuData *pPara;                //存放输入自变量的数组指针* B& s5 B4 u' q4 c) c, K* \\\" |

luINT ErrBegin,ErrEnd;        //表达式编译出错的初始位置和结束位置\\" i# u. }; u7 S5 [( ?, R

int ErrCode;                //错误代码6 s8 S  B+ K  }/ Y

void *v;. y1 ]: g4 l$ K% M

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.]}";//字符串表达式，矩阵乘 
- |' V( f4 }1 K2 h
        //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.]}";//字符串表达式，矩阵点乘 
3 `4 ^2 A, d$ w- J2 B$ |
        LuData Val;  f( f* ]' S9 y. m* ]8 m

if(!InitLu()) return;        //初始化Lu, n, g+ z9 {, ^$ C1 q

while(LockKey(Matrix,DelMatrix,OpMatrix)){Matrix--;}        //锁定一个键，用于存储矩阵扩展类型 
! O3 k7 V  V: M2 B
 
/ t6 C  f& K4 t+ X9 R
        Val.BType=luStaData_int64; Val.VType=luStaData_int64; Val.x=Matrix;        //定义整数常量 
4 o( k& ~' k: |, q( L
        SetConst(L"matrix",&Val);        //设置整数常量 
) m5 P( M) x; k  o
        InsertKey("\0\0\0\0",4,luPubKey_User,LuMessage,NULL,NULL,1,v); //使Lu运行时可输出函数信息 
8 A9 g% D5 |0 Y& e# P
        wcout.imbue(locale("chs"));        //设置输出的locale为中文 
! V: }  a6 v; z6 f  k) K7 t, O
  5 V  W5 k, N3 F9 N! w% g

ErrCode=LuCom(ForStr,0,0,0,hFor,nPara,pPara,ErrBegin,ErrEnd); //编译表达式' [, Z& j% e/ B* D) D8 L% A6 Q2 c8 o

if(ErrCode) 
2 a3 ^9 M\\" e7 \0 x' A
        {0 Z7 z' l8 x2 E\\" B, a! b

wcout<<L"表达式有错误！错误代码："<<ErrCode<<endl; 
8 W6 N\\" X, X# Y- W2 H
        } 
+ \$ m2 I2 z  W
        else 
\\" ]/ l8 ?% m7 _1 z, _2 c! H4 H
        { 
* ]7 z3 z* v1 e2 a; ^- }' r
                LuCal(hFor,pPara);        //计算表达式的值 
& C% E# R\\" _  ?; |\\" S5 i: \8 y- D2 Y( M
        }( i& N, V' D1 I

LockKey(Matrix,NULL,OpMatrix);//解锁键Matrix，本例中，该函数可以不用) Z- g* S, s  l/ S2 f( G

FreeLu();                        //释放Lu+ x: ^( @; S# I  T3 [# J/ A

}

习题：

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

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

main(:a,b,c,d,t,i)=
7 J; }9 {( ]5 l, ?& D
a=new[matrix,2,2: 1.,2.,2.,1.],( Q9 Y! x) g# B6 _\" J; t
b=new[matrix,2,2: 2.,1.,1.,2.],
) T4 O+ O\" |3 S8 k8 N8 c6 J
c=new[matrix,2,2: 2/3.,-1/3.,-1/3.,2/3.],8 T9 z. `$ k4 e) d3 c
t=clock(),2 S5 D2 B9 q9 K, }) w# P
d=a*b, i=0, while{i<1000000, d=d*c*b, i++},
& O6 s( b4 q G! c1 h! c; M) W
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\"}";//字符串表达式

复制代码

结果：