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

查看: 8679|回复: 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> {9 d1 H9 r5 H. H% I u
#include <iostream>
: z' ?4 T: k& _! e/ {\\" m. ^! Q( O' \
#include <math.h>3 e8 C3 B2 r; G$ D1 d& e' w e3 d/ C
#include "lu32.h"
8 A- S% R! G\\" M- t$ E\\" Y
#pragma comment( lib, "lu32.lib" )5 }3 g7 P+ m3 A# o( F( O2 P
using namespace std;) }\\" \, i5 N0 }& Y+ b
//自定义矩阵+ I& ^- R8 O i8 b6 L2 c1 L1 Q
class myMatrix
% `6 T$ r, s: |3 d\\" [/ Z
{
c: q\\" d- m. _* k+ ~; X8 l1 l
public:/ ]\\" a* Q& f+ d2 D
double *Array; //数据缓冲区
+ Q2 A N/ v' ~/ |; l
luVOID ArrayLen; //数据缓冲区长度
! ^, |0 S5 l- e2 v
luVOID Dim[2]; //矩阵维数8 E' r, W4 o# N! K. b3 G
myMatrix(){Array=NULL; ArrayLen=0; Dim[0]=0; Dim[1]=0;}( T. }/ o( q; A
~myMatrix()
1 f: H R7 l {9 R, e7 i
{
7 R\\" N- n b E( z% i
if(Array) delete[] Array;
@! q\\" R& u7 M; x8 G) O1 _
} ^1 N1 S1 @. H6 t
};
: ]2 M+ I4 S2 p1 @7 n3 }- O$ P
luKEY Matrix=-1000; //标识矩阵类型，最终的Matrix由LockKey决定
\\" w* W7 ?; S3 t6 S' \+ D2 i, a
void _stdcall LuMessage(wchar_t *pch)//输出动态库信息，该函数注册到Lu，由Lu二级函数调用
8 c1 `% l9 I& r: j/ J! k: N\\" V5 _
{
; U% K4 U B8 T2 g1 Y4 o1 H: S U
wcout<<pch;( q6 q! g% L; d8 C( F- H
}0 O# C1 d: G. D3 S# t9 V; j
void _stdcall DelMatrix(void *me) //用于LockKey函数及InsertKey函数，使Lu能自动销毁myMatrix对象
5 l3 \3 F/ b1 T% ?
{
& m\\" C- k6 K4 G: O; Y
delete (myMatrix *)me;
2 `- r# W& b# {! Z$ o% [/ T! |& T; B
}) ?+ n9 U, C: h1 z! j6 \3 p! k
myMatrix * _stdcall NewMatrix(luVOID m,luVOID n) //生成一个myMatrix对象( p, N; P$ w% s3 _' \; V, H! G* ]8 e
{
- k( P3 |% w, y! N8 x( a
myMatrix *pMatrix;5 _- g& ]) @$ B: @- N* H- v) |
luVOID k;! a* i$ \) u. q: ~6 B1 r8 D8 c
double *pa;7 s, I+ S1 c' _\\" I( a; k
char keyname[sizeof(luVOID)];/ X8 y1 {$ T9 F% R: Z, @6 X
void *NowKey;
: ]* Z6 O\\" q; r7 w( X; _/ ?, V
k=m*n;
1 B6 n( U3 Z/ ^\\" F# i5 ^
pMatrix=(myMatrix *)GetBufObj(Matrix,keyname);//先尝试从缓冲区中获取一个矩阵对象
. o+ v& _- A3 n5 j2 o- d
if(pMatrix)
6 H3 Z; ]2 g8 j. q
{* U, w; o% [\\" R' [\\" a
if(pMatrix->ArrayLen!=k) //重置矩阵的大小' }# t% [5 i8 M5 ?9 Q% q
{
5 C$ N: o+ Y' J+ f a5 S
pa=new double[k];: o( i6 r1 r3 c- h$ G/ t, f
if(!pa)* {) D1 |$ D4 b5 W7 Z! f2 q3 \
{
% v V7 G9 B. q
DeleteKey(keyname,sizeof(luVOID),Matrix,DelMatrix,1); //将矩阵对象放回缓冲区
# A- u+ b2 x% o: m, E' V9 `, k6 }\\" O
return NULL;
6 `1 E& g6 |( s
}
5 ]* R' _5 K4 ~1 Y
delete[] pMatrix->Array;% B1 n- X' \& P; L9 {
pMatrix->Array=pa;
1 y( A: V; X$ {4 B$ s
}% k+ g1 |7 V5 a9 P
}8 G0 {! m5 b% F' O+ y r4 U' A' ^2 g2 y
else, _4 W4 [; V6 g! N$ F& d
{
v2 L& o+ ^$ F2 Q Q& F6 |( V
pMatrix=new myMatrix; //创建矩阵对象4 N$ U: q' O\\" Z* G0 g$ S
if(!pMatrix) return NULL;
9 g z. N0 d3 b: l# y7 u& h
pMatrix->Array=new double[k];: W; P. L; {7 |8 X- }+ n& f
if(!pMatrix->Array)
, ]! N e3 ?% o8 f5 _
{
) @; J- Q0 O2 t' h
delete pMatrix;. J/ p5 k+ O) u; K! w) E% O
return NULL;- D- w) Q- X$ f1 g/ T6 j
}. U3 {! D$ x \, {
if(InsertKey((char *)&pMatrix,-1,Matrix,pMatrix,DelMatrix,NULL,0,NowKey)) //将矩阵对象注册到Lu
- q4 \# u+ ?6 _0 |# n8 k# v
{5 A( L1 l1 D. C9 c! N6 C
delete pMatrix;
' h$ X2 I U# |8 G! t2 ~
return NULL;! L U; ^' T( S! m5 Y) ^+ B1 z
} M* f0 T9 _* p7 [9 m- Y
}% l7 |6 B7 \. r( l# ?
pMatrix->ArrayLen=k; pMatrix->Dim[0]=m; pMatrix->Dim[1]=n;
return pMatrix;
$ _ h1 z$ u! f+ ^# q# ^
}
( @* e\\" ~- G* ?
LuData _stdcall OpMatrix(luINT mm,LuData *xx,void *hFor,int theOperator) //运算符重载函数，用于LockKey函数
% Y* h$ w& f1 I3 I( @, J4 ]
{0 V3 A: q# x5 z
LuData a;
- M t9 _+ @4 C: D% y) G
myMatrix *pMatrix1,*pMatrix2,*pMatrix3;: Z& \% d$ M) A4 w7 S
luVOID i,j,k,m,n,u,v;1 }\\" g- c# t. P1 O! k
double *pa,*pb,*pc;9 ]3 V- J\\" I5 Y q
luMessage pMessage;6 Y& m) L* q8 K$ w. V
wchar_t wchNum[32];
# i: u7 C5 K; o0 _
char chNum[32];
9 J\\" U# p7 s& @1 ]8 v# ~0 r
a.BType=luStaData_nil; a.VType=luStaData_nil; a.x=0;# t- ^- W% X3 U9 S8 u+ p! Z
switch(theOperator)
+ K2 w8 M3 e: c2 N2 ~! U* Q
{1 Y2 p$ { s0 m. ^% ~1 H
case 2: //重载运算符*
6 q' j' h* N9 z `) u& H# b
pMatrix1=(myMatrix *)SearchKey((char *)&(xx->x),sizeof(luVOID),Matrix);
: o7 x. a: @* L* y$ F; g
pMatrix2=(myMatrix *)SearchKey((char *)&((xx+1)->x),sizeof(luVOID),Matrix);
* }- H( _2 v! m
if(!pMatrix1 || !pMatrix2) break; //对象句柄无效，不是矩阵
- m. e\\" ~! s6 C( w
if(pMatrix1->Dim[1]!=pMatrix2->Dim[0]) break; //维数不匹配/ T v\\" B! y. n' C t
pMatrix3=NewMatrix(pMatrix1->Dim[0],pMatrix2->Dim[1]); //生成新矩阵
\\" X/ W/ X& Q0 b( A, Q8 N9 c( W
if(!pMatrix3) break;! s# i; c\\" z2 x1 h3 U7 t
pa=pMatrix1->Array; pb=pMatrix2->Array; pc=pMatrix3->Array;: H1 ?0 H, v$ ?, s$ R6 b H
m=pMatrix1->Dim[0]; n=pMatrix1->Dim[1]; k=pMatrix2->Dim[1];- d; m3 e8 l2 @6 W6 B, \ R
for(i=0; i<m; i++) //矩阵乘
! r, a T# w* K
{( Y* b* _7 q: p- z* q$ ~9 |
for(j=0; j<k; j++)) K, |& f. }/ V( B8 \, Y/ k
{
: d+ d\\" H F4 o
u=i*k+j; pc[u]=0.0;- k# T. a6 @9 I- C3 \. [ ^
for (v=0; v<n; v++)- D- b: ^- M/ o1 A. x; w
{
+ Z! u* v% x6 L
pc[u]=pc[u]+pa[i*n+v]*pb[v*k+j];
! z1 Y/ h- K7 r9 Z
}
% J, x- x! p1 R6 w! M# N! M: N; ~4 l
}2 H( w1 D0 C c4 C# L K& E: R
}
2 A; v5 ?8 l+ s% ]
FunReObj(hFor); //告诉Lu，返回一个动态对象
0 Y# `' l0 x% O( u7 W
a.BType=Matrix; a.VType=Matrix; a.x=0; *(luVOID *)&(a.x)=(luVOID)pMatrix3;, S3 ` {% h3 v, m0 f
break;
6 u4 F f, W$ Q' v6 P
case 25: //重载运算符.*; u G @4 ~ I, K
pMatrix1=(myMatrix *)SearchKey((char *)&(xx->x),sizeof(luVOID),Matrix);1 w3 ~2 B& s2 o/ z0 D9 ]& n
pMatrix2=(myMatrix *)SearchKey((char *)&((xx+1)->x),sizeof(luVOID),Matrix);
& w1 [3 d) V. X( M/ S6 `
if(!pMatrix1 || !pMatrix2) break; //对象句柄无效，不是矩阵# t5 B3 o2 J+ R2 U2 e
if(pMatrix1->Dim[0]!=pMatrix2->Dim[0] || pMatrix1->Dim[1]!=pMatrix2->Dim[1]) break; //维数不相同& W( s2 @! c9 h/ n\\" M p( q
pMatrix3=NewMatrix(pMatrix1->Dim[0],pMatrix1->Dim[1]); //生成新矩阵( \3 ?$ t3 H! E( U2 Z4 O
if(!pMatrix3) break;
6 w9 |\\" r& U6 @, P
for(i=0;i<pMatrix1->ArrayLen;i++) pMatrix3->Array[i]=pMatrix1->Array[i]*pMatrix2->Array[i]; //矩阵点乘
% N, L' ?9 h# g+ ~5 I
FunReObj(hFor); //告诉Lu，返回一个动态对象. m2 C0 E! P8 e4 p- G) c6 y9 j
a.BType=Matrix; a.VType=Matrix; a.x=0; *(luVOID *)&(a.x)=(luVOID)pMatrix3;5 \# I/ K E/ U X3 Q# C
break; f) W' V3 l7 @\\" m! I! ~( ]/ H; w- O
case 46: //重载函数new
0 w9 \2 L, o6 p, H& R8 u- g
if(mm<2) break;
( L2 t: Y\\" ^& f! j\\" }! v
if((xx+1)->x<1 || (xx+2)->x<1 || (xx+1)->BType!=luStaData_int64 || (xx+2)->BType!=luStaData_int64) break;
0 D @! \( I+ g\\" n& X
pMatrix3=NewMatrix((luVOID)(xx+1)->x,(luVOID)(xx+2)->x);//生成新矩阵
7 N' a: z. | e3 F* o\\" T N
if(!pMatrix3) break;\\" l% ~\\" p0 Z1 \0 l( e' J% Q( W; G. N
for(j=0,i=3;i<=mm;i++,j++) //赋初值
& `# O+ N\\" u( R- Y5 W
{
4 U( v% e) E, A8 l9 G6 ]
if(j>=pMatrix3->ArrayLen) break;; ]% z/ w& ^& ]* `! l\\" L
if((xx+i)->BType!=luStaData_double) break; //只接受实数参数5 A, _' P4 S5 W) t; v7 J/ ?4 d( r2 Q8 S
pMatrix3->Array[j]=*(double *)&((xx+i)->x);
2 u4 P5 |( v/ M5 w; G2 t% T
}5 D, g: L* G8 _8 I) Z2 V
FunReObj(hFor); //告诉Lu，返回一个动态对象\\" }/ x% O' m% Y5 s: m' k# L
a.BType=Matrix; a.VType=Matrix; a.x=0; *(luVOID *)&(a.x)=(luVOID)pMatrix3;& K8 D O# @0 Z2 T/ W0 l5 D( r2 t
break;
7 F8 Y$ q* a: D- @1 H2 _* C
case 49: //重载函数o A# Y: F8 e6 q
pMessage=(luMessage)SearchKey("\0\0\0\0",sizeof(luVOID),luPubKey_User);
' l& M+ F5 ^: }3 P1 D) h
if(!pMessage) break;
& U9 @; }8 l$ N2 g# y2 c: d' ^6 N
pMatrix1=(myMatrix *)SearchKey((char *)&(xx->x),sizeof(luVOID),Matrix);
% n7 o3 ], l; }6 p6 k6 _: z ^
if(!pMatrix1) break; //对象句柄无效，不是矩阵
: k1 _7 L9 C& U+ j r6 ^
pa=pMatrix1->Array;% _4 v; i- U* l' t
m=pMatrix1->Dim[0]; n=pMatrix1->Dim[1]; k=0;
) R7 ]8 a! ^6 T\\" i7 V0 ]' {
for(i=0; i<m; i++) //输出矩阵\\" B, \ y: P$ V5 O5 Q
{! F8 R9 F5 G6 F5 Q1 r8 {
pMessage(L"\r\n"); k+=2;
9 p+ [# H1 _' c' v. M1 ^5 E
for(j=0; j<n; j++)
: p. ]' p7 ^4 J& z
{
+ m0 g0 {/ e- S1 [2 f& ?
_gcvt_s(chNum,pa[i*n+j],16);
9 ?2 C2 u\\" n1 W( t\\" u; e
for(u=0;chNum[u];u++) {wchNum[u]=chNum[u]; k++;}/ c1 \9 M0 S0 P' k1 G5 f3 [+ W5 K
wchNum[u]='\0';3 _. h0 X% w) `; x\\" p
pMessage(wchNum); pMessage(L" "); k+=2;
0 b& y H; c; L4 f
}
}
+ j- K7 ?; v& y' C) d
pMessage(L"\r\n"); k+=2;
/ z* h/ f8 ]8 Z- Q) m6 x+ n
a.BType=luStaData_int64; a.VType=luStaData_int64; a.x=k; //按函数o的要求，返回输出的字符总数
8 a4 x, ?1 P# i! U
break;
/ m- Q, e0 T, W3 d
default:& P# x) h$ Q$ G/ i
break;. O' c9 h7 i7 Z/ Z
}
7 D6 t: ?' Y3 K! h, K
return a;3 ~& T. n1 e# t8 m& t( _\\" \
}1 p; k0 r! {1 t$ B% D
void main(void)
\\" \+ P- Z9 C0 s* R8 _1 @
{9 J; J2 w0 e/ Z
void *hFor; //表达式句柄
2 ] o0 T) K! d+ H1 A9 _$ m0 H
luINT nPara; //存放表达式的自变量个数
9 v+ U5 x2 [ y; R' {, [
LuData *pPara; //存放输入自变量的数组指针; k5 J6 Q& ~6 i
luINT ErrBegin,ErrEnd; //表达式编译出错的初始位置和结束位置
1 S' y- l1 M J\\" {
int ErrCode; //错误代码; b6 [1 s. T1 q8 d5 _
void *v;
) L' q: B9 @; j8 V k
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.]}";//字符串表达式，矩阵乘2 q\\" e* b% v\\" {9 W\\" T; V6 ?\\" R
//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.]}";//字符串表达式，矩阵点乘) ~, C+ O2 N7 [, u: W3 R7 o
LuData Val;
% ?# I! o, P+ C9 b2 ~1 X
if(!InitLu()) return; //初始化Lu
7 h0 s( l! ^5 }
while(LockKey(Matrix,DelMatrix,OpMatrix)){Matrix--;} //锁定一个键，用于存储矩阵扩展类型
/ L* W4 Y i c. n+ u# X
/ j) {5 R. e+ H
Val.BType=luStaData_int64; Val.VType=luStaData_int64; Val.x=Matrix; //定义整数常量/ {( }, ~ i9 z
SetConst(L"matrix",&Val); //设置整数常量
6 h# M' o ~5 o# C4 e9 @
InsertKey("\0\0\0\0",4,luPubKey_User,LuMessage,NULL,NULL,1,v); //使Lu运行时可输出函数信息
' N, t4 ~1 j/ j' m9 i$ L
wcout.imbue(locale("chs")); //设置输出的locale为中文
: \+ E& Z, ^* e! S5 X l1 Q
- m' q- T. m0 `
ErrCode=LuCom(ForStr,0,0,0,hFor,nPara,pPara,ErrBegin,ErrEnd); //编译表达式: ?/ t' s( a$ k; c! s5 X' d
if(ErrCode)
, `- ?% m# H; @9 A: W7 D! P6 d
{
( P4 \6 [# K9 ]! S5 C\\" k8 @/ X
wcout<<L"表达式有错误！错误代码："<<ErrCode<<endl;! y! V5 ]2 R. ?: p6 f2 l
}- O+ Z1 I# d9 ^5 I8 c, @1 [3 U9 @0 p
else
{# k8 w* g n+ O' ?0 t. C+ n# ^( M
LuCal(hFor,pPara); //计算表达式的值
$ o- A2 A7 {3 S5 t
}
3 x# Q( f3 L\\" b1 Q9 O- s3 b
LockKey(Matrix,NULL,OpMatrix);//解锁键Matrix，本例中，该函数可以不用7 T/ b6 N, V J0 |8 `+ }& a3 S
FreeLu(); //释放Lu* i0 C, O% V9 s9 L+ a6 @
}

#include <windows.h>  {9 d1 H9 r5 H. H% I  u

#include <iostream> 
: z' ?4 T: k& _! e/ {\\" m. ^! Q( O' \
#include <math.h>3 e8 C3 B2 r; G$ D1 d& e' w  e3 d/ C

#include "lu32.h" 
8 A- S% R! G\\" M- t$ E\\" Y
#pragma comment( lib, "lu32.lib" )5 }3 g7 P+ m3 A# o( F( O2 P

using namespace std;) }\\" \, i5 N0 }& Y+ b

//自定义矩阵+ I& ^- R8 O  i8 b6 L2 c1 L1 Q

class myMatrix 
% `6 T$ r, s: |3 d\\" [/ Z
{ 
  c: q\\" d- m. _* k+ ~; X8 l1 l
public:/ ]\\" a* Q& f+ d2 D

double *Array;        //数据缓冲区 
+ Q2 A  N/ v' ~/ |; l
        luVOID ArrayLen;        //数据缓冲区长度 
! ^, |0 S5 l- e2 v
        luVOID Dim[2];        //矩阵维数8 E' r, W4 o# N! K. b3 G

myMatrix(){Array=NULL; ArrayLen=0; Dim[0]=0; Dim[1]=0;}( T. }/ o( q; A

~myMatrix() 
1 f: H  R7 l  {9 R, e7 i
        { 
7 R\\" N- n  b  E( z% i
                if(Array) delete[] Array; 
  @! q\\" R& u7 M; x8 G) O1 _
        }  ^1 N1 S1 @. H6 t

}; 
: ]2 M+ I4 S2 p1 @7 n3 }- O$ P
luKEY Matrix=-1000;        //标识矩阵类型，最终的Matrix由LockKey决定 
\\" w* W7 ?; S3 t6 S' \+ D2 i, a
void _stdcall LuMessage(wchar_t *pch)//输出动态库信息，该函数注册到Lu，由Lu二级函数调用 
8 c1 `% l9 I& r: j/ J! k: N\\" V5 _
{ 
; U% K4 U  B8 T2 g1 Y4 o1 H: S  U
        wcout<<pch;( q6 q! g% L; d8 C( F- H

}0 O# C1 d: G. D3 S# t9 V; j

void _stdcall DelMatrix(void *me)        //用于LockKey函数及InsertKey函数，使Lu能自动销毁myMatrix对象 
5 l3 \3 F/ b1 T% ?
{ 
& m\\" C- k6 K4 G: O; Y
        delete (myMatrix *)me; 
2 `- r# W& b# {! Z$ o% [/ T! |& T; B
}) ?+ n9 U, C: h1 z! j6 \3 p! k

myMatrix * _stdcall NewMatrix(luVOID m,luVOID n)        //生成一个myMatrix对象( p, N; P$ w% s3 _' \; V, H! G* ]8 e

{ 
- k( P3 |% w, y! N8 x( a
        myMatrix *pMatrix;5 _- g& ]) @$ B: @- N* H- v) |

luVOID k;! a* i$ \) u. q: ~6 B1 r8 D8 c

double *pa;7 s, I+ S1 c' _\\" I( a; k

char keyname[sizeof(luVOID)];/ X8 y1 {$ T9 F% R: Z, @6 X

void *NowKey; 
: ]* Z6 O\\" q; r7 w( X; _/ ?, V
        k=m*n; 
1 B6 n( U3 Z/ ^\\" F# i5 ^
        pMatrix=(myMatrix *)GetBufObj(Matrix,keyname);//先尝试从缓冲区中获取一个矩阵对象 
. o+ v& _- A3 n5 j2 o- d
        if(pMatrix) 
6 H3 Z; ]2 g8 j. q
        {* U, w; o% [\\" R' [\\" a

if(pMatrix->ArrayLen!=k)        //重置矩阵的大小' }# t% [5 i8 M5 ?9 Q% q

{ 
5 C$ N: o+ Y' J+ f  a5 S
                        pa=new double[k];: o( i6 r1 r3 c- h$ G/ t, f

if(!pa)* {) D1 |$ D4 b5 W7 Z! f2 q3 \

{ 
% v  V7 G9 B. q
                                DeleteKey(keyname,sizeof(luVOID),Matrix,DelMatrix,1);        //将矩阵对象放回缓冲区 
# A- u+ b2 x% o: m, E' V9 `, k6 }\\" O
                                return NULL; 
6 `1 E& g6 |( s
                        } 
5 ]* R' _5 K4 ~1 Y
                        delete[] pMatrix->Array;% B1 n- X' \& P; L9 {

pMatrix->Array=pa; 
1 y( A: V; X$ {4 B$ s
                }% k+ g1 |7 V5 a9 P

}8 G0 {! m5 b% F' O+ y  r4 U' A' ^2 g2 y

else, _4 W4 [; V6 g! N$ F& d

{ 
  v2 L& o+ ^$ F2 Q  Q& F6 |( V
                pMatrix=new myMatrix;        //创建矩阵对象4 N$ U: q' O\\" Z* G0 g$ S

if(!pMatrix) return NULL; 
9 g  z. N0 d3 b: l# y7 u& h
                pMatrix->Array=new double[k];: W; P. L; {7 |8 X- }+ n& f

if(!pMatrix->Array) 
, ]! N  e3 ?% o8 f5 _
                { 
) @; J- Q0 O2 t' h
                        delete pMatrix;. J/ p5 k+ O) u; K! w) E% O

return NULL;- D- w) Q- X$ f1 g/ T6 j

}. U3 {! D$ x  \, {

if(InsertKey((char *)&pMatrix,-1,Matrix,pMatrix,DelMatrix,NULL,0,NowKey))        //将矩阵对象注册到Lu 
- q4 \# u+ ?6 _0 |# n8 k# v
                {5 A( L1 l1 D. C9 c! N6 C

delete pMatrix; 
' h$ X2 I  U# |8 G! t2 ~
                        return NULL;! L  U; ^' T( S! m5 Y) ^+ B1 z

}  M* f0 T9 _* p7 [9 m- Y

}% l7 |6 B7 \. r( l# ?

pMatrix->ArrayLen=k; pMatrix->Dim[0]=m; pMatrix->Dim[1]=n; 
5 ~& S4 x' l+ y+ O5 ?( l. A' N9 N\\" e2 V
        return pMatrix; 
$ _  h1 z$ u! f+ ^# q# ^
} 
( @* e\\" ~- G* ?
LuData _stdcall OpMatrix(luINT mm,LuData *xx,void *hFor,int theOperator)        //运算符重载函数，用于LockKey函数 
% Y* h$ w& f1 I3 I( @, J4 ]
{0 V3 A: q# x5 z

LuData a; 
- M  t9 _+ @4 C: D% y) G
        myMatrix *pMatrix1,*pMatrix2,*pMatrix3;: Z& \% d$ M) A4 w7 S

luVOID i,j,k,m,n,u,v;1 }\\" g- c# t. P1 O! k

double *pa,*pb,*pc;9 ]3 V- J\\" I5 Y  q

luMessage pMessage;6 Y& m) L* q8 K$ w. V

wchar_t wchNum[32]; 
# i: u7 C5 K; o0 _
        char chNum[32]; 
9 J\\" U# p7 s& @1 ]8 v# ~0 r
        a.BType=luStaData_nil; a.VType=luStaData_nil; a.x=0;# t- ^- W% X3 U9 S8 u+ p! Z

switch(theOperator) 
+ K2 w8 M3 e: c2 N2 ~! U* Q
        {1 Y2 p$ {  s0 m. ^% ~1 H

case 2:        //重载运算符* 
6 q' j' h* N9 z  `) u& H# b
                pMatrix1=(myMatrix *)SearchKey((char *)&(xx->x),sizeof(luVOID),Matrix); 
: o7 x. a: @* L* y$ F; g
                pMatrix2=(myMatrix *)SearchKey((char *)&((xx+1)->x),sizeof(luVOID),Matrix); 
* }- H( _2 v! m
                if(!pMatrix1 || !pMatrix2) break;        //对象句柄无效，不是矩阵 
- m. e\\" ~! s6 C( w
                if(pMatrix1->Dim[1]!=pMatrix2->Dim[0]) break;        //维数不匹配/ T  v\\" B! y. n' C  t

pMatrix3=NewMatrix(pMatrix1->Dim[0],pMatrix2->Dim[1]);        //生成新矩阵 
\\" X/ W/ X& Q0 b( A, Q8 N9 c( W
                if(!pMatrix3) break;! s# i; c\\" z2 x1 h3 U7 t

pa=pMatrix1->Array; pb=pMatrix2->Array; pc=pMatrix3->Array;: H1 ?0 H, v$ ?, s$ R6 b  H

m=pMatrix1->Dim[0]; n=pMatrix1->Dim[1]; k=pMatrix2->Dim[1];- d; m3 e8 l2 @6 W6 B, \  R

for(i=0; i<m; i++)        //矩阵乘 
! r, a  T# w* K
                {( Y* b* _7 q: p- z* q$ ~9 |

for(j=0; j<k; j++)) K, |& f. }/ V( B8 \, Y/ k

{ 
: d+ d\\" H  F4 o
                                u=i*k+j; pc[u]=0.0;- k# T. a6 @9 I- C3 \. [  ^

for (v=0; v<n; v++)- D- b: ^- M/ o1 A. x; w

{ 
+ Z! u* v% x6 L
                                        pc[u]=pc[u]+pa[i*n+v]*pb[v*k+j]; 
! z1 Y/ h- K7 r9 Z
                                } 
% J, x- x! p1 R6 w! M# N! M: N; ~4 l
                        }2 H( w1 D0 C  c4 C# L  K& E: R

} 
2 A; v5 ?8 l+ s% ]
                FunReObj(hFor);        //告诉Lu，返回一个动态对象 
0 Y# `' l0 x% O( u7 W
                a.BType=Matrix; a.VType=Matrix; a.x=0; *(luVOID *)&(a.x)=(luVOID)pMatrix3;, S3 `  {% h3 v, m0 f

break; 
6 u4 F  f, W$ Q' v6 P
        case 25:        //重载运算符.*; u  G  @4 ~  I, K

pMatrix1=(myMatrix *)SearchKey((char *)&(xx->x),sizeof(luVOID),Matrix);1 w3 ~2 B& s2 o/ z0 D9 ]& n

pMatrix2=(myMatrix *)SearchKey((char *)&((xx+1)->x),sizeof(luVOID),Matrix); 
& w1 [3 d) V. X( M/ S6 `
                if(!pMatrix1 || !pMatrix2) break;        //对象句柄无效，不是矩阵# t5 B3 o2 J+ R2 U2 e

if(pMatrix1->Dim[0]!=pMatrix2->Dim[0] || pMatrix1->Dim[1]!=pMatrix2->Dim[1]) break;        //维数不相同& W( s2 @! c9 h/ n\\" M  p( q

pMatrix3=NewMatrix(pMatrix1->Dim[0],pMatrix1->Dim[1]);        //生成新矩阵( \3 ?$ t3 H! E( U2 Z4 O

if(!pMatrix3) break; 
6 w9 |\\" r& U6 @, P
                for(i=0;i<pMatrix1->ArrayLen;i++) pMatrix3->Array[i]=pMatrix1->Array[i]*pMatrix2->Array[i];        //矩阵点乘 
% N, L' ?9 h# g+ ~5 I
                FunReObj(hFor);        //告诉Lu，返回一个动态对象. m2 C0 E! P8 e4 p- G) c6 y9 j

a.BType=Matrix; a.VType=Matrix; a.x=0; *(luVOID *)&(a.x)=(luVOID)pMatrix3;5 \# I/ K  E/ U  X3 Q# C

break;  f) W' V3 l7 @\\" m! I! ~( ]/ H; w- O

case 46:        //重载函数new 
0 w9 \2 L, o6 p, H& R8 u- g
                if(mm<2) break; 
( L2 t: Y\\" ^& f! j\\" }! v
                if((xx+1)->x<1 || (xx+2)->x<1 || (xx+1)->BType!=luStaData_int64 || (xx+2)->BType!=luStaData_int64) break; 
0 D  @! \( I+ g\\" n& X
                pMatrix3=NewMatrix((luVOID)(xx+1)->x,(luVOID)(xx+2)->x);//生成新矩阵 
7 N' a: z. |  e3 F* o\\" T  N
                if(!pMatrix3) break;\\" l% ~\\" p0 Z1 \0 l( e' J% Q( W; G. N

for(j=0,i=3;i<=mm;i++,j++)        //赋初值 
& `# O+ N\\" u( R- Y5 W
                { 
4 U( v% e) E, A8 l9 G6 ]
                        if(j>=pMatrix3->ArrayLen) break;; ]% z/ w& ^& ]* `! l\\" L

if((xx+i)->BType!=luStaData_double) break;        //只接受实数参数5 A, _' P4 S5 W) t; v7 J/ ?4 d( r2 Q8 S

pMatrix3->Array[j]=*(double *)&((xx+i)->x); 
2 u4 P5 |( v/ M5 w; G2 t% T
                }5 D, g: L* G8 _8 I) Z2 V

FunReObj(hFor);        //告诉Lu，返回一个动态对象\\" }/ x% O' m% Y5 s: m' k# L

a.BType=Matrix; a.VType=Matrix; a.x=0; *(luVOID *)&(a.x)=(luVOID)pMatrix3;& K8 D  O# @0 Z2 T/ W0 l5 D( r2 t

break; 
7 F8 Y$ q* a: D- @1 H2 _* C
        case 49:        //重载函数o  A# Y: F8 e6 q

pMessage=(luMessage)SearchKey("\0\0\0\0",sizeof(luVOID),luPubKey_User); 
' l& M+ F5 ^: }3 P1 D) h
                if(!pMessage) break; 
& U9 @; }8 l$ N2 g# y2 c: d' ^6 N
                pMatrix1=(myMatrix *)SearchKey((char *)&(xx->x),sizeof(luVOID),Matrix); 
% n7 o3 ], l; }6 p6 k6 _: z  ^
                if(!pMatrix1) break;        //对象句柄无效，不是矩阵 
: k1 _7 L9 C& U+ j  r6 ^
                pa=pMatrix1->Array;% _4 v; i- U* l' t

m=pMatrix1->Dim[0]; n=pMatrix1->Dim[1]; k=0; 
) R7 ]8 a! ^6 T\\" i7 V0 ]' {
                for(i=0; i<m; i++)        //输出矩阵\\" B, \  y: P$ V5 O5 Q

{! F8 R9 F5 G6 F5 Q1 r8 {

pMessage(L"\r\n"); k+=2; 
9 p+ [# H1 _' c' v. M1 ^5 E
                        for(j=0; j<n; j++) 
: p. ]' p7 ^4 J& z
                        { 
+ m0 g0 {/ e- S1 [2 f& ?
                                _gcvt_s(chNum,pa[i*n+j],16); 
9 ?2 C2 u\\" n1 W( t\\" u; e
                                for(u=0;chNum[u];u++) {wchNum[u]=chNum[u]; k++;}/ c1 \9 M0 S0 P' k1 G5 f3 [+ W5 K

wchNum[u]='\0';3 _. h0 X% w) `; x\\" p

pMessage(wchNum); pMessage(L"  "); k+=2; 
0 b& y  H; c; L4 f
                        } 
\\" Z6 j, F+ }# Y! i! p/ E3 c; T: L% J  W
                } 
+ j- K7 ?; v& y' C) d
                pMessage(L"\r\n"); k+=2; 
/ z* h/ f8 ]8 Z- Q) m6 x+ n
                a.BType=luStaData_int64; a.VType=luStaData_int64; a.x=k;        //按函数o的要求，返回输出的字符总数 
8 a4 x, ?1 P# i! U
                break; 
/ m- Q, e0 T, W3 d
        default:& P# x) h$ Q$ G/ i

break;. O' c9 h7 i7 Z/ Z

} 
7 D6 t: ?' Y3 K! h, K
        return a;3 ~& T. n1 e# t8 m& t( _\\" \

}1 p; k0 r! {1 t$ B% D

void main(void) 
\\" \+ P- Z9 C0 s* R8 _1 @
{9 J; J2 w0 e/ Z

void *hFor;                //表达式句柄 
2 ]  o0 T) K! d+ H1 A9 _$ m0 H
        luINT nPara;                //存放表达式的自变量个数 
9 v+ U5 x2 [  y; R' {, [
        LuData *pPara;                //存放输入自变量的数组指针; k5 J6 Q& ~6 i

luINT ErrBegin,ErrEnd;        //表达式编译出错的初始位置和结束位置 
1 S' y- l1 M  J\\" {
        int ErrCode;                //错误代码; b6 [1 s. T1 q8 d5 _

void *v; 
) L' q: B9 @; j8 V  k
        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.]}";//字符串表达式，矩阵乘2 q\\" e* b% v\\" {9 W\\" T; V6 ?\\" R

//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.]}";//字符串表达式，矩阵点乘) ~, C+ O2 N7 [, u: W3 R7 o

LuData Val; 
% ?# I! o, P+ C9 b2 ~1 X
        if(!InitLu()) return;        //初始化Lu 
7 h0 s( l! ^5 }
        while(LockKey(Matrix,DelMatrix,OpMatrix)){Matrix--;}        //锁定一个键，用于存储矩阵扩展类型 
/ L* W4 Y  i  c. n+ u# X
 
/ j) {5 R. e+ H
        Val.BType=luStaData_int64; Val.VType=luStaData_int64; Val.x=Matrix;        //定义整数常量/ {( }, ~  i9 z

SetConst(L"matrix",&Val);        //设置整数常量 
6 h# M' o  ~5 o# C4 e9 @
        InsertKey("\0\0\0\0",4,luPubKey_User,LuMessage,NULL,NULL,1,v); //使Lu运行时可输出函数信息 
' N, t4 ~1 j/ j' m9 i$ L
        wcout.imbue(locale("chs"));        //设置输出的locale为中文 
: \+ E& Z, ^* e! S5 X  l1 Q
  - m' q- T. m0 `

ErrCode=LuCom(ForStr,0,0,0,hFor,nPara,pPara,ErrBegin,ErrEnd); //编译表达式: ?/ t' s( a$ k; c! s5 X' d

if(ErrCode) 
, `- ?% m# H; @9 A: W7 D! P6 d
        { 
( P4 \6 [# K9 ]! S5 C\\" k8 @/ X
                wcout<<L"表达式有错误！错误代码："<<ErrCode<<endl;! y! V5 ]2 R. ?: p6 f2 l

}- O+ Z1 I# d9 ^5 I8 c, @1 [3 U9 @0 p

else 
% a. M8 z) ~7 y: w! L( U  u! v: ~  A
        {# k8 w* g  n+ O' ?0 t. C+ n# ^( M

LuCal(hFor,pPara);        //计算表达式的值 
$ o- A2 A7 {3 S5 t
        } 
3 x# Q( f3 L\\" b1 Q9 O- s3 b
        LockKey(Matrix,NULL,OpMatrix);//解锁键Matrix，本例中，该函数可以不用7 T/ b6 N, V  J0 |8 `+ }& a3 S

FreeLu();                        //释放Lu* i0 C, O% V9 s9 L+ a6 @

}

习题：

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

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

main(:a,b,c,d,t,i)=
8 Q: r2 Q( m2 r! }! d* a7 {! y) c
a=new[matrix,2,2: 1.,2.,2.,1.],
+ { N: [7 n, q, Q+ R* w
b=new[matrix,2,2: 2.,1.,1.,2.],' D# r\" e; b1 q& y( {8 J
c=new[matrix,2,2: 2/3.,-1/3.,-1/3.,2/3.],
# ]\" A$ }4 O' `) o
t=clock(),
1 k1 N; V' ^7 E+ t
d=a*b, i=0, while{i<1000000, d=d*c*b, i++},
+ x: \5 Z5 g+ W+ u, Q
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\"}";//字符串表达式

复制代码

结果：