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

查看: 8680|回复: 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>
1 t, H/ E8 O& b\\" j! F
#include <iostream>
' {- C! ~* c F. Z+ a
#include <math.h>( q v, _% N: W+ c- D
#include "lu32.h": j& x4 N- {) W* B
#pragma comment( lib, "lu32.lib" )# ^ o- c. q& x |) X) a) b
using namespace std;
6 d \6 z1 q0 |. I
//自定义矩阵, K4 a/ S/ V9 ~% {. o5 I8 k
class myMatrix
' w6 s3 Z2 \8 `2 ~& h/ I* `
{; r8 B8 f9 B, E, Q\\" `: `# s
public:& u }# l9 n\\" H& {5 H4 d& U
double *Array; //数据缓冲区1 Q% E# k! Y- H. P
luVOID ArrayLen; //数据缓冲区长度
; \\\" D& D3 p5 g0 F( R# y A3 E6 c
luVOID Dim[2]; //矩阵维数0 q) w, W0 z( I0 \1 S8 D6 V\\" i
myMatrix(){Array=NULL; ArrayLen=0; Dim[0]=0; Dim[1]=0;}9 C( I& N1 Y% Z7 q
~myMatrix()
6 j9 O\\" {0 j* F$ G; Z* R
{
& z3 l$ U: z+ s3 l' M
if(Array) delete[] Array;
/ P# `7 ~# m# f z9 A! l
}/ P# p\\" e7 o8 K
};# l% t4 Y0 F6 _. ~) r/ O
luKEY Matrix=-1000; //标识矩阵类型，最终的Matrix由LockKey决定\\" z! q- x/ R; }5 [0 A3 G6 N) [
void _stdcall LuMessage(wchar_t *pch)//输出动态库信息，该函数注册到Lu，由Lu二级函数调用
8 Q9 f% v2 B4 H. s a# O6 l# J
{
, ~\\" E5 F) J, u. m; x* s. k* ~
wcout<<pch;
' X. h: R9 c$ F\\" }4 u
}/ X( [* K) w C$ G
void _stdcall DelMatrix(void *me) //用于LockKey函数及InsertKey函数，使Lu能自动销毁myMatrix对象. c1 H9 c7 H1 Q n; Z3 `+ r
{! f/ U- H% y2 K! a8 o; U8 I
delete (myMatrix *)me;
9 P/ a. [3 k3 k( V* x
}% d! n, [8 G/ j5 E
myMatrix * _stdcall NewMatrix(luVOID m,luVOID n) //生成一个myMatrix对象+ n. v9 P) O8 c6 b' |: @
{1 ^9 m3 l* w) v. L, ]) c: m
myMatrix *pMatrix;, s7 x' \- D% F5 d+ z& ~
luVOID k;
8 ~8 O# Z6 i- U8 l; T# [6 o
double *pa;
: U$ _ ^- \8 d( g7 l' u
char keyname[sizeof(luVOID)];
6 p$ q( I z- t/ _$ T
void *NowKey;; D5 W% J. E5 c9 d
k=m*n;* T0 M4 F1 u- D- E+ s) M& R
pMatrix=(myMatrix *)GetBufObj(Matrix,keyname);//先尝试从缓冲区中获取一个矩阵对象
\\" `: N) C4 n$ g7 ?
if(pMatrix)8 k/ H6 H9 `+ n; ?4 d9 e1 d
{
/ Z. b$ H) y& h- S0 | Z
if(pMatrix->ArrayLen!=k) //重置矩阵的大小
3 y t* g u. G% J
{
: j5 e5 W' f, W4 ]1 C+ z! t
pa=new double[k];# q- G, a2 ~) ~; Z
if(!pa)2 ?+ f\\" a& M- |) q
{% H u3 w* E7 A; y
DeleteKey(keyname,sizeof(luVOID),Matrix,DelMatrix,1); //将矩阵对象放回缓冲区* T3 C' H4 i* I( j- _7 h/ g
return NULL;& w# \\\" x2 O' b
}
6 u8 m8 T% D6 |3 e
delete[] pMatrix->Array; X* x, ^7 x# g
pMatrix->Array=pa;: r# o' `# s( f0 U7 \* h- \/ o
}
9 {) s! \- I4 u. d& G- F
}
: l& S& e0 a1 a0 s6 }1 z
else\\" q. R& ~6 l1 Q# o( k
{+ q: m0 m2 M9 ~ B M e7 C
pMatrix=new myMatrix; //创建矩阵对象
W8 x2 ^0 u& x0 n3 S
if(!pMatrix) return NULL;
; r2 \6 B5 f. r8 }5 y
pMatrix->Array=new double[k];
3 {! [) C2 u, l
if(!pMatrix->Array)
7 ^( r4 N3 O: U3 n. z1 [2 T6 v% a
{
+ P6 T- {7 u2 B ]+ Q
delete pMatrix;# n+ o. W: F2 b, j8 v. C, Z) ?
return NULL;
* U\\" s2 G# X, U8 A0 I5 H: i
}& j) h, G; T7 f. s5 ^1 M5 Y
if(InsertKey((char *)&pMatrix,-1,Matrix,pMatrix,DelMatrix,NULL,0,NowKey)) //将矩阵对象注册到Lu
\\" ~6 K+ `0 U$ \, G% t* I) L$ l
{- B7 {4 v3 R; d
delete pMatrix;
# a; s$ p, N+ y# g- c1 [
return NULL;
0 @/ I5 ^- Z. f6 T1 I# t% C7 N
}
! A4 O! a- U0 C6 T! H
}
: Q. y9 D6 t; @; q! ^: q
pMatrix->ArrayLen=k; pMatrix->Dim[0]=m; pMatrix->Dim[1]=n;5 f( n7 x7 C1 [( \. b, W
return pMatrix;
2 `+ h& w8 p) e3 ^) p: Y r
}: p/ E: L2 F W2 y# R/ |
LuData _stdcall OpMatrix(luINT mm,LuData *xx,void *hFor,int theOperator) //运算符重载函数，用于LockKey函数
6 C' C# G: E2 G2 k
{
* }/ a! b: v' Z9 G) h _5 F
LuData a;
& t3 h3 o3 S- M\\" N
myMatrix *pMatrix1,*pMatrix2,*pMatrix3;
, V6 g4 o: [7 C! E' C
luVOID i,j,k,m,n,u,v;
2 _' x6 f' a$ o\\" u; u: i
double *pa,*pb,*pc;3 q n8 `. i' X0 e
luMessage pMessage;* I4 P/ t/ Y T+ X. V' H
wchar_t wchNum[32];6 U j& ^3 Z' c7 a& K! U. }
char chNum[32]; N( v. ]/ x( q9 w' Q
a.BType=luStaData_nil; a.VType=luStaData_nil; a.x=0;1 V: Y J& z8 j9 U' F; \
switch(theOperator)8 S. n' I/ v# n0 E! u7 Y9 Q! \
{/ _- s( ^* H$ i& f q
case 2: //重载运算符*7 x3 h# T# z7 |/ c
pMatrix1=(myMatrix *)SearchKey((char *)&(xx->x),sizeof(luVOID),Matrix);
% l8 ]$ y+ m( r: m
pMatrix2=(myMatrix *)SearchKey((char *)&((xx+1)->x),sizeof(luVOID),Matrix);9 W: m( V1 F- y4 C& Z+ k
if(!pMatrix1 || !pMatrix2) break; //对象句柄无效，不是矩阵8 p( T, I( @+ a+ R
if(pMatrix1->Dim[1]!=pMatrix2->Dim[0]) break; //维数不匹配
4 u/ Z9 [\\" X( |\\" F a
pMatrix3=NewMatrix(pMatrix1->Dim[0],pMatrix2->Dim[1]); //生成新矩阵; L; O- H6 R+ y1 O5 E, _
if(!pMatrix3) break;- k6 j1 e, x, e9 X! m2 T4 S2 l
pa=pMatrix1->Array; pb=pMatrix2->Array; pc=pMatrix3->Array;
7 a+ n' p2 G, |9 x; _% `
m=pMatrix1->Dim[0]; n=pMatrix1->Dim[1]; k=pMatrix2->Dim[1];
4 g* |& h& r& n6 A X6 p% L) M
for(i=0; i<m; i++) //矩阵乘7 f4 q; T- i/ `! l# {
{3 Z' S2 f! a7 k1 [
for(j=0; j<k; j++)
- y' M Y: a# @- r$ M. d9 i
{7 v2 k- Y: }/ Q2 f, S0 f\\" a
u=i*k+j; pc[u]=0.0;
. `5 q\\" V' s+ T0 `\\" u
for (v=0; v<n; v++)$ [& s* S) G! u# I
{
0 a G' d; X3 k9 ~
pc[u]=pc[u]+pa[i*n+v]*pb[v*k+j];
$ k6 |& P$ T- j
}\\" o' ^# x; G( N6 x4 g
}1 s& j& n0 B6 [/ l1 N
}
) x4 N% s _# R, _. s: S2 W
FunReObj(hFor); //告诉Lu，返回一个动态对象1 R4 c8 C; O6 o) Y; I
a.BType=Matrix; a.VType=Matrix; a.x=0; *(luVOID *)&(a.x)=(luVOID)pMatrix3;
9 N) W: k; f) j
break;
' b! z) d; P# X7 \+ Q
case 25: //重载运算符.*
4 u+ M\\" q5 x$ r' m1 \( D
pMatrix1=(myMatrix *)SearchKey((char *)&(xx->x),sizeof(luVOID),Matrix);
$ O9 ~# l2 y( q% s* F* ~2 h
pMatrix2=(myMatrix *)SearchKey((char *)&((xx+1)->x),sizeof(luVOID),Matrix);
% o5 V5 b# V+ I
if(!pMatrix1 || !pMatrix2) break; //对象句柄无效，不是矩阵% S\\" m+ |# l' W7 M! ?
if(pMatrix1->Dim[0]!=pMatrix2->Dim[0] || pMatrix1->Dim[1]!=pMatrix2->Dim[1]) break; //维数不相同4 G ]; V! z5 |0 O: ]# T6 e1 l
pMatrix3=NewMatrix(pMatrix1->Dim[0],pMatrix1->Dim[1]); //生成新矩阵
# |2 z( }& G7 g8 q k5 O. f
if(!pMatrix3) break;
$ B0 B$ z5 O z3 w# ] k
for(i=0;i<pMatrix1->ArrayLen;i++) pMatrix3->Array[i]=pMatrix1->Array[i]*pMatrix2->Array[i]; //矩阵点乘 y2 N! u @* q\\" W\\" T
FunReObj(hFor); //告诉Lu，返回一个动态对象\\" `! m( U# a- m H/ j0 `
a.BType=Matrix; a.VType=Matrix; a.x=0; *(luVOID *)&(a.x)=(luVOID)pMatrix3;8 O4 W8 n/ O$ q4 j8 O% i# f* P0 G
break;
0 o3 N I: H# q7 @, S8 r! `
case 46: //重载函数new2 }$ B! B# v+ R2 Z6 G
if(mm<2) break;- ]- [' `# a; K: Z; G1 E9 O
if((xx+1)->x<1 || (xx+2)->x<1 || (xx+1)->BType!=luStaData_int64 || (xx+2)->BType!=luStaData_int64) break;
\\" t5 O0 Z% Q\\" E- s: h7 d
pMatrix3=NewMatrix((luVOID)(xx+1)->x,(luVOID)(xx+2)->x);//生成新矩阵
7 B, T P. }7 H
if(!pMatrix3) break;
3 k) I+ j) c7 N5 a7 n
for(j=0,i=3;i<=mm;i++,j++) //赋初值% P' Y1 t9 [1 Q
{
: t2 ^. a4 Q: E\\" ~ N1 Y
if(j>=pMatrix3->ArrayLen) break;
% v8 S# a2 V' t- w: t: i
if((xx+i)->BType!=luStaData_double) break; //只接受实数参数7 \% a8 w$ n/ q1 u% [
pMatrix3->Array[j]=*(double *)&((xx+i)->x);; x( m: H% o6 |1 v/ ?& V
}
i m I& Q5 h7 N3 Q! R/ ^% ?- V
FunReObj(hFor); //告诉Lu，返回一个动态对象
* G9 _2 b1 p: K, F Q
a.BType=Matrix; a.VType=Matrix; a.x=0; *(luVOID *)&(a.x)=(luVOID)pMatrix3;/ n: D5 P3 m' P$ N
break;5 ?1 ~# S4 M+ {, g. ]+ J& A# X
case 49: //重载函数o$ p( V* ?4 ~( R/ M+ y
pMessage=(luMessage)SearchKey("\0\0\0\0",sizeof(luVOID),luPubKey_User);$ r* E: A2 w/ @, r& v
if(!pMessage) break;
, j- ?* R. E9 f
pMatrix1=(myMatrix *)SearchKey((char *)&(xx->x),sizeof(luVOID),Matrix);% K\\" y y% ]3 A5 O# n
if(!pMatrix1) break; //对象句柄无效，不是矩阵5 p8 a1 F6 G& c; ~ p, l% E, `
pa=pMatrix1->Array;
5 A, J$ [- v2 N) C4 P; Y8 Z2 m/ t
m=pMatrix1->Dim[0]; n=pMatrix1->Dim[1]; k=0;# I3 y( h7 j- j% q$ Y3 U( |\\" p7 V7 O
for(i=0; i<m; i++) //输出矩阵) [4 O. L7 t/ ^8 Y/ I) J& ~9 n
{
5 W\\" ] i& L2 k\\" v
pMessage(L"\r\n"); k+=2;
/ d8 l5 i6 b, x( j7 ]
for(j=0; j<n; j++)8 O6 b N r4 j
{6 S1 U: N: W# ?! u6 Z! s5 h
_gcvt_s(chNum,pa[i*n+j],16);
2 B) C' Q& V0 s( u9 E
for(u=0;chNum[u];u++) {wchNum[u]=chNum[u]; k++;}
0 q* j# O9 h- c6 D
wchNum[u]='\0';
( a% `, l8 A- g# B$ [
pMessage(wchNum); pMessage(L" "); k+=2;
3 O: }3 \* f% y f
} J6 h! f\\" y% c. ^* c5 _
}
3 `% I. M! X+ ?& r
pMessage(L"\r\n"); k+=2;* S5 ~0 e- Q( |! g) K
a.BType=luStaData_int64; a.VType=luStaData_int64; a.x=k; //按函数o的要求，返回输出的字符总数$ W0 y/ O; O( c0 K# w# L# D
break;/ D, u. w; _0 @2 H; Q
default: t' N9 y\\" `0 P% D$ T% L- n! z( R
break;2 O) \/ f+ ^! a* g: K4 y
}
. W/ j! o' s: T. {2 I f* W3 a
return a;4 I t1 i; K; p f r4 M
}
1 O, o1 O: u2 p
void main(void)
5 j6 h0 u9 H& d& R. Q# v
{
% {1 |$ p; i% E- e1 ?2 ?3 a5 [% M
void *hFor; //表达式句柄9 {) ~1 J\\" @1 \4 K; a+ `
luINT nPara; //存放表达式的自变量个数
% y( n8 j X( p$ y* g
LuData *pPara; //存放输入自变量的数组指针+ D! E8 `; ` J( p' A x5 r
luINT ErrBegin,ErrEnd; //表达式编译出错的初始位置和结束位置
' v+ l0 S4 A1 ^) d! H
int ErrCode; //错误代码+ v- t }/ [6 @* p/ L9 Z
void *v;
1 y7 @; b; h9 i+ o9 i
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.]}";//字符串表达式，矩阵乘9 s. y% e/ E. `( J0 `
//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.]}";//字符串表达式，矩阵点乘
' e; J9 j- X T1 `6 m! x
LuData Val;
& V! n$ [2 U: q' p$ A. N/ v
if(!InitLu()) return; //初始化Lu: e$ ^ J3 P4 I0 t3 `( p
while(LockKey(Matrix,DelMatrix,OpMatrix)){Matrix--;} //锁定一个键，用于存储矩阵扩展类型2 J* v$ j. G. v: d2 i% S* s$ W
4 V\\" K' ` \$ G- J# l, d
Val.BType=luStaData_int64; Val.VType=luStaData_int64; Val.x=Matrix; //定义整数常量5 _/ Q$ j' x' d0 k; t
SetConst(L"matrix",&Val); //设置整数常量
, X5 B- y7 w( r i! |4 h/ w
InsertKey("\0\0\0\0",4,luPubKey_User,LuMessage,NULL,NULL,1,v); //使Lu运行时可输出函数信息
/ s6 z2 c5 B# L/ K) _\\" V
wcout.imbue(locale("chs")); //设置输出的locale为中文
* K2 K2 L7 ^* |* Q8 G$ j' @8 K
: h& n5 o7 n: y\\" I7 Z
ErrCode=LuCom(ForStr,0,0,0,hFor,nPara,pPara,ErrBegin,ErrEnd); //编译表达式\\" X& M- U! ?( i( m8 n4 X) Q$ ~) p
if(ErrCode)\\" q! ?' P3 @0 H7 N; v8 i+ `! N
{, U. @3 c9 @+ S1 s0 d
wcout<<L"表达式有错误！错误代码："<<ErrCode<<endl;& V4 I! R: Z) y( _; Y! D, J8 S
}
1 T( |& x\\" W3 S1 ]% a
else! P, a) ~, g- a) r: A& l
{5 t1 Z7 D) N2 ]$ \$ f
LuCal(hFor,pPara); //计算表达式的值
# l6 r! E, }1 C Q# N) m3 C: v
}7 o3 d1 v* ?! h1 q2 u9 n# q/ T* w
LockKey(Matrix,NULL,OpMatrix);//解锁键Matrix，本例中，该函数可以不用( K1 k5 L. \2 C8 [8 R\\" ~
FreeLu(); //释放Lu: U& Z. Y: u. a2 @; q
}

#include <windows.h> 
1 t, H/ E8 O& b\\" j! F
#include <iostream> 
' {- C! ~* c  F. Z+ a
#include <math.h>( q  v, _% N: W+ c- D

#include "lu32.h": j& x4 N- {) W* B

#pragma comment( lib, "lu32.lib" )# ^  o- c. q& x  |) X) a) b

using namespace std; 
6 d  \6 z1 q0 |. I
//自定义矩阵, K4 a/ S/ V9 ~% {. o5 I8 k

class myMatrix 
' w6 s3 Z2 \8 `2 ~& h/ I* `
{; r8 B8 f9 B, E, Q\\" `: `# s

public:& u  }# l9 n\\" H& {5 H4 d& U

double *Array;        //数据缓冲区1 Q% E# k! Y- H. P

luVOID ArrayLen;        //数据缓冲区长度 
; \\\" D& D3 p5 g0 F( R# y  A3 E6 c
        luVOID Dim[2];        //矩阵维数0 q) w, W0 z( I0 \1 S8 D6 V\\" i

myMatrix(){Array=NULL; ArrayLen=0; Dim[0]=0; Dim[1]=0;}9 C( I& N1 Y% Z7 q

~myMatrix() 
6 j9 O\\" {0 j* F$ G; Z* R
        { 
& z3 l$ U: z+ s3 l' M
                if(Array) delete[] Array; 
/ P# `7 ~# m# f  z9 A! l
        }/ P# p\\" e7 o8 K

};# l% t4 Y0 F6 _. ~) r/ O

luKEY Matrix=-1000;        //标识矩阵类型，最终的Matrix由LockKey决定\\" z! q- x/ R; }5 [0 A3 G6 N) [

void _stdcall LuMessage(wchar_t *pch)//输出动态库信息，该函数注册到Lu，由Lu二级函数调用 
8 Q9 f% v2 B4 H. s  a# O6 l# J
{ 
, ~\\" E5 F) J, u. m; x* s. k* ~
        wcout<<pch; 
' X. h: R9 c$ F\\" }4 u
}/ X( [* K) w  C$ G

void _stdcall DelMatrix(void *me)        //用于LockKey函数及InsertKey函数，使Lu能自动销毁myMatrix对象. c1 H9 c7 H1 Q  n; Z3 `+ r

{! f/ U- H% y2 K! a8 o; U8 I

delete (myMatrix *)me; 
9 P/ a. [3 k3 k( V* x
}% d! n, [8 G/ j5 E

myMatrix * _stdcall NewMatrix(luVOID m,luVOID n)        //生成一个myMatrix对象+ n. v9 P) O8 c6 b' |: @

{1 ^9 m3 l* w) v. L, ]) c: m

myMatrix *pMatrix;, s7 x' \- D% F5 d+ z& ~

luVOID k; 
8 ~8 O# Z6 i- U8 l; T# [6 o
        double *pa; 
: U$ _  ^- \8 d( g7 l' u
        char keyname[sizeof(luVOID)]; 
6 p$ q( I  z- t/ _$ T
        void *NowKey;; D5 W% J. E5 c9 d

k=m*n;* T0 M4 F1 u- D- E+ s) M& R

pMatrix=(myMatrix *)GetBufObj(Matrix,keyname);//先尝试从缓冲区中获取一个矩阵对象 
\\" `: N) C4 n$ g7 ?
        if(pMatrix)8 k/ H6 H9 `+ n; ?4 d9 e1 d

{ 
/ Z. b$ H) y& h- S0 |  Z
                if(pMatrix->ArrayLen!=k)        //重置矩阵的大小 
3 y  t* g  u. G% J
                { 
: j5 e5 W' f, W4 ]1 C+ z! t
                        pa=new double[k];# q- G, a2 ~) ~; Z

if(!pa)2 ?+ f\\" a& M- |) q

{% H  u3 w* E7 A; y

DeleteKey(keyname,sizeof(luVOID),Matrix,DelMatrix,1);        //将矩阵对象放回缓冲区* T3 C' H4 i* I( j- _7 h/ g

return NULL;& w# \\\" x2 O' b

} 
6 u8 m8 T% D6 |3 e
                        delete[] pMatrix->Array;  X* x, ^7 x# g

pMatrix->Array=pa;: r# o' `# s( f0 U7 \* h- \/ o

} 
9 {) s! \- I4 u. d& G- F
        } 
: l& S& e0 a1 a0 s6 }1 z
        else\\" q. R& ~6 l1 Q# o( k

{+ q: m0 m2 M9 ~  B  M  e7 C

pMatrix=new myMatrix;        //创建矩阵对象 
  W8 x2 ^0 u& x0 n3 S
                if(!pMatrix) return NULL; 
; r2 \6 B5 f. r8 }5 y
                pMatrix->Array=new double[k]; 
3 {! [) C2 u, l
                if(!pMatrix->Array) 
7 ^( r4 N3 O: U3 n. z1 [2 T6 v% a
                { 
+ P6 T- {7 u2 B  ]+ Q
                        delete pMatrix;# n+ o. W: F2 b, j8 v. C, Z) ?

return NULL; 
* U\\" s2 G# X, U8 A0 I5 H: i
                }& j) h, G; T7 f. s5 ^1 M5 Y

if(InsertKey((char *)&pMatrix,-1,Matrix,pMatrix,DelMatrix,NULL,0,NowKey))        //将矩阵对象注册到Lu 
\\" ~6 K+ `0 U$ \, G% t* I) L$ l
                {- B7 {4 v3 R; d

delete pMatrix; 
# a; s$ p, N+ y# g- c1 [
                        return NULL; 
0 @/ I5 ^- Z. f6 T1 I# t% C7 N
                } 
! A4 O! a- U0 C6 T! H
        } 
: Q. y9 D6 t; @; q! ^: q
        pMatrix->ArrayLen=k; pMatrix->Dim[0]=m; pMatrix->Dim[1]=n;5 f( n7 x7 C1 [( \. b, W

return pMatrix; 
2 `+ h& w8 p) e3 ^) p: Y  r
}: p/ E: L2 F  W2 y# R/ |

LuData _stdcall OpMatrix(luINT mm,LuData *xx,void *hFor,int theOperator)        //运算符重载函数，用于LockKey函数 
6 C' C# G: E2 G2 k
{ 
* }/ a! b: v' Z9 G) h  _5 F
        LuData a; 
& t3 h3 o3 S- M\\" N
        myMatrix *pMatrix1,*pMatrix2,*pMatrix3; 
, V6 g4 o: [7 C! E' C
        luVOID i,j,k,m,n,u,v; 
2 _' x6 f' a$ o\\" u; u: i
        double *pa,*pb,*pc;3 q  n8 `. i' X0 e

luMessage pMessage;* I4 P/ t/ Y  T+ X. V' H

wchar_t wchNum[32];6 U  j& ^3 Z' c7 a& K! U. }

char chNum[32];  N( v. ]/ x( q9 w' Q

a.BType=luStaData_nil; a.VType=luStaData_nil; a.x=0;1 V: Y  J& z8 j9 U' F; \

switch(theOperator)8 S. n' I/ v# n0 E! u7 Y9 Q! \

{/ _- s( ^* H$ i& f  q

case 2:        //重载运算符*7 x3 h# T# z7 |/ c

pMatrix1=(myMatrix *)SearchKey((char *)&(xx->x),sizeof(luVOID),Matrix); 
% l8 ]$ y+ m( r: m
                pMatrix2=(myMatrix *)SearchKey((char *)&((xx+1)->x),sizeof(luVOID),Matrix);9 W: m( V1 F- y4 C& Z+ k

if(!pMatrix1 || !pMatrix2) break;        //对象句柄无效，不是矩阵8 p( T, I( @+ a+ R

if(pMatrix1->Dim[1]!=pMatrix2->Dim[0]) break;        //维数不匹配 
4 u/ Z9 [\\" X( |\\" F  a
                pMatrix3=NewMatrix(pMatrix1->Dim[0],pMatrix2->Dim[1]);        //生成新矩阵; L; O- H6 R+ y1 O5 E, _

if(!pMatrix3) break;- k6 j1 e, x, e9 X! m2 T4 S2 l

pa=pMatrix1->Array; pb=pMatrix2->Array; pc=pMatrix3->Array; 
7 a+ n' p2 G, |9 x; _% `
                m=pMatrix1->Dim[0]; n=pMatrix1->Dim[1]; k=pMatrix2->Dim[1]; 
4 g* |& h& r& n6 A  X6 p% L) M
                for(i=0; i<m; i++)        //矩阵乘7 f4 q; T- i/ `! l# {

{3 Z' S2 f! a7 k1 [

for(j=0; j<k; j++) 
- y' M  Y: a# @- r$ M. d9 i
                        {7 v2 k- Y: }/ Q2 f, S0 f\\" a

u=i*k+j; pc[u]=0.0; 
. `5 q\\" V' s+ T0 `\\" u
                                for (v=0; v<n; v++)$ [& s* S) G! u# I

{ 
0 a  G' d; X3 k9 ~
                                        pc[u]=pc[u]+pa[i*n+v]*pb[v*k+j]; 
$ k6 |& P$ T- j
                                }\\" o' ^# x; G( N6 x4 g

}1 s& j& n0 B6 [/ l1 N

} 
) x4 N% s  _# R, _. s: S2 W
                FunReObj(hFor);        //告诉Lu，返回一个动态对象1 R4 c8 C; O6 o) Y; I

a.BType=Matrix; a.VType=Matrix; a.x=0; *(luVOID *)&(a.x)=(luVOID)pMatrix3; 
9 N) W: k; f) j
                break; 
' b! z) d; P# X7 \+ Q
        case 25:        //重载运算符.* 
4 u+ M\\" q5 x$ r' m1 \( D
                pMatrix1=(myMatrix *)SearchKey((char *)&(xx->x),sizeof(luVOID),Matrix); 
$ O9 ~# l2 y( q% s* F* ~2 h
                pMatrix2=(myMatrix *)SearchKey((char *)&((xx+1)->x),sizeof(luVOID),Matrix); 
% o5 V5 b# V+ I
                if(!pMatrix1 || !pMatrix2) break;        //对象句柄无效，不是矩阵% S\\" m+ |# l' W7 M! ?

if(pMatrix1->Dim[0]!=pMatrix2->Dim[0] || pMatrix1->Dim[1]!=pMatrix2->Dim[1]) break;        //维数不相同4 G  ]; V! z5 |0 O: ]# T6 e1 l

pMatrix3=NewMatrix(pMatrix1->Dim[0],pMatrix1->Dim[1]);        //生成新矩阵 
# |2 z( }& G7 g8 q  k5 O. f
                if(!pMatrix3) break; 
$ B0 B$ z5 O  z3 w# ]  k
                for(i=0;i<pMatrix1->ArrayLen;i++) pMatrix3->Array[i]=pMatrix1->Array[i]*pMatrix2->Array[i];        //矩阵点乘  y2 N! u  @* q\\" W\\" T

FunReObj(hFor);        //告诉Lu，返回一个动态对象\\" `! m( U# a- m  H/ j0 `

a.BType=Matrix; a.VType=Matrix; a.x=0; *(luVOID *)&(a.x)=(luVOID)pMatrix3;8 O4 W8 n/ O$ q4 j8 O% i# f* P0 G

break; 
0 o3 N  I: H# q7 @, S8 r! `
        case 46:        //重载函数new2 }$ B! B# v+ R2 Z6 G

if(mm<2) break;- ]- [' `# a; K: Z; G1 E9 O

if((xx+1)->x<1 || (xx+2)->x<1 || (xx+1)->BType!=luStaData_int64 || (xx+2)->BType!=luStaData_int64) break; 
\\" t5 O0 Z% Q\\" E- s: h7 d
                pMatrix3=NewMatrix((luVOID)(xx+1)->x,(luVOID)(xx+2)->x);//生成新矩阵 
7 B, T  P. }7 H
                if(!pMatrix3) break; 
3 k) I+ j) c7 N5 a7 n
                for(j=0,i=3;i<=mm;i++,j++)        //赋初值% P' Y1 t9 [1 Q

{ 
: t2 ^. a4 Q: E\\" ~  N1 Y
                        if(j>=pMatrix3->ArrayLen) break; 
% v8 S# a2 V' t- w: t: i
                        if((xx+i)->BType!=luStaData_double) break;        //只接受实数参数7 \% a8 w$ n/ q1 u% [

pMatrix3->Array[j]=*(double *)&((xx+i)->x);; x( m: H% o6 |1 v/ ?& V

} 
  i  m  I& Q5 h7 N3 Q! R/ ^% ?- V
                FunReObj(hFor);        //告诉Lu，返回一个动态对象 
* G9 _2 b1 p: K, F  Q
                a.BType=Matrix; a.VType=Matrix; a.x=0; *(luVOID *)&(a.x)=(luVOID)pMatrix3;/ n: D5 P3 m' P$ N

break;5 ?1 ~# S4 M+ {, g. ]+ J& A# X

case 49:        //重载函数o$ p( V* ?4 ~( R/ M+ y

pMessage=(luMessage)SearchKey("\0\0\0\0",sizeof(luVOID),luPubKey_User);$ r* E: A2 w/ @, r& v

if(!pMessage) break; 
, j- ?* R. E9 f
                pMatrix1=(myMatrix *)SearchKey((char *)&(xx->x),sizeof(luVOID),Matrix);% K\\" y  y% ]3 A5 O# n

if(!pMatrix1) break;        //对象句柄无效，不是矩阵5 p8 a1 F6 G& c; ~  p, l% E, `

pa=pMatrix1->Array; 
5 A, J$ [- v2 N) C4 P; Y8 Z2 m/ t
                m=pMatrix1->Dim[0]; n=pMatrix1->Dim[1]; k=0;# I3 y( h7 j- j% q$ Y3 U( |\\" p7 V7 O

for(i=0; i<m; i++)        //输出矩阵) [4 O. L7 t/ ^8 Y/ I) J& ~9 n

{ 
5 W\\" ]  i& L2 k\\" v
                        pMessage(L"\r\n"); k+=2; 
/ d8 l5 i6 b, x( j7 ]
                        for(j=0; j<n; j++)8 O6 b  N  r4 j

{6 S1 U: N: W# ?! u6 Z! s5 h

_gcvt_s(chNum,pa[i*n+j],16); 
2 B) C' Q& V0 s( u9 E
                                for(u=0;chNum[u];u++) {wchNum[u]=chNum[u]; k++;} 
0 q* j# O9 h- c6 D
                                wchNum[u]='\0'; 
( a% `, l8 A- g# B$ [
                                pMessage(wchNum); pMessage(L"  "); k+=2; 
3 O: }3 \* f% y  f
                        }  J6 h! f\\" y% c. ^* c5 _

} 
3 `% I. M! X+ ?& r
                pMessage(L"\r\n"); k+=2;* S5 ~0 e- Q( |! g) K

a.BType=luStaData_int64; a.VType=luStaData_int64; a.x=k;        //按函数o的要求，返回输出的字符总数$ W0 y/ O; O( c0 K# w# L# D

break;/ D, u. w; _0 @2 H; Q

default:  t' N9 y\\" `0 P% D$ T% L- n! z( R

break;2 O) \/ f+ ^! a* g: K4 y

} 
. W/ j! o' s: T. {2 I  f* W3 a
        return a;4 I  t1 i; K; p  f  r4 M

} 
1 O, o1 O: u2 p
void main(void) 
5 j6 h0 u9 H& d& R. Q# v
{ 
% {1 |$ p; i% E- e1 ?2 ?3 a5 [% M
        void *hFor;                //表达式句柄9 {) ~1 J\\" @1 \4 K; a+ `

luINT nPara;                //存放表达式的自变量个数 
% y( n8 j  X( p$ y* g
        LuData *pPara;                //存放输入自变量的数组指针+ D! E8 `; `  J( p' A  x5 r

luINT ErrBegin,ErrEnd;        //表达式编译出错的初始位置和结束位置 
' v+ l0 S4 A1 ^) d! H
        int ErrCode;                //错误代码+ v- t  }/ [6 @* p/ L9 Z

void *v; 
1 y7 @; b; h9 i+ o9 i
        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.]}";//字符串表达式，矩阵乘9 s. y% e/ E. `( J0 `

//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.]}";//字符串表达式，矩阵点乘 
' e; J9 j- X  T1 `6 m! x
        LuData Val; 
& V! n$ [2 U: q' p$ A. N/ v
        if(!InitLu()) return;        //初始化Lu: e$ ^  J3 P4 I0 t3 `( p

while(LockKey(Matrix,DelMatrix,OpMatrix)){Matrix--;}        //锁定一个键，用于存储矩阵扩展类型2 J* v$ j. G. v: d2 i% S* s$ W

4 V\\" K' `  \$ G- J# l, d
        Val.BType=luStaData_int64; Val.VType=luStaData_int64; Val.x=Matrix;        //定义整数常量5 _/ Q$ j' x' d0 k; t

SetConst(L"matrix",&Val);        //设置整数常量 
, X5 B- y7 w( r  i! |4 h/ w
        InsertKey("\0\0\0\0",4,luPubKey_User,LuMessage,NULL,NULL,1,v); //使Lu运行时可输出函数信息 
/ s6 z2 c5 B# L/ K) _\\" V
        wcout.imbue(locale("chs"));        //设置输出的locale为中文 
* K2 K2 L7 ^* |* Q8 G$ j' @8 K
   
: h& n5 o7 n: y\\" I7 Z
        ErrCode=LuCom(ForStr,0,0,0,hFor,nPara,pPara,ErrBegin,ErrEnd); //编译表达式\\" X& M- U! ?( i( m8 n4 X) Q$ ~) p

if(ErrCode)\\" q! ?' P3 @0 H7 N; v8 i+ `! N

{, U. @3 c9 @+ S1 s0 d

wcout<<L"表达式有错误！错误代码："<<ErrCode<<endl;& V4 I! R: Z) y( _; Y! D, J8 S

} 
1 T( |& x\\" W3 S1 ]% a
        else! P, a) ~, g- a) r: A& l

{5 t1 Z7 D) N2 ]$ \$ f

LuCal(hFor,pPara);        //计算表达式的值 
# l6 r! E, }1 C  Q# N) m3 C: v
        }7 o3 d1 v* ?! h1 q2 u9 n# q/ T* w

LockKey(Matrix,NULL,OpMatrix);//解锁键Matrix，本例中，该函数可以不用( K1 k5 L. \2 C8 [8 R\\" ~

FreeLu();                        //释放Lu: U& Z. Y: u. a2 @; q

}

习题：

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

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

main(:a,b,c,d,t,i)=, y7 D0 K3 B- ]/ ]. W$ P
a=new[matrix,2,2: 1.,2.,2.,1.],
$ Q* ^# Q4 k* V; V
b=new[matrix,2,2: 2.,1.,1.,2.], g- x! H4 Q1 K* x, H7 O
c=new[matrix,2,2: 2/3.,-1/3.,-1/3.,2/3.],
- o7 S+ L/ I h2 k; ?3 E
t=clock(),
$ j R! k& t4 n6 U7 v/ T: n# M
d=a*b, i=0, while{i<1000000, d=d*c*b, i++},
5 w; }2 s9 M\" K. i% l' n# F
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\"}";//字符串表达式

复制代码

结果：