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

查看: 8681|回复: 0

在Lu中创建自定义数据类型，小矩阵乘效率测试

[复制链接]

字体大小: 正常放大

forcal

45 主题	3 听众	282 积分

升级 91%

TA的每日心情

	难过 2012-8-27 18:22

签到天数: 1 天

[LV.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>+ I. b1 w- }. H* q; P
#include <iostream>
$ Q3 k7 | |6 q
#include <math.h>, `% W- @0 k# n; i( b3 T' A
#include "lu32.h"
' M- ~) c4 h0 t$ U
#pragma comment( lib, "lu32.lib" )( }/ R( T) X( s- K2 z
using namespace std;# }: Y0 C4 L# M: Z3 o! b+ u
//自定义矩阵* c- N) D6 X8 F, E
class myMatrix
0 ^) D0 a% k; [& H
{# \\\" F1 K0 `% E* `% Z6 W1 X5 y
public:
2 e( t' B\\" c4 d+ W
double *Array; //数据缓冲区
* Y. {; M: ]: Y
luVOID ArrayLen; //数据缓冲区长度
% |) U+ T; d# f8 j: m
luVOID Dim[2]; //矩阵维数* O' I ?4 I0 t+ x1 [4 N1 h8 s
myMatrix(){Array=NULL; ArrayLen=0; Dim[0]=0; Dim[1]=0;}
9 {! s2 }. O\\" H U) }7 o# Z
~myMatrix()4 G9 K5 F6 B* o0 R+ Y
{* e9 V& w$ h) W7 v. R- |
if(Array) delete[] Array;$ l\\" B- Q+ h) i8 W# c
}
9 |* M& z: Q9 T! `0 d/ m
};
4 F6 ?7 k% U# r1 K
luKEY Matrix=-1000; //标识矩阵类型，最终的Matrix由LockKey决定
; v* P! J! }+ o
void _stdcall LuMessage(wchar_t *pch)//输出动态库信息，该函数注册到Lu，由Lu二级函数调用
9 e: G& V. N& @; O$ E/ t& l& F) t
{
6 ~# e+ \' l8 T3 R
wcout<<pch;
- p+ |+ f3 M4 _' F' b% C5 ]( ~. A! R
}
0 ]0 p# c& b: F: s. b/ ]' S. L+ z
void _stdcall DelMatrix(void *me) //用于LockKey函数及InsertKey函数，使Lu能自动销毁myMatrix对象* ^- ?, r3 D) Q4 O! G4 A1 m
{2 `$ l; e4 z- M\\" o
delete (myMatrix *)me;
. r4 i+ g* [6 h5 C
}$ r: P, k\\" r& |- Y) S; X
myMatrix * _stdcall NewMatrix(luVOID m,luVOID n) //生成一个myMatrix对象\\" w/ [* f. R+ w\\" S9 ]6 I1 k
{3 w2 j \\\" p5 D
myMatrix *pMatrix;$ H7 s1 @) A Y x
luVOID k;, _0 X3 o: X5 i' D4 n
double *pa;) G- y5 @/ m4 g. C/ C7 N% q
char keyname[sizeof(luVOID)];; C- J. F5 [7 S
void *NowKey;
( B* a& M% }- G( P' I
k=m*n;
& q3 ~' Y5 v7 V, B4 I3 }
pMatrix=(myMatrix *)GetBufObj(Matrix,keyname);//先尝试从缓冲区中获取一个矩阵对象 F1 d* U8 D2 ~, J
if(pMatrix) ~1 V2 F4 r! V* x; R
{
. _9 t9 t8 n! l3 g
if(pMatrix->ArrayLen!=k) //重置矩阵的大小+ T8 w$ v, F4 n/ g7 X
{' }, w/ {$ C5 q5 B/ ^4 _) a
pa=new double[k];0 w9 k, b3 K8 K+ a\\" \% x7 t
if(!pa)
$ Z+ k3 m' e- S& b
{
8 h9 h0 v9 P9 Z- A: P\\" b
DeleteKey(keyname,sizeof(luVOID),Matrix,DelMatrix,1); //将矩阵对象放回缓冲区
* h* v M0 b F& |
return NULL;
: q) B' v: U4 O! R. R
}& z1 m/ i! y\\" q) Q
delete[] pMatrix->Array;' f( _: o\\" t3 K1 c4 r( y& p
pMatrix->Array=pa;
: M$ W$ q5 Q6 q/ S; o& c; a6 A
}6 m+ s3 K+ B\\" i8 W* j
}1 A! l u& e. o2 Y ^, g4 I
else' Z. N/ |4 d* F+ C
{+ T( i: b\\" D3 M
pMatrix=new myMatrix; //创建矩阵对象# @6 q2 D3 I9 m* Y6 f2 N& j
if(!pMatrix) return NULL;
$ k4 D$ U6 a* Z+ [% S1 w
pMatrix->Array=new double[k];) g @0 B- }6 ?, B# S' n
if(!pMatrix->Array)\\" @+ \# b- m/ Y\\" C: g
{+ N$ S) @' R8 u5 o/ m$ H
delete pMatrix;
. j* ^! \8 }$ t8 }
return NULL;* ?/ n# D* L) k( a: s! a' _$ m
}$ [3 t5 `\\" {5 k7 O6 E% T2 _9 G
if(InsertKey((char *)&pMatrix,-1,Matrix,pMatrix,DelMatrix,NULL,0,NowKey)) //将矩阵对象注册到Lu& G/ x; V$ Y1 V
{. J& J$ p2 ?8 M- ^
delete pMatrix;
7 N& }) @+ U7 M2 i; m
return NULL;3 C7 e# W r& a3 B\\" Y
}4 q( m# C) x6 {* y' Z( L
}
/ m0 M, y% `) \$ n
pMatrix->ArrayLen=k; pMatrix->Dim[0]=m; pMatrix->Dim[1]=n;
( ?7 W$ ]- z: _! w
return pMatrix;
: O6 R8 G5 t. N4 H5 j
}
4 O( a' s2 q) N: P6 l& Q# V
LuData _stdcall OpMatrix(luINT mm,LuData *xx,void *hFor,int theOperator) //运算符重载函数，用于LockKey函数, e* d. [3 w/ j4 S! \
{
3 h7 t! ?$ R% ^' p
LuData a;
: [4 b: Z% U8 X
myMatrix *pMatrix1,*pMatrix2,*pMatrix3;
% R5 b7 G' k8 C5 b: N: I) x
luVOID i,j,k,m,n,u,v;/ y4 Y/ r6 ], o6 a
double *pa,*pb,*pc; D3 n- \+ U9 f
luMessage pMessage;2 u5 F) {5 N. ?! V1 l
wchar_t wchNum[32];# V) M# x9 |7 Y ^+ ]8 I& G
char chNum[32];5 [) l& y2 E: e* m8 v
a.BType=luStaData_nil; a.VType=luStaData_nil; a.x=0;
) L\\" r; a t' X. e* Q! K- n* a
switch(theOperator)- u: r! o7 I J3 W- G
{
$ B& L9 W\\" Y3 I9 y
case 2: //重载运算符*
* ]( X. L# B. T9 {0 K5 }& ]8 C5 r( o
pMatrix1=(myMatrix *)SearchKey((char *)&(xx->x),sizeof(luVOID),Matrix);5 L' k7 ]% {- {; E: p- h
pMatrix2=(myMatrix *)SearchKey((char *)&((xx+1)->x),sizeof(luVOID),Matrix);: X\\" q+ e- s, D
if(!pMatrix1 || !pMatrix2) break; //对象句柄无效，不是矩阵
5 j$ ^' J7 A0 J, _% e/ Y
if(pMatrix1->Dim[1]!=pMatrix2->Dim[0]) break; //维数不匹配) M8 W, I, f& M+ D* f
pMatrix3=NewMatrix(pMatrix1->Dim[0],pMatrix2->Dim[1]); //生成新矩阵
* U! V2 K' b3 R$ q5 m9 P
if(!pMatrix3) break;
% R+ I* v/ c& p; }$ L# i
pa=pMatrix1->Array; pb=pMatrix2->Array; pc=pMatrix3->Array; N( E/ u9 T. `) Q
m=pMatrix1->Dim[0]; n=pMatrix1->Dim[1]; k=pMatrix2->Dim[1];2 \- \. U1 Y( a& Z* T
for(i=0; i<m; i++) //矩阵乘
, s& a0 w. I& A) @$ G! D
{3 x$ T7 d9 x1 e; u
for(j=0; j<k; j++)
2 U; h* s- w O. D9 R
{
f& R# T1 b- g6 ]+ f; _
u=i*k+j; pc[u]=0.0;9 r) F1 b7 [. I' ^8 M8 s0 q
for (v=0; v<n; v++)$ z\\" g3 J5 v4 Y* p! R2 E
{
A4 ]* a5 g# _$ ]
pc[u]=pc[u]+pa[i*n+v]*pb[v*k+j];1 W' {- K* q. V8 W I- ]4 r5 `
}4 B$ @% S P' V! P+ ^. P, S
}
) l# w\\" X, P$ D+ o- M( {; R6 g m
}! @9 a7 y \1 X/ B N. Z% S7 L# q. U2 C
FunReObj(hFor); //告诉Lu，返回一个动态对象
9 I3 W( L- m1 R7 v
a.BType=Matrix; a.VType=Matrix; a.x=0; *(luVOID *)&(a.x)=(luVOID)pMatrix3;
4 U& ~9 k) Q% ?) ^
break;$ f b7 O6 L5 p' J
case 25: //重载运算符.*1 I4 f' U T9 x6 |
pMatrix1=(myMatrix *)SearchKey((char *)&(xx->x),sizeof(luVOID),Matrix);
: E, J( R% @8 c: z1 F* J( E% @
pMatrix2=(myMatrix *)SearchKey((char *)&((xx+1)->x),sizeof(luVOID),Matrix);
/ N: f3 ?$ h% P* i4 }
if(!pMatrix1 || !pMatrix2) break; //对象句柄无效，不是矩阵
Y$ l& v: x: b% R
if(pMatrix1->Dim[0]!=pMatrix2->Dim[0] || pMatrix1->Dim[1]!=pMatrix2->Dim[1]) break; //维数不相同& t% T% T0 U% H2 J5 }
pMatrix3=NewMatrix(pMatrix1->Dim[0],pMatrix1->Dim[1]); //生成新矩阵
1 d- G: ]- |0 ]& u8 }: s: X, u
if(!pMatrix3) break;0 e2 t, n+ q/ ]1 z# [5 p% _' q6 m
for(i=0;i<pMatrix1->ArrayLen;i++) pMatrix3->Array[i]=pMatrix1->Array[i]*pMatrix2->Array[i]; //矩阵点乘5 ~5 g+ L0 U, h( r- |7 z
FunReObj(hFor); //告诉Lu，返回一个动态对象
4 i0 B4 U/ ^- ?9 u5 I1 B# o3 ^4 g4 F
a.BType=Matrix; a.VType=Matrix; a.x=0; *(luVOID *)&(a.x)=(luVOID)pMatrix3;- Q4 b! F* X5 _; g6 A1 Y
break;+ z% a+ T6 e5 z
case 46: //重载函数new
! [/ K- a5 c$ V( I
if(mm<2) break;
if((xx+1)->x<1 || (xx+2)->x<1 || (xx+1)->BType!=luStaData_int64 || (xx+2)->BType!=luStaData_int64) break;
4 i, j2 |% a. }6 a1 N
pMatrix3=NewMatrix((luVOID)(xx+1)->x,(luVOID)(xx+2)->x);//生成新矩阵) Q( S: f) ]; ?5 g! d
if(!pMatrix3) break;6 p: M- f) J) N1 Y
for(j=0,i=3;i<=mm;i++,j++) //赋初值
5 P2 l( u0 X* S% G: b7 ^
{ J1 G: X9 o& `% O5 b
if(j>=pMatrix3->ArrayLen) break;
: q9 P& G o* ]4 X S) Y' m
if((xx+i)->BType!=luStaData_double) break; //只接受实数参数
6 Y6 Y7 a$ e! G( F1 P3 Q
pMatrix3->Array[j]=*(double *)&((xx+i)->x);# q3 e. b5 l# F2 Z\\" g2 Z$ D
}2 r* z9 s4 G' J9 m) { O7 I/ `' ~: x( o
FunReObj(hFor); //告诉Lu，返回一个动态对象% [% K* x6 O8 G: |8 r1 k$ W/ l3 ?
a.BType=Matrix; a.VType=Matrix; a.x=0; *(luVOID *)&(a.x)=(luVOID)pMatrix3;
3 [. C. `\\" v/ f. c* l; n
break;( V3 D: ]6 t _8 D; M% a
case 49: //重载函数o+ z& n/ j- Z2 K7 p2 S
pMessage=(luMessage)SearchKey("\0\0\0\0",sizeof(luVOID),luPubKey_User);
: d; D/ v- S. b1 ^- _
if(!pMessage) break;9 u; e; }\\" K m+ S, I# M3 O- M
pMatrix1=(myMatrix *)SearchKey((char *)&(xx->x),sizeof(luVOID),Matrix);- N5 r& \$ m. X! X' J7 ^
if(!pMatrix1) break; //对象句柄无效，不是矩阵
' p, y\\" `\\" n! p# B f5 s2 n
pa=pMatrix1->Array;: ~. l r8 I* u7 J$ W6 j
m=pMatrix1->Dim[0]; n=pMatrix1->Dim[1]; k=0; Q0 j9 f* `8 b- u# h) V0 K+ S
for(i=0; i<m; i++) //输出矩阵
- D3 X0 X/ h o9 }/ {) B
{( E# `2 `% I! W' e\\" I\\" g% C
pMessage(L"\r\n"); k+=2;
5 B2 w) F5 `6 G G/ r: p3 d' p
for(j=0; j<n; j++)( R/ Q n: n* t& b) H! C
{\\" E' ]. w4 R) a+ o ?) d
_gcvt_s(chNum,pa[i*n+j],16);
# K! ?+ A3 z( N/ ^
for(u=0;chNum[u];u++) {wchNum[u]=chNum[u]; k++;}( J/ t% H$ j( w- |
wchNum[u]='\0';# g$ L/ U5 |\\" Y& z4 N* v1 C5 y- I
pMessage(wchNum); pMessage(L" "); k+=2;; `, O! ~# G% \/ D0 Y* _
}$ t( T. ~' H* p9 y: `
}
! {3 u/ S+ m: f6 B1 _9 |9 P% Y
pMessage(L"\r\n"); k+=2;7 d) Y. i8 B, z. U$ ?
a.BType=luStaData_int64; a.VType=luStaData_int64; a.x=k; //按函数o的要求，返回输出的字符总数
( T7 ^6 K c+ e L5 _
break;
2 Y. Q) w- F. Y0 q. S
default:
* B- O9 r$ k# m, S( L
break;
! e2 F% d9 M. S1 a% i: \
}! T. ]. |8 R0 U& F
return a;
; n8 i8 G! {$ j& S' b* s5 E
}
) f\\" U- x+ O* D: S
void main(void)
) \ W$ c' n8 C; V8 \- T
{$ U6 x7 D' S. F- a' |/ t
void *hFor; //表达式句柄
9 j6 v9 |5 F) e$ H
luINT nPara; //存放表达式的自变量个数
. j\\" ?: {; E# A, E0 b0 }
LuData *pPara; //存放输入自变量的数组指针: r6 a! E$ ` F: m
luINT ErrBegin,ErrEnd; //表达式编译出错的初始位置和结束位置
( Y& A( | Y; ]4 l) F; u
int ErrCode; //错误代码+ V3 u' {* y* T% K3 I/ ]
void *v;: ]% a* C3 _( e
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.]}";//字符串表达式，矩阵乘1 f% C3 q6 u\\" M( \$ I2 r: v7 j
//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.]}";//字符串表达式，矩阵点乘
/ A0 Z* v# u2 H+ @+ A. t
LuData Val;
5 [3 _\\" s- a+ W# a( ]1 m( R
if(!InitLu()) return; //初始化Lu @$ u\\" v* N, J1 i1 C ]
while(LockKey(Matrix,DelMatrix,OpMatrix)){Matrix--;} //锁定一个键，用于存储矩阵扩展类型# a7 E t9 q; |5 I\\" ?
! A$ a! j- s1 A/ n
Val.BType=luStaData_int64; Val.VType=luStaData_int64; Val.x=Matrix; //定义整数常量
5 e; N5 @0 i( E- r3 w# D
SetConst(L"matrix",&Val); //设置整数常量
2 u, }& p) A% _! \
InsertKey("\0\0\0\0",4,luPubKey_User,LuMessage,NULL,NULL,1,v); //使Lu运行时可输出函数信息
/ ^& T% l4 S\\" `' j t
wcout.imbue(locale("chs")); //设置输出的locale为中文2 c4 C6 o% [! e
' O6 Q, z6 c* I3 a# R, U
ErrCode=LuCom(ForStr,0,0,0,hFor,nPara,pPara,ErrBegin,ErrEnd); //编译表达式% I: z; r, A* o; }6 @. z9 i3 f9 _ H
if(ErrCode)
- e D4 F$ Y) j& X- K2 b, F
{
* H9 |% ]! Y5 m- F2 R
wcout<<L"表达式有错误！错误代码："<<ErrCode<<endl;4 |) S\\" I W- z4 Q
}7 i8 M' d0 @5 v0 o. o
else
+ y- g. {+ j- \1 |
{
8 y- t, T. m9 Z4 W# C# H* c
LuCal(hFor,pPara); //计算表达式的值3 X# n7 d( w S9 L& ]/ @
}) m# X: z |- [+ y# g3 e
LockKey(Matrix,NULL,OpMatrix);//解锁键Matrix，本例中，该函数可以不用
( b, B: ^& U7 t+ l3 ~
FreeLu(); //释放Lu
- Y) i$ y% U% T X\\" ?. k8 X
}

#include <windows.h>+ I. b1 w- }. H* q; P

#include <iostream> 
$ Q3 k7 |  |6 q
#include <math.h>, `% W- @0 k# n; i( b3 T' A

#include "lu32.h" 
' M- ~) c4 h0 t$ U
#pragma comment( lib, "lu32.lib" )( }/ R( T) X( s- K2 z

using namespace std;# }: Y0 C4 L# M: Z3 o! b+ u

//自定义矩阵* c- N) D6 X8 F, E

class myMatrix 
0 ^) D0 a% k; [& H
{# \\\" F1 K0 `% E* `% Z6 W1 X5 y

public: 
2 e( t' B\\" c4 d+ W
        double *Array;        //数据缓冲区 
* Y. {; M: ]: Y
        luVOID ArrayLen;        //数据缓冲区长度 
% |) U+ T; d# f8 j: m
        luVOID Dim[2];        //矩阵维数* O' I  ?4 I0 t+ x1 [4 N1 h8 s

myMatrix(){Array=NULL; ArrayLen=0; Dim[0]=0; Dim[1]=0;} 
9 {! s2 }. O\\" H  U) }7 o# Z
        ~myMatrix()4 G9 K5 F6 B* o0 R+ Y

{* e9 V& w$ h) W7 v. R- |

if(Array) delete[] Array;$ l\\" B- Q+ h) i8 W# c

} 
9 |* M& z: Q9 T! `0 d/ m
}; 
4 F6 ?7 k% U# r1 K
luKEY Matrix=-1000;        //标识矩阵类型，最终的Matrix由LockKey决定 
; v* P! J! }+ o
void _stdcall LuMessage(wchar_t *pch)//输出动态库信息，该函数注册到Lu，由Lu二级函数调用 
9 e: G& V. N& @; O$ E/ t& l& F) t
{ 
6 ~# e+ \' l8 T3 R
        wcout<<pch; 
- p+ |+ f3 M4 _' F' b% C5 ]( ~. A! R
} 
0 ]0 p# c& b: F: s. b/ ]' S. L+ z
void _stdcall DelMatrix(void *me)        //用于LockKey函数及InsertKey函数，使Lu能自动销毁myMatrix对象* ^- ?, r3 D) Q4 O! G4 A1 m

{2 `$ l; e4 z- M\\" o

delete (myMatrix *)me; 
. r4 i+ g* [6 h5 C
}$ r: P, k\\" r& |- Y) S; X

myMatrix * _stdcall NewMatrix(luVOID m,luVOID n)        //生成一个myMatrix对象\\" w/ [* f. R+ w\\" S9 ]6 I1 k

{3 w2 j  \\\" p5 D

myMatrix *pMatrix;$ H7 s1 @) A  Y  x

luVOID k;, _0 X3 o: X5 i' D4 n

double *pa;) G- y5 @/ m4 g. C/ C7 N% q

char keyname[sizeof(luVOID)];; C- J. F5 [7 S

void *NowKey; 
( B* a& M% }- G( P' I
        k=m*n; 
& q3 ~' Y5 v7 V, B4 I3 }
        pMatrix=(myMatrix *)GetBufObj(Matrix,keyname);//先尝试从缓冲区中获取一个矩阵对象  F1 d* U8 D2 ~, J

if(pMatrix)  ~1 V2 F4 r! V* x; R

{ 
. _9 t9 t8 n! l3 g
                if(pMatrix->ArrayLen!=k)        //重置矩阵的大小+ T8 w$ v, F4 n/ g7 X

{' }, w/ {$ C5 q5 B/ ^4 _) a

pa=new double[k];0 w9 k, b3 K8 K+ a\\" \% x7 t

if(!pa) 
$ Z+ k3 m' e- S& b
                        { 
8 h9 h0 v9 P9 Z- A: P\\" b
                                DeleteKey(keyname,sizeof(luVOID),Matrix,DelMatrix,1);        //将矩阵对象放回缓冲区 
* h* v  M0 b  F& |
                                return NULL; 
: q) B' v: U4 O! R. R
                        }& z1 m/ i! y\\" q) Q

delete[] pMatrix->Array;' f( _: o\\" t3 K1 c4 r( y& p

pMatrix->Array=pa; 
: M$ W$ q5 Q6 q/ S; o& c; a6 A
                }6 m+ s3 K+ B\\" i8 W* j

}1 A! l  u& e. o2 Y  ^, g4 I

else' Z. N/ |4 d* F+ C

{+ T( i: b\\" D3 M

pMatrix=new myMatrix;        //创建矩阵对象# @6 q2 D3 I9 m* Y6 f2 N& j

if(!pMatrix) return NULL; 
$ k4 D$ U6 a* Z+ [% S1 w
                pMatrix->Array=new double[k];) g  @0 B- }6 ?, B# S' n

if(!pMatrix->Array)\\" @+ \# b- m/ Y\\" C: g

{+ N$ S) @' R8 u5 o/ m$ H

delete pMatrix; 
. j* ^! \8 }$ t8 }
                        return NULL;* ?/ n# D* L) k( a: s! a' _$ m

}$ [3 t5 `\\" {5 k7 O6 E% T2 _9 G

if(InsertKey((char *)&pMatrix,-1,Matrix,pMatrix,DelMatrix,NULL,0,NowKey))        //将矩阵对象注册到Lu& G/ x; V$ Y1 V

{. J& J$ p2 ?8 M- ^

delete pMatrix; 
7 N& }) @+ U7 M2 i; m
                        return NULL;3 C7 e# W  r& a3 B\\" Y

}4 q( m# C) x6 {* y' Z( L

} 
/ m0 M, y% `) \$ n
        pMatrix->ArrayLen=k; pMatrix->Dim[0]=m; pMatrix->Dim[1]=n; 
( ?7 W$ ]- z: _! w
        return pMatrix; 
: O6 R8 G5 t. N4 H5 j
} 
4 O( a' s2 q) N: P6 l& Q# V
LuData _stdcall OpMatrix(luINT mm,LuData *xx,void *hFor,int theOperator)        //运算符重载函数，用于LockKey函数, e* d. [3 w/ j4 S! \

{ 
3 h7 t! ?$ R% ^' p
        LuData a; 
: [4 b: Z% U8 X
        myMatrix *pMatrix1,*pMatrix2,*pMatrix3; 
% R5 b7 G' k8 C5 b: N: I) x
        luVOID i,j,k,m,n,u,v;/ y4 Y/ r6 ], o6 a

double *pa,*pb,*pc;  D3 n- \+ U9 f

luMessage pMessage;2 u5 F) {5 N. ?! V1 l

wchar_t wchNum[32];# V) M# x9 |7 Y  ^+ ]8 I& G

char chNum[32];5 [) l& y2 E: e* m8 v

a.BType=luStaData_nil; a.VType=luStaData_nil; a.x=0; 
) L\\" r; a  t' X. e* Q! K- n* a
        switch(theOperator)- u: r! o7 I  J3 W- G

{ 
$ B& L9 W\\" Y3 I9 y
        case 2:        //重载运算符* 
* ]( X. L# B. T9 {0 K5 }& ]8 C5 r( o
                pMatrix1=(myMatrix *)SearchKey((char *)&(xx->x),sizeof(luVOID),Matrix);5 L' k7 ]% {- {; E: p- h

pMatrix2=(myMatrix *)SearchKey((char *)&((xx+1)->x),sizeof(luVOID),Matrix);: X\\" q+ e- s, D

if(!pMatrix1 || !pMatrix2) break;        //对象句柄无效，不是矩阵 
5 j$ ^' J7 A0 J, _% e/ Y
                if(pMatrix1->Dim[1]!=pMatrix2->Dim[0]) break;        //维数不匹配) M8 W, I, f& M+ D* f

pMatrix3=NewMatrix(pMatrix1->Dim[0],pMatrix2->Dim[1]);        //生成新矩阵 
* U! V2 K' b3 R$ q5 m9 P
                if(!pMatrix3) break; 
% R+ I* v/ c& p; }$ L# i
                pa=pMatrix1->Array; pb=pMatrix2->Array; pc=pMatrix3->Array;  N( E/ u9 T. `) Q

m=pMatrix1->Dim[0]; n=pMatrix1->Dim[1]; k=pMatrix2->Dim[1];2 \- \. U1 Y( a& Z* T

for(i=0; i<m; i++)        //矩阵乘 
, s& a0 w. I& A) @$ G! D
                {3 x$ T7 d9 x1 e; u

for(j=0; j<k; j++) 
2 U; h* s- w  O. D9 R
                        { 
  f& R# T1 b- g6 ]+ f; _
                                u=i*k+j; pc[u]=0.0;9 r) F1 b7 [. I' ^8 M8 s0 q

for (v=0; v<n; v++)$ z\\" g3 J5 v4 Y* p! R2 E

{ 
  A4 ]* a5 g# _$ ]
                                        pc[u]=pc[u]+pa[i*n+v]*pb[v*k+j];1 W' {- K* q. V8 W  I- ]4 r5 `

}4 B$ @% S  P' V! P+ ^. P, S

} 
) l# w\\" X, P$ D+ o- M( {; R6 g  m
                }! @9 a7 y  \1 X/ B  N. Z% S7 L# q. U2 C

FunReObj(hFor);        //告诉Lu，返回一个动态对象 
9 I3 W( L- m1 R7 v
                a.BType=Matrix; a.VType=Matrix; a.x=0; *(luVOID *)&(a.x)=(luVOID)pMatrix3; 
4 U& ~9 k) Q% ?) ^
                break;$ f  b7 O6 L5 p' J

case 25:        //重载运算符.*1 I4 f' U  T9 x6 |

pMatrix1=(myMatrix *)SearchKey((char *)&(xx->x),sizeof(luVOID),Matrix); 
: E, J( R% @8 c: z1 F* J( E% @
                pMatrix2=(myMatrix *)SearchKey((char *)&((xx+1)->x),sizeof(luVOID),Matrix); 
/ N: f3 ?$ h% P* i4 }
                if(!pMatrix1 || !pMatrix2) break;        //对象句柄无效，不是矩阵 
  Y$ l& v: x: b% R
                if(pMatrix1->Dim[0]!=pMatrix2->Dim[0] || pMatrix1->Dim[1]!=pMatrix2->Dim[1]) break;        //维数不相同& t% T% T0 U% H2 J5 }

pMatrix3=NewMatrix(pMatrix1->Dim[0],pMatrix1->Dim[1]);        //生成新矩阵 
1 d- G: ]- |0 ]& u8 }: s: X, u
                if(!pMatrix3) break;0 e2 t, n+ q/ ]1 z# [5 p% _' q6 m

for(i=0;i<pMatrix1->ArrayLen;i++) pMatrix3->Array[i]=pMatrix1->Array[i]*pMatrix2->Array[i];        //矩阵点乘5 ~5 g+ L0 U, h( r- |7 z

FunReObj(hFor);        //告诉Lu，返回一个动态对象 
4 i0 B4 U/ ^- ?9 u5 I1 B# o3 ^4 g4 F
                a.BType=Matrix; a.VType=Matrix; a.x=0; *(luVOID *)&(a.x)=(luVOID)pMatrix3;- Q4 b! F* X5 _; g6 A1 Y

break;+ z% a+ T6 e5 z

case 46:        //重载函数new 
! [/ K- a5 c$ V( I
                if(mm<2) break; 
* T: m( j5 T, s: {  Z* M, g1 ~5 ?  g
                if((xx+1)->x<1 || (xx+2)->x<1 || (xx+1)->BType!=luStaData_int64 || (xx+2)->BType!=luStaData_int64) break; 
4 i, j2 |% a. }6 a1 N
                pMatrix3=NewMatrix((luVOID)(xx+1)->x,(luVOID)(xx+2)->x);//生成新矩阵) Q( S: f) ]; ?5 g! d

if(!pMatrix3) break;6 p: M- f) J) N1 Y

for(j=0,i=3;i<=mm;i++,j++)        //赋初值 
5 P2 l( u0 X* S% G: b7 ^
                {  J1 G: X9 o& `% O5 b

if(j>=pMatrix3->ArrayLen) break; 
: q9 P& G  o* ]4 X  S) Y' m
                        if((xx+i)->BType!=luStaData_double) break;        //只接受实数参数 
6 Y6 Y7 a$ e! G( F1 P3 Q
                        pMatrix3->Array[j]=*(double *)&((xx+i)->x);# q3 e. b5 l# F2 Z\\" g2 Z$ D

}2 r* z9 s4 G' J9 m) {  O7 I/ `' ~: x( o

FunReObj(hFor);        //告诉Lu，返回一个动态对象% [% K* x6 O8 G: |8 r1 k$ W/ l3 ?

a.BType=Matrix; a.VType=Matrix; a.x=0; *(luVOID *)&(a.x)=(luVOID)pMatrix3; 
3 [. C. `\\" v/ f. c* l; n
                break;( V3 D: ]6 t  _8 D; M% a

case 49:        //重载函数o+ z& n/ j- Z2 K7 p2 S

pMessage=(luMessage)SearchKey("\0\0\0\0",sizeof(luVOID),luPubKey_User); 
: d; D/ v- S. b1 ^- _
                if(!pMessage) break;9 u; e; }\\" K  m+ S, I# M3 O- M

pMatrix1=(myMatrix *)SearchKey((char *)&(xx->x),sizeof(luVOID),Matrix);- N5 r& \$ m. X! X' J7 ^

if(!pMatrix1) break;        //对象句柄无效，不是矩阵 
' p, y\\" `\\" n! p# B  f5 s2 n
                pa=pMatrix1->Array;: ~. l  r8 I* u7 J$ W6 j

m=pMatrix1->Dim[0]; n=pMatrix1->Dim[1]; k=0;  Q0 j9 f* `8 b- u# h) V0 K+ S

for(i=0; i<m; i++)        //输出矩阵 
- D3 X0 X/ h  o9 }/ {) B
                {( E# `2 `% I! W' e\\" I\\" g% C

pMessage(L"\r\n"); k+=2; 
5 B2 w) F5 `6 G  G/ r: p3 d' p
                        for(j=0; j<n; j++)( R/ Q  n: n* t& b) H! C

{\\" E' ]. w4 R) a+ o  ?) d

_gcvt_s(chNum,pa[i*n+j],16); 
# K! ?+ A3 z( N/ ^
                                for(u=0;chNum[u];u++) {wchNum[u]=chNum[u]; k++;}( J/ t% H$ j( w- |

wchNum[u]='\0';# g$ L/ U5 |\\" Y& z4 N* v1 C5 y- I

pMessage(wchNum); pMessage(L"  "); k+=2;; `, O! ~# G% \/ D0 Y* _

}$ t( T. ~' H* p9 y: `

} 
! {3 u/ S+ m: f6 B1 _9 |9 P% Y
                pMessage(L"\r\n"); k+=2;7 d) Y. i8 B, z. U$ ?

a.BType=luStaData_int64; a.VType=luStaData_int64; a.x=k;        //按函数o的要求，返回输出的字符总数 
( T7 ^6 K  c+ e  L5 _
                break; 
2 Y. Q) w- F. Y0 q. S
        default: 
* B- O9 r$ k# m, S( L
                break; 
! e2 F% d9 M. S1 a% i: \
        }! T. ]. |8 R0 U& F

return a; 
; n8 i8 G! {$ j& S' b* s5 E
} 
) f\\" U- x+ O* D: S
void main(void) 
) \  W$ c' n8 C; V8 \- T
{$ U6 x7 D' S. F- a' |/ t

void *hFor;                //表达式句柄 
9 j6 v9 |5 F) e$ H
        luINT nPara;                //存放表达式的自变量个数 
. j\\" ?: {; E# A, E0 b0 }
        LuData *pPara;                //存放输入自变量的数组指针: r6 a! E$ `  F: m

luINT ErrBegin,ErrEnd;        //表达式编译出错的初始位置和结束位置 
( Y& A( |  Y; ]4 l) F; u
        int ErrCode;                //错误代码+ V3 u' {* y* T% K3 I/ ]

void *v;: ]% a* C3 _( e

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.]}";//字符串表达式，矩阵乘1 f% C3 q6 u\\" M( \$ I2 r: v7 j

//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.]}";//字符串表达式，矩阵点乘 
/ A0 Z* v# u2 H+ @+ A. t
        LuData Val; 
5 [3 _\\" s- a+ W# a( ]1 m( R
        if(!InitLu()) return;        //初始化Lu  @$ u\\" v* N, J1 i1 C  ]

while(LockKey(Matrix,DelMatrix,OpMatrix)){Matrix--;}        //锁定一个键，用于存储矩阵扩展类型# a7 E  t9 q; |5 I\\" ?

! A$ a! j- s1 A/ n
        Val.BType=luStaData_int64; Val.VType=luStaData_int64; Val.x=Matrix;        //定义整数常量 
5 e; N5 @0 i( E- r3 w# D
        SetConst(L"matrix",&Val);        //设置整数常量 
2 u, }& p) A% _! \
        InsertKey("\0\0\0\0",4,luPubKey_User,LuMessage,NULL,NULL,1,v); //使Lu运行时可输出函数信息 
/ ^& T% l4 S\\" `' j  t
        wcout.imbue(locale("chs"));        //设置输出的locale为中文2 c4 C6 o% [! e

' O6 Q, z6 c* I3 a# R, U
        ErrCode=LuCom(ForStr,0,0,0,hFor,nPara,pPara,ErrBegin,ErrEnd); //编译表达式% I: z; r, A* o; }6 @. z9 i3 f9 _  H

if(ErrCode) 
- e  D4 F$ Y) j& X- K2 b, F
        { 
* H9 |% ]! Y5 m- F2 R
                wcout<<L"表达式有错误！错误代码："<<ErrCode<<endl;4 |) S\\" I  W- z4 Q

}7 i8 M' d0 @5 v0 o. o

else 
+ y- g. {+ j- \1 |
        { 
8 y- t, T. m9 Z4 W# C# H* c
                LuCal(hFor,pPara);        //计算表达式的值3 X# n7 d( w  S9 L& ]/ @

}) m# X: z  |- [+ y# g3 e

LockKey(Matrix,NULL,OpMatrix);//解锁键Matrix，本例中，该函数可以不用 
( b, B: ^& U7 t+ l3 ~
        FreeLu();                        //释放Lu 
- Y) i$ y% U% T  X\\" ?. k8 X
}

习题：

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

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

main(:a,b,c,d,t,i)=
1 C; }# x/ A8 Y1 M8 K
a=new[matrix,2,2: 1.,2.,2.,1.],
7 a; e0 N8 u+ G
b=new[matrix,2,2: 2.,1.,1.,2.],
$ @, _8 v* O# G6 e: f$ r, X
c=new[matrix,2,2: 2/3.,-1/3.,-1/3.,2/3.],
& }7 _% W+ W4 ^, i
t=clock(),4 M+ v) \1 H' _4 { z& V/ W
d=a*b, i=0, while{i<1000000, d=d*c*b, i++},
6 a$ P. R1 R% F$ n6 Z/ S
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\"}";//字符串表达式

复制代码

结果：