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

查看: 8448|回复: 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>
$ {2 S8 e# R- O' E; I+ g2 \- a4 u
#include <iostream>
3 }& B1 z6 B0 i
#include <math.h>* p8 m+ C' ~7 x3 N$ f4 o, N
#include "lu32.h", \( U3 U% ^$ N7 G4 ?+ C
#pragma comment( lib, "lu32.lib" )5 _3 B' P. n$ P) S8 R
using namespace std;3 ?$ |# Y3 E/ ^5 d! V
//自定义矩阵$ @$ D% b3 H) u. q- r
class myMatrix
, e9 r' r7 g) b+ j
{
\\" W2 |+ D: }. v: A' k( v
public:) B' U: ]8 L, z. \* k\\" r+ q7 I0 p! S
double *Array; //数据缓冲区. b! s, ]( C& q3 e0 j2 g. c7 R' O: G
luVOID ArrayLen; //数据缓冲区长度* I2 v. q4 M) A) m3 p3 F X; ?
luVOID Dim[2]; //矩阵维数( x2 b/ @! D+ T5 w6 ~
myMatrix(){Array=NULL; ArrayLen=0; Dim[0]=0; Dim[1]=0;}
/ Y\\" m' g/ p1 y+ j0 c9 M/ K
~myMatrix()
5 R9 }1 J4 x8 H6 Q' k
{
5 l\\" u! J& V3 t4 B3 K, f9 P! s
if(Array) delete[] Array;
7 {% \- ~1 {9 o1 y; i
}: r- N/ s4 g4 X\\" s0 u
};- l+ y9 J# L2 Z# z/ _' R* }0 X1 `
luKEY Matrix=-1000; //标识矩阵类型，最终的Matrix由LockKey决定- \\\" z: V1 B' z$ t9 i
void _stdcall LuMessage(wchar_t *pch)//输出动态库信息，该函数注册到Lu，由Lu二级函数调用 % e. `+ X- C% @2 F6 V
{0 \5 K% g' R* Y% |- \
wcout<<pch;
) {# A! V$ }# D, I9 O) J
}1 A n& w5 P( p. A- K' e
void _stdcall DelMatrix(void *me) //用于LockKey函数及InsertKey函数，使Lu能自动销毁myMatrix对象6 D! \$ D: [& E/ r0 h8 X7 C
{8 |) b! i1 A6 A0 b
delete (myMatrix *)me;1 E$ t* S/ [2 z/ n
}
( R1 |, o) A2 m! n# O
myMatrix * _stdcall NewMatrix(luVOID m,luVOID n) //生成一个myMatrix对象
! Z: d) f! y0 ~6 p/ S$ J
{
7 ~; t& l) u$ C P, H! [
myMatrix *pMatrix;
$ T0 V+ B+ [( |9 `. f5 [/ `6 u
luVOID k;
\\" Z8 Y\\" u, N' V9 E% @8 }$ L& H
double *pa;
\\" b: h+ C/ Q! \6 a+ ^- v9 p9 P
char keyname[sizeof(luVOID)];( l6 `9 w& j- Z5 D* A/ N
void *NowKey;
1 S# l+ f1 X* @' m/ j
k=m*n;. e& G: Z) G+ O; f9 ]- y
pMatrix=(myMatrix *)GetBufObj(Matrix,keyname);//先尝试从缓冲区中获取一个矩阵对象5 d! T. f& V9 ^7 g
if(pMatrix)1 g4 w; S9 V: ~! Z* m
{, r) _1 X& l3 U# ]- ?# P* V
if(pMatrix->ArrayLen!=k) //重置矩阵的大小
+ d V% p0 f. }) P1 F: T, L
{
- E: D; H! O% ?) `
pa=new double[k];
3 u _9 c6 d0 X. W, b; N: M
if(!pa)
d! C' F3 x* \ {5 f9 W: d
{
7 u2 x+ J8 ]) T/ M
DeleteKey(keyname,sizeof(luVOID),Matrix,DelMatrix,1); //将矩阵对象放回缓冲区8 h4 F! y( {) F
return NULL;
; N8 v, A. o3 L' z
}
. O7 Y1 }3 T z: y0 |: i
delete[] pMatrix->Array;8 q1 E( U9 Q. Z: ~4 c
pMatrix->Array=pa;
6 R7 Y, z! R& c' y4 C* I: f: a
}\\" F. C, V+ i) i) w
}
; z; g. O3 E/ x& S6 {
else7 }/ [- u* ~) w% L0 S4 I1 }; _, \
{/ u\\" z Z9 K# s2 C( O! ]
pMatrix=new myMatrix; //创建矩阵对象
) {1 ]) Y/ @, L' }: R7 J\\" W1 V
if(!pMatrix) return NULL;( F$ w1 {0 C6 `! R' b
pMatrix->Array=new double[k];
0 ^7 E s\\" [& v
if(!pMatrix->Array)% T W$ I$ w3 P7 L9 E
{. S4 z, E& O2 d0 d8 s/ ^, Z\\" d
delete pMatrix;
: b( V3 a2 e2 @- ]; a3 Z
return NULL;+ F. N$ @6 f$ q( m, e! m
}$ A9 ^# ?/ I1 [7 j
if(InsertKey((char *)&pMatrix,-1,Matrix,pMatrix,DelMatrix,NULL,0,NowKey)) //将矩阵对象注册到Lu
/ X& }9 b8 g% P' g( N- g5 q
{' P% D7 L2 F% q; N2 V( p) {4 u; @
delete pMatrix;! C1 Y8 m\\" Q W! @0 n$ g5 |% f/ O
return NULL;
, x' _+ }! e+ [0 S
}& [9 E4 e, `: P' R% }& I
}
2 B, J\\" J: r$ z6 r# G
pMatrix->ArrayLen=k; pMatrix->Dim[0]=m; pMatrix->Dim[1]=n;. O$ a3 m S: D# Y, c9 I
return pMatrix;& O+ `& s) l. w7 e/ L
}' D s. @, n\\" _ I1 l' ]# i\\" Y
LuData _stdcall OpMatrix(luINT mm,LuData *xx,void *hFor,int theOperator) //运算符重载函数，用于LockKey函数
9 Y3 A2 V/ w; `1 g
{
% t& m\\" F3 x1 B! q\\" z2 l# q
LuData a;
! ?9 z, U( [0 X6 `
myMatrix *pMatrix1,*pMatrix2,*pMatrix3;
\\" v4 G% I5 }+ ~$ t0 U, ^6 M\\" h3 U
luVOID i,j,k,m,n,u,v;
- h C/ e4 L2 N$ d\\" q3 ~
double *pa,*pb,*pc;& A$ `( `: Z6 k/ ]+ Q4 Q
luMessage pMessage;
4 o# g! ]9 h, ], O8 e2 }* i, O$ y
wchar_t wchNum[32];
; z* g/ y( z* z: `3 w1 h
char chNum[32];
. u1 T- T* X; x# h. e) b) g& ]8 A
a.BType=luStaData_nil; a.VType=luStaData_nil; a.x=0;; l ~/ {. B, d
switch(theOperator)
; N5 n, ]1 P+ ~2 i z
{
* y0 T9 ?% o- x
case 2: //重载运算符*: w9 L. f; }' C5 o! ^2 a6 i- ^
pMatrix1=(myMatrix *)SearchKey((char *)&(xx->x),sizeof(luVOID),Matrix);
) p3 u8 [6 B( z; e# A* M
pMatrix2=(myMatrix *)SearchKey((char *)&((xx+1)->x),sizeof(luVOID),Matrix);+ F, ^) q9 `# e. C8 J) H9 r* N H
if(!pMatrix1 || !pMatrix2) break; //对象句柄无效，不是矩阵2 S9 E5 A+ V. f* g2 A7 _ ^
if(pMatrix1->Dim[1]!=pMatrix2->Dim[0]) break; //维数不匹配3 H! l& q: ?; d+ p! L( z( l
pMatrix3=NewMatrix(pMatrix1->Dim[0],pMatrix2->Dim[1]); //生成新矩阵
J3 k: p1 n0 I( O
if(!pMatrix3) break;* R' v8 t4 \% I2 @0 J/ F, h
pa=pMatrix1->Array; pb=pMatrix2->Array; pc=pMatrix3->Array;
* b% ?! J, ~2 t8 A
m=pMatrix1->Dim[0]; n=pMatrix1->Dim[1]; k=pMatrix2->Dim[1]; b' {\\" T6 g3 m, e6 Y
for(i=0; i<m; i++) //矩阵乘2 b, ^( s4 B+ O3 u4 Y6 C, M# Y
{4 y- |( w! b& Z6 u( T
for(j=0; j<k; j++)3 I5 ?7 W1 t( I, n
{/ P6 _( P2 ]7 M2 r$ ?5 F
u=i*k+j; pc[u]=0.0;
/ L& b h1 o; P* K9 f
for (v=0; v<n; v++)
; f# j6 r \6 B$ N; q' {5 m
{
: h, {( b$ @+ t3 A7 c2 a. c
pc[u]=pc[u]+pa[i*n+v]*pb[v*k+j];
# h3 n& _# ~0 }3 H$ t3 h
}
' s! n! |4 q5 u O\\" `
}
6 u: |6 [3 [2 X9 a+ t
}0 t\\" E9 X; E& `3 d) E5 F
FunReObj(hFor); //告诉Lu，返回一个动态对象\\" P( d9 U$ D- Y( P% v
a.BType=Matrix; a.VType=Matrix; a.x=0; *(luVOID *)&(a.x)=(luVOID)pMatrix3;
0 V# x. y9 t i3 e
break;( {% H0 V% S; y8 k4 _, l6 `
case 25: //重载运算符.*
& J6 d# H- U) I( s7 A, ]4 ~
pMatrix1=(myMatrix *)SearchKey((char *)&(xx->x),sizeof(luVOID),Matrix);8 y. s1 w' F$ k- K& R3 q( q
pMatrix2=(myMatrix *)SearchKey((char *)&((xx+1)->x),sizeof(luVOID),Matrix);
- B' s2 P+ P3 i0 M
if(!pMatrix1 || !pMatrix2) break; //对象句柄无效，不是矩阵9 c5 p+ b. I$ M# H$ t
if(pMatrix1->Dim[0]!=pMatrix2->Dim[0] || pMatrix1->Dim[1]!=pMatrix2->Dim[1]) break; //维数不相同
, g4 K3 r' p\\" f; E: O
pMatrix3=NewMatrix(pMatrix1->Dim[0],pMatrix1->Dim[1]); //生成新矩阵
2 \; G2 N1 M+ Z( F2 t* {0 Y8 I1 x
if(!pMatrix3) break;7 K( i. _/ L: @2 h% ~
for(i=0;i<pMatrix1->ArrayLen;i++) pMatrix3->Array[i]=pMatrix1->Array[i]*pMatrix2->Array[i]; //矩阵点乘: R( E( i! x# ]4 g! U
FunReObj(hFor); //告诉Lu，返回一个动态对象
^' [- \/ F! U) Z+ W( @
a.BType=Matrix; a.VType=Matrix; a.x=0; *(luVOID *)&(a.x)=(luVOID)pMatrix3;+ z+ m- }% i4 K5 r$ b# e+ O
break;
: ?0 [* D$ s% N& z* t
case 46: //重载函数new
$ a* ~) c\\" Z, O; y$ p
if(mm<2) break;
+ R+ S8 D$ o9 _6 }5 Z
if((xx+1)->x<1 || (xx+2)->x<1 || (xx+1)->BType!=luStaData_int64 || (xx+2)->BType!=luStaData_int64) break;
6 |* m7 }0 F9 ?4 {& o9 X! X\\" \
pMatrix3=NewMatrix((luVOID)(xx+1)->x,(luVOID)(xx+2)->x);//生成新矩阵/ Z- p z3 S, B- `0 D6 W' v! ~
if(!pMatrix3) break;/ l- F6 k$ o7 _; C
for(j=0,i=3;i<=mm;i++,j++) //赋初值4 L, p$ R3 a( `: z' g
{3 z* ~2 B( s% C
if(j>=pMatrix3->ArrayLen) break;: F( f; s! a$ }0 P5 D' h9 j4 I. n$ B
if((xx+i)->BType!=luStaData_double) break; //只接受实数参数
- @6 L* C6 c: L\\" t5 O, N
pMatrix3->Array[j]=*(double *)&((xx+i)->x);
& w( @0 r1 l9 y# P$ N
}
/ U& a$ B( ^0 L3 X& [9 p
FunReObj(hFor); //告诉Lu，返回一个动态对象! K0 S g! `1 q' g
a.BType=Matrix; a.VType=Matrix; a.x=0; *(luVOID *)&(a.x)=(luVOID)pMatrix3;, L' J. ]: V. k4 M' n
break;
1 F! [0 x( L& r) a2 v* r\\" E, x
case 49: //重载函数o
[% \8 E' v) J0 S4 h
pMessage=(luMessage)SearchKey("\0\0\0\0",sizeof(luVOID),luPubKey_User);
; N O; F! {8 m& p
if(!pMessage) break;4 `3 X( Z/ g, W
pMatrix1=(myMatrix *)SearchKey((char *)&(xx->x),sizeof(luVOID),Matrix);6 T$ _/ m2 `& J( u! X
if(!pMatrix1) break; //对象句柄无效，不是矩阵
! x: L2 l5 f8 j3 j, T9 q
pa=pMatrix1->Array;4 t% {, ?9 y, T7 `! z2 Q
m=pMatrix1->Dim[0]; n=pMatrix1->Dim[1]; k=0;
8 l0 I\\" u, M8 ^* y
for(i=0; i<m; i++) //输出矩阵
/ Q% X) N; x2 q* J
{
& _. }2 x: q! L5 P
pMessage(L"\r\n"); k+=2;
# o. w/ X9 o4 f' a. m5 @
for(j=0; j<n; j++)! j( e# g3 {) K6 C) t
{ s$ a7 Q: I( @
_gcvt_s(chNum,pa[i*n+j],16);
, N& |. F: k8 _\\" ^5 u; w2 w
for(u=0;chNum[u];u++) {wchNum[u]=chNum[u]; k++;}\\" p( {% a0 o: O1 p- {1 P
wchNum[u]='\0';
: ^$ X: \* Z4 v4 F/ k0 F: y; D
pMessage(wchNum); pMessage(L" "); k+=2;
7 v6 ?7 @4 H\\" P Y& O1 U6 _( Q
}
1 Y! Y/ x\\" o6 t B9 Y2 l
}
+ Z! z% e! x* p3 w! ~8 C3 o
pMessage(L"\r\n"); k+=2;
0 T- L) a1 \8 `; i, W- X5 V2 S1 {
a.BType=luStaData_int64; a.VType=luStaData_int64; a.x=k; //按函数o的要求，返回输出的字符总数 B% n5 x( G- n; l, g
break;
) c% F3 K0 y- z) e( T! x
default:
. b3 I( V( M; [# n0 A0 h3 ~
break;
& m! I9 f) w3 n6 ^; [5 s. O
}3 ? w5 {: \8 T
return a;
. \0 t! |- C5 M+ k4 ]' e
}2 d4 b. W/ ^0 j
void main(void)
* a- E) w; Q0 A& E' J! p
{
; O p5 b\\" E2 g
void *hFor; //表达式句柄
7 [; R# b. I4 A& C- X2 D. N
luINT nPara; //存放表达式的自变量个数
+ V& J1 v% G7 c- p9 k7 n
LuData *pPara; //存放输入自变量的数组指针
1 t- p/ F H2 u$ r6 ?) ~+ Z; I
luINT ErrBegin,ErrEnd; //表达式编译出错的初始位置和结束位置4 p$ q F7 y/ D! Z) E' d0 k1 s A
int ErrCode; //错误代码
3 G3 i: \' \% L6 f
void *v;$ }( F% D) @+ \; k: L& [
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.]}";//字符串表达式，矩阵乘* q: H, y) U) _) h7 G
//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.]}";//字符串表达式，矩阵点乘& B+ w7 y, v8 b4 v
LuData Val;, {5 `+ G5 Z\\" t# N( X
if(!InitLu()) return; //初始化Lu
4 q( l) B0 a; N& F x2 R- ~* w
while(LockKey(Matrix,DelMatrix,OpMatrix)){Matrix--;} //锁定一个键，用于存储矩阵扩展类型7 u8 e. [9 {- @# y; }
6 U! z' F9 A1 o! J' F
Val.BType=luStaData_int64; Val.VType=luStaData_int64; Val.x=Matrix; //定义整数常量) {2 E\\" s; b: S* H2 w; n- l
SetConst(L"matrix",&Val); //设置整数常量
* o! Y% v8 ^5 u5 z- R2 e
InsertKey("\0\0\0\0",4,luPubKey_User,LuMessage,NULL,NULL,1,v); //使Lu运行时可输出函数信息
v4 b0 B0 s1 W# m
wcout.imbue(locale("chs")); //设置输出的locale为中文4 k% p8 y% B' X2 k: d6 _/ Z+ `) l. l5 r
4 R5 E y! S( v0 H) s
ErrCode=LuCom(ForStr,0,0,0,hFor,nPara,pPara,ErrBegin,ErrEnd); //编译表达式\\" f8 v5 e. X# k& g
if(ErrCode)
4 b5 M; S9 H' A w8 P& f
{4 D3 m3 u4 \ J5 Y: b/ g
wcout<<L"表达式有错误！错误代码："<<ErrCode<<endl;3 V8 S( q, g\\" S6 N\\" h/ L. g+ D
}5 T* e1 T; }) M& w6 O' O
else! U$ F9 g0 w c# [- k9 w' B
{' m, y9 c, f& d4 t\\" } P6 f
LuCal(hFor,pPara); //计算表达式的值
; A4 |5 a8 s& M6 U# v3 [! [
}
1 M( y, U5 L3 G+ I. B/ T0 g- l
LockKey(Matrix,NULL,OpMatrix);//解锁键Matrix，本例中，该函数可以不用/ p1 E; i: ]* a8 d; ~
FreeLu(); //释放Lu0 J% A& G: q3 j+ }
}

#include <windows.h> 
$ {2 S8 e# R- O' E; I+ g2 \- a4 u
#include <iostream> 
3 }& B1 z6 B0 i
#include <math.h>* p8 m+ C' ~7 x3 N$ f4 o, N

#include "lu32.h", \( U3 U% ^$ N7 G4 ?+ C

#pragma comment( lib, "lu32.lib" )5 _3 B' P. n$ P) S8 R

using namespace std;3 ?$ |# Y3 E/ ^5 d! V

//自定义矩阵$ @$ D% b3 H) u. q- r

class myMatrix 
, e9 r' r7 g) b+ j
{ 
\\" W2 |+ D: }. v: A' k( v
public:) B' U: ]8 L, z. \* k\\" r+ q7 I0 p! S

double *Array;        //数据缓冲区. b! s, ]( C& q3 e0 j2 g. c7 R' O: G

luVOID ArrayLen;        //数据缓冲区长度* I2 v. q4 M) A) m3 p3 F  X; ?

luVOID Dim[2];        //矩阵维数( x2 b/ @! D+ T5 w6 ~

myMatrix(){Array=NULL; ArrayLen=0; Dim[0]=0; Dim[1]=0;} 
/ Y\\" m' g/ p1 y+ j0 c9 M/ K
        ~myMatrix() 
5 R9 }1 J4 x8 H6 Q' k
        { 
5 l\\" u! J& V3 t4 B3 K, f9 P! s
                if(Array) delete[] Array; 
7 {% \- ~1 {9 o1 y; i
        }: r- N/ s4 g4 X\\" s0 u

};- l+ y9 J# L2 Z# z/ _' R* }0 X1 `

luKEY Matrix=-1000;        //标识矩阵类型，最终的Matrix由LockKey决定- \\\" z: V1 B' z$ t9 i

void _stdcall LuMessage(wchar_t *pch)//输出动态库信息，该函数注册到Lu，由Lu二级函数调用 % e. `+ X- C% @2 F6 V

{0 \5 K% g' R* Y% |- \

wcout<<pch; 
) {# A! V$ }# D, I9 O) J
}1 A  n& w5 P( p. A- K' e

void _stdcall DelMatrix(void *me)        //用于LockKey函数及InsertKey函数，使Lu能自动销毁myMatrix对象6 D! \$ D: [& E/ r0 h8 X7 C

{8 |) b! i1 A6 A0 b

delete (myMatrix *)me;1 E$ t* S/ [2 z/ n

} 
( R1 |, o) A2 m! n# O
myMatrix * _stdcall NewMatrix(luVOID m,luVOID n)        //生成一个myMatrix对象 
! Z: d) f! y0 ~6 p/ S$ J
{ 
7 ~; t& l) u$ C  P, H! [
        myMatrix *pMatrix; 
$ T0 V+ B+ [( |9 `. f5 [/ `6 u
        luVOID k; 
\\" Z8 Y\\" u, N' V9 E% @8 }$ L& H
        double *pa; 
\\" b: h+ C/ Q! \6 a+ ^- v9 p9 P
        char keyname[sizeof(luVOID)];( l6 `9 w& j- Z5 D* A/ N

void *NowKey; 
1 S# l+ f1 X* @' m/ j
        k=m*n;. e& G: Z) G+ O; f9 ]- y

pMatrix=(myMatrix *)GetBufObj(Matrix,keyname);//先尝试从缓冲区中获取一个矩阵对象5 d! T. f& V9 ^7 g

if(pMatrix)1 g4 w; S9 V: ~! Z* m

{, r) _1 X& l3 U# ]- ?# P* V

if(pMatrix->ArrayLen!=k)        //重置矩阵的大小 
+ d  V% p0 f. }) P1 F: T, L
                { 
- E: D; H! O% ?) `
                        pa=new double[k]; 
3 u  _9 c6 d0 X. W, b; N: M
                        if(!pa) 
  d! C' F3 x* \  {5 f9 W: d
                        { 
7 u2 x+ J8 ]) T/ M
                                DeleteKey(keyname,sizeof(luVOID),Matrix,DelMatrix,1);        //将矩阵对象放回缓冲区8 h4 F! y( {) F

return NULL; 
; N8 v, A. o3 L' z
                        } 
. O7 Y1 }3 T  z: y0 |: i
                        delete[] pMatrix->Array;8 q1 E( U9 Q. Z: ~4 c

pMatrix->Array=pa; 
6 R7 Y, z! R& c' y4 C* I: f: a
                }\\" F. C, V+ i) i) w

} 
; z; g. O3 E/ x& S6 {
        else7 }/ [- u* ~) w% L0 S4 I1 }; _, \

{/ u\\" z  Z9 K# s2 C( O! ]

pMatrix=new myMatrix;        //创建矩阵对象 
) {1 ]) Y/ @, L' }: R7 J\\" W1 V
                if(!pMatrix) return NULL;( F$ w1 {0 C6 `! R' b

pMatrix->Array=new double[k]; 
0 ^7 E  s\\" [& v
                if(!pMatrix->Array)% T  W$ I$ w3 P7 L9 E

{. S4 z, E& O2 d0 d8 s/ ^, Z\\" d

delete pMatrix; 
: b( V3 a2 e2 @- ]; a3 Z
                        return NULL;+ F. N$ @6 f$ q( m, e! m

}$ A9 ^# ?/ I1 [7 j

if(InsertKey((char *)&pMatrix,-1,Matrix,pMatrix,DelMatrix,NULL,0,NowKey))        //将矩阵对象注册到Lu 
/ X& }9 b8 g% P' g( N- g5 q
                {' P% D7 L2 F% q; N2 V( p) {4 u; @

delete pMatrix;! C1 Y8 m\\" Q  W! @0 n$ g5 |% f/ O

return NULL; 
, x' _+ }! e+ [0 S
                }& [9 E4 e, `: P' R% }& I

} 
2 B, J\\" J: r$ z6 r# G
        pMatrix->ArrayLen=k; pMatrix->Dim[0]=m; pMatrix->Dim[1]=n;. O$ a3 m  S: D# Y, c9 I

return pMatrix;& O+ `& s) l. w7 e/ L

}' D  s. @, n\\" _  I1 l' ]# i\\" Y

LuData _stdcall OpMatrix(luINT mm,LuData *xx,void *hFor,int theOperator)        //运算符重载函数，用于LockKey函数 
9 Y3 A2 V/ w; `1 g
{ 
% t& m\\" F3 x1 B! q\\" z2 l# q
        LuData a; 
! ?9 z, U( [0 X6 `
        myMatrix *pMatrix1,*pMatrix2,*pMatrix3; 
\\" v4 G% I5 }+ ~$ t0 U, ^6 M\\" h3 U
        luVOID i,j,k,m,n,u,v; 
- h  C/ e4 L2 N$ d\\" q3 ~
        double *pa,*pb,*pc;& A$ `( `: Z6 k/ ]+ Q4 Q

luMessage pMessage; 
4 o# g! ]9 h, ], O8 e2 }* i, O$ y
        wchar_t wchNum[32]; 
; z* g/ y( z* z: `3 w1 h
        char chNum[32]; 
. u1 T- T* X; x# h. e) b) g& ]8 A
        a.BType=luStaData_nil; a.VType=luStaData_nil; a.x=0;; l  ~/ {. B, d

switch(theOperator) 
; N5 n, ]1 P+ ~2 i  z
        { 
* y0 T9 ?% o- x
        case 2:        //重载运算符*: w9 L. f; }' C5 o! ^2 a6 i- ^

pMatrix1=(myMatrix *)SearchKey((char *)&(xx->x),sizeof(luVOID),Matrix); 
) p3 u8 [6 B( z; e# A* M
                pMatrix2=(myMatrix *)SearchKey((char *)&((xx+1)->x),sizeof(luVOID),Matrix);+ F, ^) q9 `# e. C8 J) H9 r* N  H

if(!pMatrix1 || !pMatrix2) break;        //对象句柄无效，不是矩阵2 S9 E5 A+ V. f* g2 A7 _  ^

if(pMatrix1->Dim[1]!=pMatrix2->Dim[0]) break;        //维数不匹配3 H! l& q: ?; d+ p! L( z( l

pMatrix3=NewMatrix(pMatrix1->Dim[0],pMatrix2->Dim[1]);        //生成新矩阵 
  J3 k: p1 n0 I( O
                if(!pMatrix3) break;* R' v8 t4 \% I2 @0 J/ F, h

pa=pMatrix1->Array; pb=pMatrix2->Array; pc=pMatrix3->Array; 
* b% ?! J, ~2 t8 A
                m=pMatrix1->Dim[0]; n=pMatrix1->Dim[1]; k=pMatrix2->Dim[1];  b' {\\" T6 g3 m, e6 Y

for(i=0; i<m; i++)        //矩阵乘2 b, ^( s4 B+ O3 u4 Y6 C, M# Y

{4 y- |( w! b& Z6 u( T

for(j=0; j<k; j++)3 I5 ?7 W1 t( I, n

{/ P6 _( P2 ]7 M2 r$ ?5 F

u=i*k+j; pc[u]=0.0; 
/ L& b  h1 o; P* K9 f
                                for (v=0; v<n; v++) 
; f# j6 r  \6 B$ N; q' {5 m
                                { 
: h, {( b$ @+ t3 A7 c2 a. c
                                        pc[u]=pc[u]+pa[i*n+v]*pb[v*k+j]; 
# h3 n& _# ~0 }3 H$ t3 h
                                } 
' s! n! |4 q5 u  O\\" `
                        } 
6 u: |6 [3 [2 X9 a+ t
                }0 t\\" E9 X; E& `3 d) E5 F

FunReObj(hFor);        //告诉Lu，返回一个动态对象\\" P( d9 U$ D- Y( P% v

a.BType=Matrix; a.VType=Matrix; a.x=0; *(luVOID *)&(a.x)=(luVOID)pMatrix3; 
0 V# x. y9 t  i3 e
                break;( {% H0 V% S; y8 k4 _, l6 `

case 25:        //重载运算符.* 
& J6 d# H- U) I( s7 A, ]4 ~
                pMatrix1=(myMatrix *)SearchKey((char *)&(xx->x),sizeof(luVOID),Matrix);8 y. s1 w' F$ k- K& R3 q( q

pMatrix2=(myMatrix *)SearchKey((char *)&((xx+1)->x),sizeof(luVOID),Matrix); 
- B' s2 P+ P3 i0 M
                if(!pMatrix1 || !pMatrix2) break;        //对象句柄无效，不是矩阵9 c5 p+ b. I$ M# H$ t

if(pMatrix1->Dim[0]!=pMatrix2->Dim[0] || pMatrix1->Dim[1]!=pMatrix2->Dim[1]) break;        //维数不相同 
, g4 K3 r' p\\" f; E: O
                pMatrix3=NewMatrix(pMatrix1->Dim[0],pMatrix1->Dim[1]);        //生成新矩阵 
2 \; G2 N1 M+ Z( F2 t* {0 Y8 I1 x
                if(!pMatrix3) break;7 K( i. _/ L: @2 h% ~

for(i=0;i<pMatrix1->ArrayLen;i++) pMatrix3->Array[i]=pMatrix1->Array[i]*pMatrix2->Array[i];        //矩阵点乘: R( E( i! x# ]4 g! U

FunReObj(hFor);        //告诉Lu，返回一个动态对象 
  ^' [- \/ F! U) Z+ W( @
                a.BType=Matrix; a.VType=Matrix; a.x=0; *(luVOID *)&(a.x)=(luVOID)pMatrix3;+ z+ m- }% i4 K5 r$ b# e+ O

break; 
: ?0 [* D$ s% N& z* t
        case 46:        //重载函数new 
$ a* ~) c\\" Z, O; y$ p
                if(mm<2) break; 
+ R+ S8 D$ o9 _6 }5 Z
                if((xx+1)->x<1 || (xx+2)->x<1 || (xx+1)->BType!=luStaData_int64 || (xx+2)->BType!=luStaData_int64) break; 
6 |* m7 }0 F9 ?4 {& o9 X! X\\" \
                pMatrix3=NewMatrix((luVOID)(xx+1)->x,(luVOID)(xx+2)->x);//生成新矩阵/ Z- p  z3 S, B- `0 D6 W' v! ~

if(!pMatrix3) break;/ l- F6 k$ o7 _; C

for(j=0,i=3;i<=mm;i++,j++)        //赋初值4 L, p$ R3 a( `: z' g

{3 z* ~2 B( s% C

if(j>=pMatrix3->ArrayLen) break;: F( f; s! a$ }0 P5 D' h9 j4 I. n$ B

if((xx+i)->BType!=luStaData_double) break;        //只接受实数参数 
- @6 L* C6 c: L\\" t5 O, N
                        pMatrix3->Array[j]=*(double *)&((xx+i)->x); 
& w( @0 r1 l9 y# P$ N
                } 
/ U& a$ B( ^0 L3 X& [9 p
                FunReObj(hFor);        //告诉Lu，返回一个动态对象! K0 S  g! `1 q' g

a.BType=Matrix; a.VType=Matrix; a.x=0; *(luVOID *)&(a.x)=(luVOID)pMatrix3;, L' J. ]: V. k4 M' n

break; 
1 F! [0 x( L& r) a2 v* r\\" E, x
        case 49:        //重载函数o 
  [% \8 E' v) J0 S4 h
                pMessage=(luMessage)SearchKey("\0\0\0\0",sizeof(luVOID),luPubKey_User); 
; N  O; F! {8 m& p
                if(!pMessage) break;4 `3 X( Z/ g, W

pMatrix1=(myMatrix *)SearchKey((char *)&(xx->x),sizeof(luVOID),Matrix);6 T$ _/ m2 `& J( u! X

if(!pMatrix1) break;        //对象句柄无效，不是矩阵 
! x: L2 l5 f8 j3 j, T9 q
                pa=pMatrix1->Array;4 t% {, ?9 y, T7 `! z2 Q

m=pMatrix1->Dim[0]; n=pMatrix1->Dim[1]; k=0; 
8 l0 I\\" u, M8 ^* y
                for(i=0; i<m; i++)        //输出矩阵 
/ Q% X) N; x2 q* J
                { 
& _. }2 x: q! L5 P
                        pMessage(L"\r\n"); k+=2; 
# o. w/ X9 o4 f' a. m5 @
                        for(j=0; j<n; j++)! j( e# g3 {) K6 C) t

{  s$ a7 Q: I( @

_gcvt_s(chNum,pa[i*n+j],16); 
, N& |. F: k8 _\\" ^5 u; w2 w
                                for(u=0;chNum[u];u++) {wchNum[u]=chNum[u]; k++;}\\" p( {% a0 o: O1 p- {1 P

wchNum[u]='\0'; 
: ^$ X: \* Z4 v4 F/ k0 F: y; D
                                pMessage(wchNum); pMessage(L"  "); k+=2; 
7 v6 ?7 @4 H\\" P  Y& O1 U6 _( Q
                        } 
1 Y! Y/ x\\" o6 t  B9 Y2 l
                } 
+ Z! z% e! x* p3 w! ~8 C3 o
                pMessage(L"\r\n"); k+=2; 
0 T- L) a1 \8 `; i, W- X5 V2 S1 {
                a.BType=luStaData_int64; a.VType=luStaData_int64; a.x=k;        //按函数o的要求，返回输出的字符总数  B% n5 x( G- n; l, g

break; 
) c% F3 K0 y- z) e( T! x
        default: 
. b3 I( V( M; [# n0 A0 h3 ~
                break; 
& m! I9 f) w3 n6 ^; [5 s. O
        }3 ?  w5 {: \8 T

return a; 
. \0 t! |- C5 M+ k4 ]' e
}2 d4 b. W/ ^0 j

void main(void) 
* a- E) w; Q0 A& E' J! p
{ 
; O  p5 b\\" E2 g
        void *hFor;                //表达式句柄 
7 [; R# b. I4 A& C- X2 D. N
        luINT nPara;                //存放表达式的自变量个数 
+ V& J1 v% G7 c- p9 k7 n
        LuData *pPara;                //存放输入自变量的数组指针 
1 t- p/ F  H2 u$ r6 ?) ~+ Z; I
        luINT ErrBegin,ErrEnd;        //表达式编译出错的初始位置和结束位置4 p$ q  F7 y/ D! Z) E' d0 k1 s  A

int ErrCode;                //错误代码 
3 G3 i: \' \% L6 f
        void *v;$ }( F% D) @+ \; k: L& [

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.]}";//字符串表达式，矩阵乘* q: H, y) U) _) h7 G

//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.]}";//字符串表达式，矩阵点乘& B+ w7 y, v8 b4 v

LuData Val;, {5 `+ G5 Z\\" t# N( X

if(!InitLu()) return;        //初始化Lu 
4 q( l) B0 a; N& F  x2 R- ~* w
        while(LockKey(Matrix,DelMatrix,OpMatrix)){Matrix--;}        //锁定一个键，用于存储矩阵扩展类型7 u8 e. [9 {- @# y; }

6 U! z' F9 A1 o! J' F
        Val.BType=luStaData_int64; Val.VType=luStaData_int64; Val.x=Matrix;        //定义整数常量) {2 E\\" s; b: S* H2 w; n- l

SetConst(L"matrix",&Val);        //设置整数常量 
* o! Y% v8 ^5 u5 z- R2 e
        InsertKey("\0\0\0\0",4,luPubKey_User,LuMessage,NULL,NULL,1,v); //使Lu运行时可输出函数信息 
  v4 b0 B0 s1 W# m
        wcout.imbue(locale("chs"));        //设置输出的locale为中文4 k% p8 y% B' X2 k: d6 _/ Z+ `) l. l5 r

4 R5 E  y! S( v0 H) s
        ErrCode=LuCom(ForStr,0,0,0,hFor,nPara,pPara,ErrBegin,ErrEnd); //编译表达式\\" f8 v5 e. X# k& g

if(ErrCode) 
4 b5 M; S9 H' A  w8 P& f
        {4 D3 m3 u4 \  J5 Y: b/ g

wcout<<L"表达式有错误！错误代码："<<ErrCode<<endl;3 V8 S( q, g\\" S6 N\\" h/ L. g+ D

}5 T* e1 T; }) M& w6 O' O

else! U$ F9 g0 w  c# [- k9 w' B

{' m, y9 c, f& d4 t\\" }  P6 f

LuCal(hFor,pPara);        //计算表达式的值 
; A4 |5 a8 s& M6 U# v3 [! [
        } 
1 M( y, U5 L3 G+ I. B/ T0 g- l
        LockKey(Matrix,NULL,OpMatrix);//解锁键Matrix，本例中，该函数可以不用/ p1 E; i: ]* a8 d; ~

FreeLu();                        //释放Lu0 J% A& G: q3 j+ }

}

习题：

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

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

main(:a,b,c,d,t,i)=
# ^5 P W, N+ `& |: Y8 j' X
a=new[matrix,2,2: 1.,2.,2.,1.],5 O3 {\" `8 `. g3 Y( [( V
b=new[matrix,2,2: 2.,1.,1.,2.],0 c/ r9 @, r2 m
c=new[matrix,2,2: 2/3.,-1/3.,-1/3.,2/3.],4 p u) u0 n4 H3 K) t: d8 d6 T3 v. I
t=clock(),
\" p/ g! K8 |! d! z
d=a*b, i=0, while{i<1000000, d=d*c*b, i++},
3 A! A- b# P6 \: F) [+ j- R
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\"}";//字符串表达式

复制代码

结果：