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

查看: 8660|回复: 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>
1 X. v5 l h' D6 }( X, ?
#include <iostream>2 L) o9 _; |- p
#include <math.h># g8 k; I& e) c7 Z' M
#include "lu32.h"3 Y9 \* g5 h; _/ o* [! {( O
#pragma comment( lib, "lu32.lib" )/ [4 x: z/ Z& Q- O3 S3 z2 I
using namespace std;, t! V& ~8 S, @% O/ L0 W! Z
//自定义矩阵1 p: ~; a0 P: c2 z! l
class myMatrix! x/ S+ I) j) @* L4 u+ A4 G
{
: ]\\" S0 g( V: W
public:- B4 w: J\\" h l! d& K d% w
double *Array; //数据缓冲区& E5 o7 L& A. \) H6 q: F3 v
luVOID ArrayLen; //数据缓冲区长度! P% x/ F0 D& f' B
luVOID Dim[2]; //矩阵维数& E\\" { H7 y1 f/ y( M) f4 _2 T
myMatrix(){Array=NULL; ArrayLen=0; Dim[0]=0; Dim[1]=0;}4 N# C) c$ @4 x9 u
~myMatrix()
& S9 t' a8 q, _7 Y K8 I
{
! _; }! b- ?' [2 s1 F
if(Array) delete[] Array;
) t\\" f2 W8 [# j) `3 g$ c
}
, o3 C9 Q; d& C Q) R
};+ y1 F+ p6 M8 } P) v9 Q# i5 c
luKEY Matrix=-1000; //标识矩阵类型，最终的Matrix由LockKey决定$ S\\" [$ _ t% j' g0 S
void _stdcall LuMessage(wchar_t *pch)//输出动态库信息，该函数注册到Lu，由Lu二级函数调用 / R+ H) h& t* f9 v
{0 G$ S- _. r' Y# z% a
wcout<<pch;
j: F# h1 I1 f\\" X# C$ f
}\\" j* {' M* p% \6 ?2 `\\" H' M& m
void _stdcall DelMatrix(void *me) //用于LockKey函数及InsertKey函数，使Lu能自动销毁myMatrix对象- V. x8 a5 b( x; T/ N/ c0 K1 ~
{
9 V, J$ k7 V* G$ y
delete (myMatrix *)me;' t2 a& Q) W* Z4 V& S( C
}7 H/ w7 A6 X. h; V8 I
myMatrix * _stdcall NewMatrix(luVOID m,luVOID n) //生成一个myMatrix对象
, w1 U/ _, Y& X, H' g4 C1 ]
{
9 s# a& n9 \$ \
myMatrix *pMatrix;
6 s9 k: n( Q' v( }$ Z2 f4 } K\\" |
luVOID k;
; u. m# m5 E6 b& s
double *pa;\\" C j* A- [& O9 q) F
char keyname[sizeof(luVOID)];7 h# c. \& r4 Y2 E8 i
void *NowKey;
* r) N' ?$ R9 B. I/ f
k=m*n;
5 e, p& A- V# n8 Z5 j
pMatrix=(myMatrix *)GetBufObj(Matrix,keyname);//先尝试从缓冲区中获取一个矩阵对象8 L\\" v- K. X3 G! {' v ~( \
if(pMatrix)0 o' i( g9 ]: m5 g, Z o0 |- M
{
+ u5 p3 e0 m4 m2 o+ ~ l( M' q
if(pMatrix->ArrayLen!=k) //重置矩阵的大小
% Y' H8 h% w, Y8 L6 f: Q
{
' A5 D$ F0 B* k& Y; |
pa=new double[k];
+ U$ l K1 H) F, v* ?* Z
if(!pa)/ S# U+ ^1 }+ m0 U\\" ]
{
8 S( B) n5 C+ q3 C% h
DeleteKey(keyname,sizeof(luVOID),Matrix,DelMatrix,1); //将矩阵对象放回缓冲区6 g3 P* D; o# [9 c
return NULL;
& H3 P& @4 ^0 s( ~ I9 p/ c4 b
}
0 X\\" O9 Z( C$ x/ g
delete[] pMatrix->Array;5 e8 }: @! Q. M! |& n
pMatrix->Array=pa;/ ^4 h3 R8 P! E$ R5 n( j
}* E f3 o; _7 h3 n6 L
}
& p4 m, ~1 _% d9 B* _
else
+ p\\" g9 v8 w$ k6 z* S8 K l
{
, k: Y# h: H( s& x2 P9 c# Y
pMatrix=new myMatrix; //创建矩阵对象, p2 \3 D( H! [: u
if(!pMatrix) return NULL;- s, g: r$ v# g2 O8 I! m' \9 S+ k
pMatrix->Array=new double[k];
9 R7 V9 B5 j' q. e7 W
if(!pMatrix->Array)4 B# E. }1 |( z
{: W1 o& e4 T& J! \! d
delete pMatrix;
; c\\" `5 G; @! @! d0 T( m! g
return NULL;0 |) I& r+ h4 X8 M% f$ W1 u
}
2 F* D% N7 u' b/ j! d9 f$ c
if(InsertKey((char *)&pMatrix,-1,Matrix,pMatrix,DelMatrix,NULL,0,NowKey)) //将矩阵对象注册到Lu7 F7 C7 B' ]) d8 X
{
, ~( N7 b( A$ g- c. R# m4 C7 F: `
delete pMatrix;( f7 l; V& `/ k- ~( d( S. ]
return NULL;2 D6 p5 }3 a* `8 M5 [
}3 n/ N) Q$ S\\" g/ P. d
}
\\" ?\\" w, F' j, H0 m& o3 B
pMatrix->ArrayLen=k; pMatrix->Dim[0]=m; pMatrix->Dim[1]=n;
& A$ f% B; n: Z& h' ^
return pMatrix;, n z- P u0 F5 R- k: I8 p
}
p' T' O& c; N
LuData _stdcall OpMatrix(luINT mm,LuData *xx,void *hFor,int theOperator) //运算符重载函数，用于LockKey函数5 P) O: u\\" N+ Z+ o
{
& m. m3 ?& c; E! { o
LuData a;/ ~+ a* }) X$ I) s8 G
myMatrix *pMatrix1,*pMatrix2,*pMatrix3;
+ f9 S) z% l6 Y3 f0 a+ ]. e# T' t; {
luVOID i,j,k,m,n,u,v;: |- b. j+ a& N1 f& q. c
double *pa,*pb,*pc;3 U# N1 i& K9 x/ B9 t
luMessage pMessage;5 {- m; M# r2 z' b j2 \
wchar_t wchNum[32];0 w7 k\\" E) S3 L
char chNum[32];\\" r- Y1 U3 H5 s% }# ], t
a.BType=luStaData_nil; a.VType=luStaData_nil; a.x=0;9 o; L+ H& [: T- e8 s5 `
switch(theOperator); u( b\\" f8 }3 p- d' {& n: T
{# |6 \9 l0 @/ f
case 2: //重载运算符*7 b# x- G/ d F% L/ v, ~3 S
pMatrix1=(myMatrix *)SearchKey((char *)&(xx->x),sizeof(luVOID),Matrix);
* v* w0 m, b7 a: J; ~
pMatrix2=(myMatrix *)SearchKey((char *)&((xx+1)->x),sizeof(luVOID),Matrix);
; M4 v5 [, y% i: @
if(!pMatrix1 || !pMatrix2) break; //对象句柄无效，不是矩阵* I0 r# ~5 w9 D) {; O
if(pMatrix1->Dim[1]!=pMatrix2->Dim[0]) break; //维数不匹配4 \# b+ l1 t. ^' Y) `& ^
pMatrix3=NewMatrix(pMatrix1->Dim[0],pMatrix2->Dim[1]); //生成新矩阵1 V: m- T# x0 A\\" {$ V
if(!pMatrix3) break;
1 W5 S' [6 G# C# K
pa=pMatrix1->Array; pb=pMatrix2->Array; pc=pMatrix3->Array; H8 E# g, M% o) L9 U( C/ k w
m=pMatrix1->Dim[0]; n=pMatrix1->Dim[1]; k=pMatrix2->Dim[1];
8 O8 e. k7 t/ N' _; p, C\\" F1 R
for(i=0; i<m; i++) //矩阵乘; D8 u5 J/ _# x: m6 s; O8 x\\" w- b
{$ O) D. \% J5 B! o
for(j=0; j<k; j++)' z\\" X7 _6 ^( J$ w9 j
{/ {$ f! y( F% ^/ D/ \2 @& G3 |
u=i*k+j; pc[u]=0.0;3 C4 J/ ^. {- ~; T
for (v=0; v<n; v++)* m0 }\\" B8 g. b1 i, g
{
& ?2 N) c% p. r, s& F0 W+ d% B- e
pc[u]=pc[u]+pa[i*n+v]*pb[v*k+j];- @. }% s/ `9 ]; Z% L2 x* k. {* P
}
* i1 J, d1 y' _5 l$ t6 G
}
3 |5 x; I; @- n+ g3 F
}
% p/ d& @- l7 w* `2 O$ b0 b4 e
FunReObj(hFor); //告诉Lu，返回一个动态对象$ p5 U! Y8 b- N1 M
a.BType=Matrix; a.VType=Matrix; a.x=0; *(luVOID *)&(a.x)=(luVOID)pMatrix3;
- @! c/ _ M# j7 q
break;2 x\\" P5 B7 m+ }6 H9 H7 A/ Y5 J
case 25: //重载运算符.*
3 I) f3 a M) r4 z5 X, M
pMatrix1=(myMatrix *)SearchKey((char *)&(xx->x),sizeof(luVOID),Matrix);
$ g\\" u( g* a0 Q @! j- E6 ?
pMatrix2=(myMatrix *)SearchKey((char *)&((xx+1)->x),sizeof(luVOID),Matrix);
p- f# [* `+ |
if(!pMatrix1 || !pMatrix2) break; //对象句柄无效，不是矩阵- F\\" L! F8 m/ f1 O! O, d' i
if(pMatrix1->Dim[0]!=pMatrix2->Dim[0] || pMatrix1->Dim[1]!=pMatrix2->Dim[1]) break; //维数不相同
* q( C- o$ Z, q8 R8 c. F' D
pMatrix3=NewMatrix(pMatrix1->Dim[0],pMatrix1->Dim[1]); //生成新矩阵
% C4 @/ l e\\" [* N2 @
if(!pMatrix3) break;
( }3 D V/ L, u8 E
for(i=0;i<pMatrix1->ArrayLen;i++) pMatrix3->Array[i]=pMatrix1->Array[i]*pMatrix2->Array[i]; //矩阵点乘
FunReObj(hFor); //告诉Lu，返回一个动态对象
\\" f% ^8 n\\" V% K9 L
a.BType=Matrix; a.VType=Matrix; a.x=0; *(luVOID *)&(a.x)=(luVOID)pMatrix3;
6 l+ Z h5 Z P5 M' S- ^
break;/ O( \+ C- ?% k$ x( t6 c
case 46: //重载函数new; g T4 W0 W2 M8 {6 w1 N
if(mm<2) break;+ F2 n s( O# X5 C1 N9 g$ j0 E7 y
if((xx+1)->x<1 || (xx+2)->x<1 || (xx+1)->BType!=luStaData_int64 || (xx+2)->BType!=luStaData_int64) break;
1 }\\" T! m# H& @
pMatrix3=NewMatrix((luVOID)(xx+1)->x,(luVOID)(xx+2)->x);//生成新矩阵
/ l- S5 R- T& a! [
if(!pMatrix3) break;
* }0 n8 F+ s5 M7 O+ m# v d
for(j=0,i=3;i<=mm;i++,j++) //赋初值& y3 p' E\\" ~% Q5 U6 s, |5 D# G/ R
{
: `! A7 A/ Q9 u\\" _$ ~1 [0 f1 n
if(j>=pMatrix3->ArrayLen) break;6 g2 f2 n W; Y0 g2 n; w) @; n
if((xx+i)->BType!=luStaData_double) break; //只接受实数参数4 P9 s( v! X6 F' F; X$ c; T\\" h# p
pMatrix3->Array[j]=*(double *)&((xx+i)->x);
9 E9 _# S1 I2 E- `$ e# C2 |# A
}
8 w! `$ _5 Q* z2 r\\" w: D
FunReObj(hFor); //告诉Lu，返回一个动态对象
7 l6 @) j/ b0 L! p3 G Y
a.BType=Matrix; a.VType=Matrix; a.x=0; *(luVOID *)&(a.x)=(luVOID)pMatrix3;6 z, O X N# M# W! \' ]
break;
$ m7 Q( p% R7 K1 }
case 49: //重载函数o8 Y) [# D/ W/ l8 z
pMessage=(luMessage)SearchKey("\0\0\0\0",sizeof(luVOID),luPubKey_User);9 ^4 w\\" B; b, h- @
if(!pMessage) break;
( ?! v+ }6 n6 ^7 ]
pMatrix1=(myMatrix *)SearchKey((char *)&(xx->x),sizeof(luVOID),Matrix);
, t$ u3 R8 _7 r8 k7 |
if(!pMatrix1) break; //对象句柄无效，不是矩阵
6 Z1 z0 Z! p; x$ a
pa=pMatrix1->Array;
\\" u/ M2 j U) n' ^- Y4 u K
m=pMatrix1->Dim[0]; n=pMatrix1->Dim[1]; k=0;
' T8 v9 u2 P& h9 Q) T5 S
for(i=0; i<m; i++) //输出矩阵8 J& X; C6 P. ~9 z7 Y
{
' J/ \\\" w# u+ @ i& x0 f
pMessage(L"\r\n"); k+=2;
. y R2 x/ T: R- m
for(j=0; j<n; j++)
: ~& l! W5 I0 p! q% s8 h/ e
{ B1 C5 g3 H5 u6 {) j
_gcvt_s(chNum,pa[i*n+j],16);5 s' X' C. A2 U( x1 f
for(u=0;chNum[u];u++) {wchNum[u]=chNum[u]; k++;}) S' O3 k5 v! v9 Q! l
wchNum[u]='\0';
9 `# w- u! o4 N& F9 O- H2 d7 v7 _+ H
pMessage(wchNum); pMessage(L" "); k+=2;& A$ T6 a$ p: T: }/ ~. e
}$ O$ z; G6 L; T% X, B7 v
} d5 c\\" L- _+ s
pMessage(L"\r\n"); k+=2;2 a5 S0 p! L. \$ t' g9 Y& S
a.BType=luStaData_int64; a.VType=luStaData_int64; a.x=k; //按函数o的要求，返回输出的字符总数$ k( m* u# @\\" p\\" X- e4 i
break; I% N( G m6 t) r( Q' T2 u
default:
2 }; E% A: J }$ G3 L6 ~& d
break;
/ G' ]. L! {' ?* k9 _
}# f: H1 s) \0 o2 t7 i
return a;, H- G, k3 H J# m' X+ A6 P
}' D. K1 c0 C6 Z# V; J1 r7 o' Y/ C6 @
void main(void)
* y% S, R* j' g# f1 S+ K7 {) A
{) M0 i6 C* K+ q# {\\" c; I
void *hFor; //表达式句柄
; r& {/ g* c* ]3 S7 F' Q) z9 F
luINT nPara; //存放表达式的自变量个数' y/ i) S- I, G8 Y% g
LuData *pPara; //存放输入自变量的数组指针
8 f+ L0 t# p' T* n/ K8 {: y* g) Z
luINT ErrBegin,ErrEnd; //表达式编译出错的初始位置和结束位置
\\" n$ o) ~\\" W\\" l8 n
int ErrCode; //错误代码. F: D2 @: b4 |4 v! Z: s
void *v;: p( r# n! w% q# C N1 f\\" g6 C
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 O6 U\\" r5 |$ J+ g9 |; b6 L
//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.]}";//字符串表达式，矩阵点乘
( [' |( J6 f. i0 }, Z& Z( a! s; P7 b
LuData Val;$ ]) Z' f; [) F3 G; w+ ^& k
if(!InitLu()) return; //初始化Lu7 W8 a& u1 ~/ M% F9 P
while(LockKey(Matrix,DelMatrix,OpMatrix)){Matrix--;} //锁定一个键，用于存储矩阵扩展类型
/ I5 z3 m, \$ K7 F
I- f. ]8 N/ e0 i7 |- f
Val.BType=luStaData_int64; Val.VType=luStaData_int64; Val.x=Matrix; //定义整数常量
8 j3 Q4 Y. M- Z' B3 H8 V( D\\" ?7 {
SetConst(L"matrix",&Val); //设置整数常量
) C6 O# @& n8 e2 P
InsertKey("\0\0\0\0",4,luPubKey_User,LuMessage,NULL,NULL,1,v); //使Lu运行时可输出函数信息
8 ~) N, I% v, Q) J: }
wcout.imbue(locale("chs")); //设置输出的locale为中文# l; h. E# O V. z) L7 p8 i; K: {
% [$ g& H R; C3 ^# Z
ErrCode=LuCom(ForStr,0,0,0,hFor,nPara,pPara,ErrBegin,ErrEnd); //编译表达式
1 n1 c1 g! W+ g' a% a$ K7 p* P
if(ErrCode)9 z\\" S+ Z9 v4 _7 W
{8 B/ P% ^. B2 F6 o- [) `% p
wcout<<L"表达式有错误！错误代码："<<ErrCode<<endl;! B2 }; p5 q2 N/ L' B3 d2 F& O8 P4 G
}
+ b+ A6 p Y% i3 X
else
; U) t1 {, s; O: c. a
{
% }) ^: _5 X5 {0 I4 ~ ^
LuCal(hFor,pPara); //计算表达式的值0 h% n3 X& Q4 {6 S* O# ?1 w
}
( {% P$ Y$ B& q8 V' h' C
LockKey(Matrix,NULL,OpMatrix);//解锁键Matrix，本例中，该函数可以不用! ]( L* ?5 x- t+ l8 [
FreeLu(); //释放Lu
& g' c( N6 j4 m' m/ W N5 f; }
}

#include <windows.h> 
1 X. v5 l  h' D6 }( X, ?
#include <iostream>2 L) o9 _; |- p

#include <math.h># g8 k; I& e) c7 Z' M

#include "lu32.h"3 Y9 \* g5 h; _/ o* [! {( O

#pragma comment( lib, "lu32.lib" )/ [4 x: z/ Z& Q- O3 S3 z2 I

using namespace std;, t! V& ~8 S, @% O/ L0 W! Z

//自定义矩阵1 p: ~; a0 P: c2 z! l

class myMatrix! x/ S+ I) j) @* L4 u+ A4 G

{ 
: ]\\" S0 g( V: W
public:- B4 w: J\\" h  l! d& K  d% w

double *Array;        //数据缓冲区& E5 o7 L& A. \) H6 q: F3 v

luVOID ArrayLen;        //数据缓冲区长度! P% x/ F0 D& f' B

luVOID Dim[2];        //矩阵维数& E\\" {  H7 y1 f/ y( M) f4 _2 T

myMatrix(){Array=NULL; ArrayLen=0; Dim[0]=0; Dim[1]=0;}4 N# C) c$ @4 x9 u

~myMatrix() 
& S9 t' a8 q, _7 Y  K8 I
        { 
! _; }! b- ?' [2 s1 F
                if(Array) delete[] Array; 
) t\\" f2 W8 [# j) `3 g$ c
        } 
, o3 C9 Q; d& C  Q) R
};+ y1 F+ p6 M8 }  P) v9 Q# i5 c

luKEY Matrix=-1000;        //标识矩阵类型，最终的Matrix由LockKey决定$ S\\" [$ _  t% j' g0 S

void _stdcall LuMessage(wchar_t *pch)//输出动态库信息，该函数注册到Lu，由Lu二级函数调用 / R+ H) h& t* f9 v

{0 G$ S- _. r' Y# z% a

wcout<<pch; 
  j: F# h1 I1 f\\" X# C$ f
}\\" j* {' M* p% \6 ?2 `\\" H' M& m

void _stdcall DelMatrix(void *me)        //用于LockKey函数及InsertKey函数，使Lu能自动销毁myMatrix对象- V. x8 a5 b( x; T/ N/ c0 K1 ~

{ 
9 V, J$ k7 V* G$ y
        delete (myMatrix *)me;' t2 a& Q) W* Z4 V& S( C

}7 H/ w7 A6 X. h; V8 I

myMatrix * _stdcall NewMatrix(luVOID m,luVOID n)        //生成一个myMatrix对象 
, w1 U/ _, Y& X, H' g4 C1 ]
{ 
9 s# a& n9 \$ \
        myMatrix *pMatrix; 
6 s9 k: n( Q' v( }$ Z2 f4 }  K\\" |
        luVOID k; 
; u. m# m5 E6 b& s
        double *pa;\\" C  j* A- [& O9 q) F

char keyname[sizeof(luVOID)];7 h# c. \& r4 Y2 E8 i

void *NowKey; 
* r) N' ?$ R9 B. I/ f
        k=m*n; 
5 e, p& A- V# n8 Z5 j
        pMatrix=(myMatrix *)GetBufObj(Matrix,keyname);//先尝试从缓冲区中获取一个矩阵对象8 L\\" v- K. X3 G! {' v  ~( \

if(pMatrix)0 o' i( g9 ]: m5 g, Z  o0 |- M

{ 
+ u5 p3 e0 m4 m2 o+ ~  l( M' q
                if(pMatrix->ArrayLen!=k)        //重置矩阵的大小 
% Y' H8 h% w, Y8 L6 f: Q
                { 
' A5 D$ F0 B* k& Y; |
                        pa=new double[k]; 
+ U$ l  K1 H) F, v* ?* Z
                        if(!pa)/ S# U+ ^1 }+ m0 U\\" ]

{ 
8 S( B) n5 C+ q3 C% h
                                DeleteKey(keyname,sizeof(luVOID),Matrix,DelMatrix,1);        //将矩阵对象放回缓冲区6 g3 P* D; o# [9 c

return NULL; 
& H3 P& @4 ^0 s( ~  I9 p/ c4 b
                        } 
0 X\\" O9 Z( C$ x/ g
                        delete[] pMatrix->Array;5 e8 }: @! Q. M! |& n

pMatrix->Array=pa;/ ^4 h3 R8 P! E$ R5 n( j

}* E  f3 o; _7 h3 n6 L

} 
& p4 m, ~1 _% d9 B* _
        else 
+ p\\" g9 v8 w$ k6 z* S8 K  l
        { 
, k: Y# h: H( s& x2 P9 c# Y
                pMatrix=new myMatrix;        //创建矩阵对象, p2 \3 D( H! [: u

if(!pMatrix) return NULL;- s, g: r$ v# g2 O8 I! m' \9 S+ k

pMatrix->Array=new double[k]; 
9 R7 V9 B5 j' q. e7 W
                if(!pMatrix->Array)4 B# E. }1 |( z

{: W1 o& e4 T& J! \! d

delete pMatrix; 
; c\\" `5 G; @! @! d0 T( m! g
                        return NULL;0 |) I& r+ h4 X8 M% f$ W1 u

} 
2 F* D% N7 u' b/ j! d9 f$ c
                if(InsertKey((char *)&pMatrix,-1,Matrix,pMatrix,DelMatrix,NULL,0,NowKey))        //将矩阵对象注册到Lu7 F7 C7 B' ]) d8 X

{ 
, ~( N7 b( A$ g- c. R# m4 C7 F: `
                        delete pMatrix;( f7 l; V& `/ k- ~( d( S. ]

return NULL;2 D6 p5 }3 a* `8 M5 [

}3 n/ N) Q$ S\\" g/ P. d

} 
\\" ?\\" w, F' j, H0 m& o3 B
        pMatrix->ArrayLen=k; pMatrix->Dim[0]=m; pMatrix->Dim[1]=n; 
& A$ f% B; n: Z& h' ^
        return pMatrix;, n  z- P  u0 F5 R- k: I8 p

} 
  p' T' O& c; N
LuData _stdcall OpMatrix(luINT mm,LuData *xx,void *hFor,int theOperator)        //运算符重载函数，用于LockKey函数5 P) O: u\\" N+ Z+ o

{ 
& m. m3 ?& c; E! {  o
        LuData a;/ ~+ a* }) X$ I) s8 G

myMatrix *pMatrix1,*pMatrix2,*pMatrix3; 
+ f9 S) z% l6 Y3 f0 a+ ]. e# T' t; {
        luVOID i,j,k,m,n,u,v;: |- b. j+ a& N1 f& q. c

double *pa,*pb,*pc;3 U# N1 i& K9 x/ B9 t

luMessage pMessage;5 {- m; M# r2 z' b  j2 \

wchar_t wchNum[32];0 w7 k\\" E) S3 L

char chNum[32];\\" r- Y1 U3 H5 s% }# ], t

a.BType=luStaData_nil; a.VType=luStaData_nil; a.x=0;9 o; L+ H& [: T- e8 s5 `

switch(theOperator); u( b\\" f8 }3 p- d' {& n: T

{# |6 \9 l0 @/ f

case 2:        //重载运算符*7 b# x- G/ d  F% L/ v, ~3 S

pMatrix1=(myMatrix *)SearchKey((char *)&(xx->x),sizeof(luVOID),Matrix); 
* v* w0 m, b7 a: J; ~
                pMatrix2=(myMatrix *)SearchKey((char *)&((xx+1)->x),sizeof(luVOID),Matrix); 
; M4 v5 [, y% i: @
                if(!pMatrix1 || !pMatrix2) break;        //对象句柄无效，不是矩阵* I0 r# ~5 w9 D) {; O

if(pMatrix1->Dim[1]!=pMatrix2->Dim[0]) break;        //维数不匹配4 \# b+ l1 t. ^' Y) `& ^

pMatrix3=NewMatrix(pMatrix1->Dim[0],pMatrix2->Dim[1]);        //生成新矩阵1 V: m- T# x0 A\\" {$ V

if(!pMatrix3) break; 
1 W5 S' [6 G# C# K
                pa=pMatrix1->Array; pb=pMatrix2->Array; pc=pMatrix3->Array;  H8 E# g, M% o) L9 U( C/ k  w

m=pMatrix1->Dim[0]; n=pMatrix1->Dim[1]; k=pMatrix2->Dim[1]; 
8 O8 e. k7 t/ N' _; p, C\\" F1 R
                for(i=0; i<m; i++)        //矩阵乘; D8 u5 J/ _# x: m6 s; O8 x\\" w- b

{$ O) D. \% J5 B! o

for(j=0; j<k; j++)' z\\" X7 _6 ^( J$ w9 j

{/ {$ f! y( F% ^/ D/ \2 @& G3 |

u=i*k+j; pc[u]=0.0;3 C4 J/ ^. {- ~; T

for (v=0; v<n; v++)* m0 }\\" B8 g. b1 i, g

{ 
& ?2 N) c% p. r, s& F0 W+ d% B- e
                                        pc[u]=pc[u]+pa[i*n+v]*pb[v*k+j];- @. }% s/ `9 ]; Z% L2 x* k. {* P

} 
* i1 J, d1 y' _5 l$ t6 G
                        } 
3 |5 x; I; @- n+ g3 F
                } 
% p/ d& @- l7 w* `2 O$ b0 b4 e
                FunReObj(hFor);        //告诉Lu，返回一个动态对象$ p5 U! Y8 b- N1 M

a.BType=Matrix; a.VType=Matrix; a.x=0; *(luVOID *)&(a.x)=(luVOID)pMatrix3; 
- @! c/ _  M# j7 q
                break;2 x\\" P5 B7 m+ }6 H9 H7 A/ Y5 J

case 25:        //重载运算符.* 
3 I) f3 a  M) r4 z5 X, M
                pMatrix1=(myMatrix *)SearchKey((char *)&(xx->x),sizeof(luVOID),Matrix); 
$ g\\" u( g* a0 Q  @! j- E6 ?
                pMatrix2=(myMatrix *)SearchKey((char *)&((xx+1)->x),sizeof(luVOID),Matrix); 
  p- f# [* `+ |
                if(!pMatrix1 || !pMatrix2) break;        //对象句柄无效，不是矩阵- F\\" L! F8 m/ f1 O! O, d' i

if(pMatrix1->Dim[0]!=pMatrix2->Dim[0] || pMatrix1->Dim[1]!=pMatrix2->Dim[1]) break;        //维数不相同 
* q( C- o$ Z, q8 R8 c. F' D
                pMatrix3=NewMatrix(pMatrix1->Dim[0],pMatrix1->Dim[1]);        //生成新矩阵 
% C4 @/ l  e\\" [* N2 @
                if(!pMatrix3) break; 
( }3 D  V/ L, u8 E
                for(i=0;i<pMatrix1->ArrayLen;i++) pMatrix3->Array[i]=pMatrix1->Array[i]*pMatrix2->Array[i];        //矩阵点乘 
1 J7 h- X% R1 Z% @* L! a+ C9 E* O\\" d\\" N
                FunReObj(hFor);        //告诉Lu，返回一个动态对象 
\\" f% ^8 n\\" V% K9 L
                a.BType=Matrix; a.VType=Matrix; a.x=0; *(luVOID *)&(a.x)=(luVOID)pMatrix3; 
6 l+ Z  h5 Z  P5 M' S- ^
                break;/ O( \+ C- ?% k$ x( t6 c

case 46:        //重载函数new; g  T4 W0 W2 M8 {6 w1 N

if(mm<2) break;+ F2 n  s( O# X5 C1 N9 g$ j0 E7 y

if((xx+1)->x<1 || (xx+2)->x<1 || (xx+1)->BType!=luStaData_int64 || (xx+2)->BType!=luStaData_int64) break; 
1 }\\" T! m# H& @
                pMatrix3=NewMatrix((luVOID)(xx+1)->x,(luVOID)(xx+2)->x);//生成新矩阵 
/ l- S5 R- T& a! [
                if(!pMatrix3) break; 
* }0 n8 F+ s5 M7 O+ m# v  d
                for(j=0,i=3;i<=mm;i++,j++)        //赋初值& y3 p' E\\" ~% Q5 U6 s, |5 D# G/ R

{ 
: `! A7 A/ Q9 u\\" _$ ~1 [0 f1 n
                        if(j>=pMatrix3->ArrayLen) break;6 g2 f2 n  W; Y0 g2 n; w) @; n

if((xx+i)->BType!=luStaData_double) break;        //只接受实数参数4 P9 s( v! X6 F' F; X$ c; T\\" h# p

pMatrix3->Array[j]=*(double *)&((xx+i)->x); 
9 E9 _# S1 I2 E- `$ e# C2 |# A
                } 
8 w! `$ _5 Q* z2 r\\" w: D
                FunReObj(hFor);        //告诉Lu，返回一个动态对象 
7 l6 @) j/ b0 L! p3 G  Y
                a.BType=Matrix; a.VType=Matrix; a.x=0; *(luVOID *)&(a.x)=(luVOID)pMatrix3;6 z, O  X  N# M# W! \' ]

break; 
$ m7 Q( p% R7 K1 }
        case 49:        //重载函数o8 Y) [# D/ W/ l8 z

pMessage=(luMessage)SearchKey("\0\0\0\0",sizeof(luVOID),luPubKey_User);9 ^4 w\\" B; b, h- @

if(!pMessage) break; 
( ?! v+ }6 n6 ^7 ]
                pMatrix1=(myMatrix *)SearchKey((char *)&(xx->x),sizeof(luVOID),Matrix); 
, t$ u3 R8 _7 r8 k7 |
                if(!pMatrix1) break;        //对象句柄无效，不是矩阵 
6 Z1 z0 Z! p; x$ a
                pa=pMatrix1->Array; 
\\" u/ M2 j  U) n' ^- Y4 u  K
                m=pMatrix1->Dim[0]; n=pMatrix1->Dim[1]; k=0; 
' T8 v9 u2 P& h9 Q) T5 S
                for(i=0; i<m; i++)        //输出矩阵8 J& X; C6 P. ~9 z7 Y

{ 
' J/ \\\" w# u+ @  i& x0 f
                        pMessage(L"\r\n"); k+=2; 
. y  R2 x/ T: R- m
                        for(j=0; j<n; j++) 
: ~& l! W5 I0 p! q% s8 h/ e
                        {  B1 C5 g3 H5 u6 {) j

_gcvt_s(chNum,pa[i*n+j],16);5 s' X' C. A2 U( x1 f

for(u=0;chNum[u];u++) {wchNum[u]=chNum[u]; k++;}) S' O3 k5 v! v9 Q! l

wchNum[u]='\0'; 
9 `# w- u! o4 N& F9 O- H2 d7 v7 _+ H
                                pMessage(wchNum); pMessage(L"  "); k+=2;& A$ T6 a$ p: T: }/ ~. e

}$ O$ z; G6 L; T% X, B7 v

}  d5 c\\" L- _+ s

pMessage(L"\r\n"); k+=2;2 a5 S0 p! L. \$ t' g9 Y& S

a.BType=luStaData_int64; a.VType=luStaData_int64; a.x=k;        //按函数o的要求，返回输出的字符总数$ k( m* u# @\\" p\\" X- e4 i

break;  I% N( G  m6 t) r( Q' T2 u

default: 
2 }; E% A: J  }$ G3 L6 ~& d
                break; 
/ G' ]. L! {' ?* k9 _
        }# f: H1 s) \0 o2 t7 i

return a;, H- G, k3 H  J# m' X+ A6 P

}' D. K1 c0 C6 Z# V; J1 r7 o' Y/ C6 @

void main(void) 
* y% S, R* j' g# f1 S+ K7 {) A
{) M0 i6 C* K+ q# {\\" c; I

void *hFor;                //表达式句柄 
; r& {/ g* c* ]3 S7 F' Q) z9 F
        luINT nPara;                //存放表达式的自变量个数' y/ i) S- I, G8 Y% g

LuData *pPara;                //存放输入自变量的数组指针 
8 f+ L0 t# p' T* n/ K8 {: y* g) Z
        luINT ErrBegin,ErrEnd;        //表达式编译出错的初始位置和结束位置 
\\" n$ o) ~\\" W\\" l8 n
        int ErrCode;                //错误代码. F: D2 @: b4 |4 v! Z: s

void *v;: p( r# n! w% q# C  N1 f\\" g6 C

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 O6 U\\" r5 |$ J+ g9 |; b6 L
        //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.]}";//字符串表达式，矩阵点乘 
( [' |( J6 f. i0 }, Z& Z( a! s; P7 b
        LuData Val;$ ]) Z' f; [) F3 G; w+ ^& k

if(!InitLu()) return;        //初始化Lu7 W8 a& u1 ~/ M% F9 P

while(LockKey(Matrix,DelMatrix,OpMatrix)){Matrix--;}        //锁定一个键，用于存储矩阵扩展类型 
/ I5 z3 m, \$ K7 F
  I- f. ]8 N/ e0 i7 |- f

Val.BType=luStaData_int64; Val.VType=luStaData_int64; Val.x=Matrix;        //定义整数常量 
8 j3 Q4 Y. M- Z' B3 H8 V( D\\" ?7 {
        SetConst(L"matrix",&Val);        //设置整数常量 
) C6 O# @& n8 e2 P
        InsertKey("\0\0\0\0",4,luPubKey_User,LuMessage,NULL,NULL,1,v); //使Lu运行时可输出函数信息 
8 ~) N, I% v, Q) J: }
        wcout.imbue(locale("chs"));        //设置输出的locale为中文# l; h. E# O  V. z) L7 p8 i; K: {

% [$ g& H  R; C3 ^# Z

ErrCode=LuCom(ForStr,0,0,0,hFor,nPara,pPara,ErrBegin,ErrEnd); //编译表达式 
1 n1 c1 g! W+ g' a% a$ K7 p* P
        if(ErrCode)9 z\\" S+ Z9 v4 _7 W

{8 B/ P% ^. B2 F6 o- [) `% p

wcout<<L"表达式有错误！错误代码："<<ErrCode<<endl;! B2 }; p5 q2 N/ L' B3 d2 F& O8 P4 G

} 
+ b+ A6 p  Y% i3 X
        else 
; U) t1 {, s; O: c. a
        { 
% }) ^: _5 X5 {0 I4 ~  ^
                LuCal(hFor,pPara);        //计算表达式的值0 h% n3 X& Q4 {6 S* O# ?1 w

} 
( {% P$ Y$ B& q8 V' h' C
        LockKey(Matrix,NULL,OpMatrix);//解锁键Matrix，本例中，该函数可以不用! ]( L* ?5 x- t+ l8 [

FreeLu();                        //释放Lu 
& g' c( N6 j4 m' m/ W  N5 f; }
}

习题：

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

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

main(:a,b,c,d,t,i)=
# f+ t W0 _9 @* ^3 r% \
a=new[matrix,2,2: 1.,2.,2.,1.],
6 k% P( w( y5 M2 q
b=new[matrix,2,2: 2.,1.,1.,2.],- I2 X\" h' l! x
c=new[matrix,2,2: 2/3.,-1/3.,-1/3.,2/3.],. a0 p2 W& v. T. l- c
t=clock(),
% s) n: L& r0 o9 o/ i
d=a*b, i=0, while{i<1000000, d=d*c*b, i++},) W3 o6 l: g2 `9 C( ]9 X
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\"}";//字符串表达式

复制代码

结果：