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

查看: 7675|回复: 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> x; {4 d0 r: u7 t7 g
#include <iostream>6 B5 G: S# @( ]* L0 G% x% k1 } K! L; {- b
#include <math.h>; O L* G' E& U' J) I
#include "lu32.h"
) T6 S0 h, Q0 W
#pragma comment( lib, "lu32.lib" )* |5 Q\\" K, Z7 o) @
using namespace std;
) d6 D1 S9 r0 N7 t6 e- e9 Q+ `
//自定义矩阵
) X3 k. {# M6 R
class myMatrix
- W7 E- V- p+ ?, p
{! ^6 X9 E5 i2 ]& {9 ^1 h
public:
; X- m; l\\" l' p8 k
double *Array; //数据缓冲区
. V# ~& A5 I) r, R8 ^
luVOID ArrayLen; //数据缓冲区长度
9 {: a\\" z7 e F$ t; e. z
luVOID Dim[2]; //矩阵维数
7 ^ ]\\" X- q$ D' |
myMatrix(){Array=NULL; ArrayLen=0; Dim[0]=0; Dim[1]=0;}1 L: A/ @* ]7 W5 O5 m
~myMatrix()2 c1 G- K& d+ a\\" P% X
{
, p# {- G7 r9 X, U- T
if(Array) delete[] Array;
\, E- P; Y4 g
}
( w* [+ H\\" n% W/ c6 r/ C& v) M( g
};! ?# F6 a, c/ E5 X7 y: K
luKEY Matrix=-1000; //标识矩阵类型，最终的Matrix由LockKey决定* n7 o* u+ r0 d# h. Q: S
void _stdcall LuMessage(wchar_t *pch)//输出动态库信息，该函数注册到Lu，由Lu二级函数调用 6 B& u3 {: m4 q7 k* J5 q% ?3 j5 W
{/ s' I, f b% \- ~7 m% D: |7 E/ \: b! z
wcout<<pch;
: `3 V9 i\\" h$ I+ Y- i
}
6 o4 J* s/ q7 k% ]
void _stdcall DelMatrix(void *me) //用于LockKey函数及InsertKey函数，使Lu能自动销毁myMatrix对象, a! T, d: H) W+ B
{
+ `8 w) A! N3 m1 w6 P' F; Z: r
delete (myMatrix *)me;
. K$ {! q I' }, [\\" A) X7 D
}
: S: w- U: \9 f
myMatrix * _stdcall NewMatrix(luVOID m,luVOID n) //生成一个myMatrix对象
8 W\\" m+ J# x- z. Y4 {
{8 r1 p# j; Z1 s. _9 j0 }8 O
myMatrix *pMatrix;
& K& d: g! e3 K
luVOID k;
5 j4 @4 K* [& N9 J- k
double *pa;
0 ~$ f! R' w6 b4 p
char keyname[sizeof(luVOID)];- d5 `; Y, b# r5 d
void *NowKey;
( t$ u/ y3 k2 b) ]( Z
k=m*n;- n8 f( \ ~1 d) ^% R/ b
pMatrix=(myMatrix *)GetBufObj(Matrix,keyname);//先尝试从缓冲区中获取一个矩阵对象* t+ `( K# c0 F( K& O' e
if(pMatrix)
\\" _3 k6 V0 r) Q% O- d3 y/ w
{$ K N! y: j2 `
if(pMatrix->ArrayLen!=k) //重置矩阵的大小
1 p: S- s' d' s' b* p\\" x
{
# [\\" h0 G/ G$ x: n5 G7 W' y
pa=new double[k];
0 {2 B: R5 O6 J8 U0 @$ b' n
if(!pa)2 l+ V+ R; [# ^) C5 s\\" [
{
3 p4 j7 R A3 S, ?9 ?$ Y
DeleteKey(keyname,sizeof(luVOID),Matrix,DelMatrix,1); //将矩阵对象放回缓冲区' `+ g+ ~, A* Z$ F
return NULL;
5 N' }1 s, n9 {8 T. Y
}
. }, A, R/ f9 g% `
delete[] pMatrix->Array;8 @# [2 r0 \ n+ V# A
pMatrix->Array=pa;* V( j. T9 u: |. ~
}
1 ?- n9 k; W) J* a' |6 @
}
+ t0 K6 [+ d [3 w6 D& i/ {4 C
else6 s. [- O. a& J: f
{
F, L. h/ K' j7 @
pMatrix=new myMatrix; //创建矩阵对象5 n; D; b$ `! m\\" g7 X% H
if(!pMatrix) return NULL;\\" s1 I$ u. U$ F( v, J- k! H' L6 }
pMatrix->Array=new double[k];
3 h! v. A: V/ G& f
if(!pMatrix->Array)/ b N1 R7 s0 U7 G
{
6 s) }6 J6 Z8 t2 S; M
delete pMatrix;
6 N4 A9 L; J! d) o; Z
return NULL;
1 X0 ?9 ]. G% I7 R2 h
}6 _\\" K0 A9 z) p2 @6 \; F' k0 n7 i
if(InsertKey((char *)&pMatrix,-1,Matrix,pMatrix,DelMatrix,NULL,0,NowKey)) //将矩阵对象注册到Lu
( t: q3 c2 @9 r4 U9 w, g+ c
{
* U* ]0 W$ D1 Y2 ?; k- U+ b
delete pMatrix;3 u* ^9 I. `6 o. F9 O: C# W
return NULL;
9 H\\" j& {: O( \: V
}4 B, f( ?- w# f
}8 U3 B x) t$ z8 {$ i( d3 h+ K& Q
pMatrix->ArrayLen=k; pMatrix->Dim[0]=m; pMatrix->Dim[1]=n;
% t W) B( @) D3 U9 c1 T
return pMatrix;
8 h\\" f) q, p4 H
}
1 O2 z\\" k) G, F( F
LuData _stdcall OpMatrix(luINT mm,LuData *xx,void *hFor,int theOperator) //运算符重载函数，用于LockKey函数: u, N1 u, |6 d; Z$ v; H) a8 A5 ^
{
4 p+ K/ f& X& h9 Y, F
LuData a;
) f; B: Q8 {3 m# P4 x\\" v
myMatrix *pMatrix1,*pMatrix2,*pMatrix3;$ l. i3 k d: l* L\\" _
luVOID i,j,k,m,n,u,v;
$ k\\" q$ Q; @% _) F( ^
double *pa,*pb,*pc; o1 a+ p7 U: ?5 J
luMessage pMessage;. R |& Q\\" v3 c$ A
wchar_t wchNum[32];
6 t7 K3 M3 j: I$ V\\" M$ h
char chNum[32];: `* G0 q5 K/ _( C5 X
a.BType=luStaData_nil; a.VType=luStaData_nil; a.x=0;
' F# M' G* X1 g# \
switch(theOperator)
/ N8 d/ s9 r7 D5 q7 {% u6 ]
{\\" H4 w% ]9 A* p$ C1 r- M# g3 R0 d
case 2: //重载运算符*- F( `2 w! D, \) e# B% a2 q7 |6 W
pMatrix1=(myMatrix *)SearchKey((char *)&(xx->x),sizeof(luVOID),Matrix);, s0 _2 k; Z\\" q+ d+ x8 r+ z
pMatrix2=(myMatrix *)SearchKey((char *)&((xx+1)->x),sizeof(luVOID),Matrix);& P) `1 {\\" q) j& m
if(!pMatrix1 || !pMatrix2) break; //对象句柄无效，不是矩阵7 F6 q. E& j3 l
if(pMatrix1->Dim[1]!=pMatrix2->Dim[0]) break; //维数不匹配3 i( ^9 y5 T; N, k2 s3 r
pMatrix3=NewMatrix(pMatrix1->Dim[0],pMatrix2->Dim[1]); //生成新矩阵9 p8 J2 `: N' u, H( G6 h: s\\" n
if(!pMatrix3) break;
1 z! A; {& p. O\\" P- \0 _& V- [# K
pa=pMatrix1->Array; pb=pMatrix2->Array; pc=pMatrix3->Array;9 t& @2 ?* v. ?\\" B+ p
m=pMatrix1->Dim[0]; n=pMatrix1->Dim[1]; k=pMatrix2->Dim[1];% Z9 I4 S, v' Z
for(i=0; i<m; i++) //矩阵乘) M; ^0 a. b* B1 O( c
{8 R4 H2 ]. K0 f
for(j=0; j<k; j++)1 F' ^) N& j5 Y! S
{
- c4 N# N) V/ ^- E8 w2 ]3 [
u=i*k+j; pc[u]=0.0;3 F4 j1 _; L- ~* V- e\\" n
for (v=0; v<n; v++)9 z0 E c6 Z1 d
{+ L% N6 A0 o0 C: l
pc[u]=pc[u]+pa[i*n+v]*pb[v*k+j];
\\" O2 C: Q/ _) ]) T% Y
}6 c\\" b# ?' O3 U1 S, a$ {
}7 j' v6 [) H/ _2 _
}: V6 U' |4 I. |% _, E7 Y
FunReObj(hFor); //告诉Lu，返回一个动态对象
* I% n. x6 N) s' h3 k2 V K
a.BType=Matrix; a.VType=Matrix; a.x=0; *(luVOID *)&(a.x)=(luVOID)pMatrix3;4 q9 w9 q( u5 K, i8 G1 h
break;
- h; d T6 A\\" x; K0 Q: M
case 25: //重载运算符.*\\" u! w6 C# ]2 o
pMatrix1=(myMatrix *)SearchKey((char *)&(xx->x),sizeof(luVOID),Matrix);0 R- ?+ s: F8 N; m3 C- b6 J
pMatrix2=(myMatrix *)SearchKey((char *)&((xx+1)->x),sizeof(luVOID),Matrix);
2 m8 ^* G% Q6 t: C0 |
if(!pMatrix1 || !pMatrix2) break; //对象句柄无效，不是矩阵
- V1 T& y! s. a$ Z6 U
if(pMatrix1->Dim[0]!=pMatrix2->Dim[0] || pMatrix1->Dim[1]!=pMatrix2->Dim[1]) break; //维数不相同
5 p z: O9 ]8 w/ L1 z, m- ~
pMatrix3=NewMatrix(pMatrix1->Dim[0],pMatrix1->Dim[1]); //生成新矩阵
8 j4 Z) _% P( _9 Y% N\\" E& m
if(!pMatrix3) break;/ j\\" m9 j; i2 p+ e6 W5 ]8 S
for(i=0;i<pMatrix1->ArrayLen;i++) pMatrix3->Array[i]=pMatrix1->Array[i]*pMatrix2->Array[i]; //矩阵点乘
7 d1 E2 i+ `4 u0 A$ Y0 L
FunReObj(hFor); //告诉Lu，返回一个动态对象
\ E6 W4 x- I& ~# I$ f; C
a.BType=Matrix; a.VType=Matrix; a.x=0; *(luVOID *)&(a.x)=(luVOID)pMatrix3;
break;
4 U' O% ]) Y4 V6 [! R! i& `: s
case 46: //重载函数new* |\\" }) x: v' J8 Z! R* O
if(mm<2) break;
. v& n7 ~: c' S& D, n6 U! \: T$ l
if((xx+1)->x<1 || (xx+2)->x<1 || (xx+1)->BType!=luStaData_int64 || (xx+2)->BType!=luStaData_int64) break;
\\" j \6 ~) G9 L; j6 V- g' F: l
pMatrix3=NewMatrix((luVOID)(xx+1)->x,(luVOID)(xx+2)->x);//生成新矩阵
\\" u4 o% Q8 B( Y& t
if(!pMatrix3) break;* |\\" m$ X; `; h( `- Z/ L; ~
for(j=0,i=3;i<=mm;i++,j++) //赋初值
8 o\\" ~, o3 p3 D/ x! P
{, X4 C0 Q. a2 v3 m
if(j>=pMatrix3->ArrayLen) break;
8 P) |+ z- m4 @/ h4 l% |! }: Q
if((xx+i)->BType!=luStaData_double) break; //只接受实数参数
# [/ S; W' ~ a1 C2 f
pMatrix3->Array[j]=*(double *)&((xx+i)->x);. T+ R& [9 j/ X
}7 w& ^. W* i2 j2 T+ [6 h7 h
FunReObj(hFor); //告诉Lu，返回一个动态对象6 `, M* U. F8 l! E
a.BType=Matrix; a.VType=Matrix; a.x=0; *(luVOID *)&(a.x)=(luVOID)pMatrix3;) E. Y8 L5 y! p, y
break;, i! W& x$ M/ u5 ^\\" b7 ?
case 49: //重载函数o
\\" ]$ C& g0 F$ @+ d- D, H
pMessage=(luMessage)SearchKey("\0\0\0\0",sizeof(luVOID),luPubKey_User);8 ?2 _\\" F+ K2 Y\\" N
if(!pMessage) break;' P G5 L# d5 ]& H' h& m
pMatrix1=(myMatrix *)SearchKey((char *)&(xx->x),sizeof(luVOID),Matrix);
2 A8 \0 n$ W( h, U' d. F4 k* l( R
if(!pMatrix1) break; //对象句柄无效，不是矩阵
9 S) z\\" k k# U# Y
pa=pMatrix1->Array;. M' o$ g- w4 K\\" U
m=pMatrix1->Dim[0]; n=pMatrix1->Dim[1]; k=0;- u1 i7 [# A3 q/ a6 G+ i
for(i=0; i<m; i++) //输出矩阵
M2 [$ K2 G, d3 m
{
8 F$ C1 z' l! v3 l( V' {! J
pMessage(L"\r\n"); k+=2;
) x0 V$ Z3 {4 d; L7 n/ _ \+ d% @
for(j=0; j<n; j++)/ I/ ]\\" d' [+ L- A% e) V% X$ e2 @& ]
{
% S; P, S2 l% u$ i: N9 f) c
_gcvt_s(chNum,pa[i*n+j],16);
! F8 y' D: ^& y# m1 j3 k) h# ^
for(u=0;chNum[u];u++) {wchNum[u]=chNum[u]; k++;}* e% s( |/ U0 b/ _6 j; |
wchNum[u]='\0';
. A; S$ n/ P$ c, Q' I$ |$ \
pMessage(wchNum); pMessage(L" "); k+=2;# S4 D9 G\\" w/ e0 U9 @2 R
}
( I2 v\\" q1 G5 h! o o
}
$ |6 e8 o, Q9 M7 g0 k2 t
pMessage(L"\r\n"); k+=2;8 @7 e. B\\" ^! r$ k: D
a.BType=luStaData_int64; a.VType=luStaData_int64; a.x=k; //按函数o的要求，返回输出的字符总数
W# c2 ?2 f2 p1 m
break;
' r7 Y8 Y1 k5 R9 B# F* G
default:
' R! \# N8 V$ [5 n\\" a0 o
break;\\" U1 P5 U, Z% G8 k
}
, F\\" ]. x m! }' d
return a;3 F- A! [\\" B+ u$ \ v/ D9 |+ T# \
}
8 Z$ L7 q4 |# z
void main(void). N4 m( ?* @$ C
{
2 p8 l( Q' e/ b! P& }
void *hFor; //表达式句柄& Z. ?, m\\" G' p& e+ V* p' A
luINT nPara; //存放表达式的自变量个数: J- c2 f5 {- k' N
LuData *pPara; //存放输入自变量的数组指针
; G4 x. D/ E E5 o) x
luINT ErrBegin,ErrEnd; //表达式编译出错的初始位置和结束位置
. C, k; A0 a; |$ R% L( e* ]2 k
int ErrCode; //错误代码
6 O% s! N\\" U+ @& b0 v! d6 Z0 y! l
void *v;
& l: K. ? L/ s* W7 h3 e/ L; C2 ^! Q
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.]}";//字符串表达式，矩阵乘
% P. o, ]5 U ^; a
//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.]}";//字符串表达式，矩阵点乘! o0 N! V; w0 ~5 p
LuData Val;
# ] i7 Q y5 z: l; A) s* a
if(!InitLu()) return; //初始化Lu
2 t9 W; w, g! l- K# t# T$ {
while(LockKey(Matrix,DelMatrix,OpMatrix)){Matrix--;} //锁定一个键，用于存储矩阵扩展类型8 T. H: q( [( V0 }
4 G% R* z: v& R+ i& _8 H' h h' x
Val.BType=luStaData_int64; Val.VType=luStaData_int64; Val.x=Matrix; //定义整数常量4 V& H) w: `9 q. i
SetConst(L"matrix",&Val); //设置整数常量
# [* I; K& q. U, a( ^: y6 R
InsertKey("\0\0\0\0",4,luPubKey_User,LuMessage,NULL,NULL,1,v); //使Lu运行时可输出函数信息5 r; V/ @6 K1 r1 Z$ v: A7 ^
wcout.imbue(locale("chs")); //设置输出的locale为中文
5 @5 F3 h. v2 `( k* V' c$ y
. M0 M2 W, M! T. q) R! u\\" `5 D: q
ErrCode=LuCom(ForStr,0,0,0,hFor,nPara,pPara,ErrBegin,ErrEnd); //编译表达式
' e/ g2 Q( _- c; E t
if(ErrCode)
+ ^. O, M4 N# H
{! d' b9 s( _- z$ o: R
wcout<<L"表达式有错误！错误代码："<<ErrCode<<endl;
A0 x, w2 l& o8 M2 k& p2 n% Y' M& [
}, I* E. v2 x$ ~
else\\" O' C, X, g! G0 m$ j& v O
{8 E9 B& Q\\" l6 y3 m8 K ]: p8 v
LuCal(hFor,pPara); //计算表达式的值
0 d& K- \- g/ |! C' c2 Y
}5 D2 ^/ O$ E9 n1 a
LockKey(Matrix,NULL,OpMatrix);//解锁键Matrix，本例中，该函数可以不用
* a- V' @7 B\\" I5 H1 Z: g; {
FreeLu(); //释放Lu
8 B\\" k/ n9 D! D+ }
}

#include <windows.h>  x; {4 d0 r: u7 t7 g

#include <iostream>6 B5 G: S# @( ]* L0 G% x% k1 }  K! L; {- b

#include <math.h>; O  L* G' E& U' J) I

#include "lu32.h" 
) T6 S0 h, Q0 W
#pragma comment( lib, "lu32.lib" )* |5 Q\\" K, Z7 o) @

using namespace std; 
) d6 D1 S9 r0 N7 t6 e- e9 Q+ `
//自定义矩阵 
) X3 k. {# M6 R
class myMatrix 
- W7 E- V- p+ ?, p
{! ^6 X9 E5 i2 ]& {9 ^1 h

public: 
; X- m; l\\" l' p8 k
        double *Array;        //数据缓冲区 
. V# ~& A5 I) r, R8 ^
        luVOID ArrayLen;        //数据缓冲区长度 
9 {: a\\" z7 e  F$ t; e. z
        luVOID Dim[2];        //矩阵维数 
7 ^  ]\\" X- q$ D' |
        myMatrix(){Array=NULL; ArrayLen=0; Dim[0]=0; Dim[1]=0;}1 L: A/ @* ]7 W5 O5 m

~myMatrix()2 c1 G- K& d+ a\\" P% X

{ 
, p# {- G7 r9 X, U- T
                if(Array) delete[] Array; 
  \, E- P; Y4 g
        } 
( w* [+ H\\" n% W/ c6 r/ C& v) M( g
};! ?# F6 a, c/ E5 X7 y: K

luKEY Matrix=-1000;        //标识矩阵类型，最终的Matrix由LockKey决定* n7 o* u+ r0 d# h. Q: S

void _stdcall LuMessage(wchar_t *pch)//输出动态库信息，该函数注册到Lu，由Lu二级函数调用 6 B& u3 {: m4 q7 k* J5 q% ?3 j5 W

{/ s' I, f  b% \- ~7 m% D: |7 E/ \: b! z

wcout<<pch; 
: `3 V9 i\\" h$ I+ Y- i
} 
6 o4 J* s/ q7 k% ]
void _stdcall DelMatrix(void *me)        //用于LockKey函数及InsertKey函数，使Lu能自动销毁myMatrix对象, a! T, d: H) W+ B

{ 
+ `8 w) A! N3 m1 w6 P' F; Z: r
        delete (myMatrix *)me; 
. K$ {! q  I' }, [\\" A) X7 D
} 
: S: w- U: \9 f
myMatrix * _stdcall NewMatrix(luVOID m,luVOID n)        //生成一个myMatrix对象 
8 W\\" m+ J# x- z. Y4 {
{8 r1 p# j; Z1 s. _9 j0 }8 O

myMatrix *pMatrix; 
& K& d: g! e3 K
        luVOID k; 
5 j4 @4 K* [& N9 J- k
        double *pa; 
0 ~$ f! R' w6 b4 p
        char keyname[sizeof(luVOID)];- d5 `; Y, b# r5 d

void *NowKey; 
( t$ u/ y3 k2 b) ]( Z
        k=m*n;- n8 f( \  ~1 d) ^% R/ b

pMatrix=(myMatrix *)GetBufObj(Matrix,keyname);//先尝试从缓冲区中获取一个矩阵对象* t+ `( K# c0 F( K& O' e

if(pMatrix) 
\\" _3 k6 V0 r) Q% O- d3 y/ w
        {$ K  N! y: j2 `

if(pMatrix->ArrayLen!=k)        //重置矩阵的大小 
1 p: S- s' d' s' b* p\\" x
                { 
# [\\" h0 G/ G$ x: n5 G7 W' y
                        pa=new double[k]; 
0 {2 B: R5 O6 J8 U0 @$ b' n
                        if(!pa)2 l+ V+ R; [# ^) C5 s\\" [

{ 
3 p4 j7 R  A3 S, ?9 ?$ Y
                                DeleteKey(keyname,sizeof(luVOID),Matrix,DelMatrix,1);        //将矩阵对象放回缓冲区' `+ g+ ~, A* Z$ F

return NULL; 
5 N' }1 s, n9 {8 T. Y
                        } 
. }, A, R/ f9 g% `
                        delete[] pMatrix->Array;8 @# [2 r0 \  n+ V# A

pMatrix->Array=pa;* V( j. T9 u: |. ~

} 
1 ?- n9 k; W) J* a' |6 @
        } 
+ t0 K6 [+ d  [3 w6 D& i/ {4 C
        else6 s. [- O. a& J: f

{ 
  F, L. h/ K' j7 @
                pMatrix=new myMatrix;        //创建矩阵对象5 n; D; b$ `! m\\" g7 X% H

if(!pMatrix) return NULL;\\" s1 I$ u. U$ F( v, J- k! H' L6 }

pMatrix->Array=new double[k]; 
3 h! v. A: V/ G& f
                if(!pMatrix->Array)/ b  N1 R7 s0 U7 G

{ 
6 s) }6 J6 Z8 t2 S; M
                        delete pMatrix; 
6 N4 A9 L; J! d) o; Z
                        return NULL; 
1 X0 ?9 ]. G% I7 R2 h
                }6 _\\" K0 A9 z) p2 @6 \; F' k0 n7 i

if(InsertKey((char *)&pMatrix,-1,Matrix,pMatrix,DelMatrix,NULL,0,NowKey))        //将矩阵对象注册到Lu 
( t: q3 c2 @9 r4 U9 w, g+ c
                { 
* U* ]0 W$ D1 Y2 ?; k- U+ b
                        delete pMatrix;3 u* ^9 I. `6 o. F9 O: C# W

return NULL; 
9 H\\" j& {: O( \: V
                }4 B, f( ?- w# f

}8 U3 B  x) t$ z8 {$ i( d3 h+ K& Q

pMatrix->ArrayLen=k; pMatrix->Dim[0]=m; pMatrix->Dim[1]=n; 
% t  W) B( @) D3 U9 c1 T
        return pMatrix; 
8 h\\" f) q, p4 H
} 
1 O2 z\\" k) G, F( F
LuData _stdcall OpMatrix(luINT mm,LuData *xx,void *hFor,int theOperator)        //运算符重载函数，用于LockKey函数: u, N1 u, |6 d; Z$ v; H) a8 A5 ^

{ 
4 p+ K/ f& X& h9 Y, F
        LuData a; 
) f; B: Q8 {3 m# P4 x\\" v
        myMatrix *pMatrix1,*pMatrix2,*pMatrix3;$ l. i3 k  d: l* L\\" _

luVOID i,j,k,m,n,u,v; 
$ k\\" q$ Q; @% _) F( ^
        double *pa,*pb,*pc;  o1 a+ p7 U: ?5 J

luMessage pMessage;. R  |& Q\\" v3 c$ A

wchar_t wchNum[32]; 
6 t7 K3 M3 j: I$ V\\" M$ h
        char chNum[32];: `* G0 q5 K/ _( C5 X

a.BType=luStaData_nil; a.VType=luStaData_nil; a.x=0; 
' F# M' G* X1 g# \
        switch(theOperator) 
/ N8 d/ s9 r7 D5 q7 {% u6 ]
        {\\" H4 w% ]9 A* p$ C1 r- M# g3 R0 d

case 2:        //重载运算符*- F( `2 w! D, \) e# B% a2 q7 |6 W

pMatrix1=(myMatrix *)SearchKey((char *)&(xx->x),sizeof(luVOID),Matrix);, s0 _2 k; Z\\" q+ d+ x8 r+ z

pMatrix2=(myMatrix *)SearchKey((char *)&((xx+1)->x),sizeof(luVOID),Matrix);& P) `1 {\\" q) j& m

if(!pMatrix1 || !pMatrix2) break;        //对象句柄无效，不是矩阵7 F6 q. E& j3 l

if(pMatrix1->Dim[1]!=pMatrix2->Dim[0]) break;        //维数不匹配3 i( ^9 y5 T; N, k2 s3 r

pMatrix3=NewMatrix(pMatrix1->Dim[0],pMatrix2->Dim[1]);        //生成新矩阵9 p8 J2 `: N' u, H( G6 h: s\\" n

if(!pMatrix3) break; 
1 z! A; {& p. O\\" P- \0 _& V- [# K
                pa=pMatrix1->Array; pb=pMatrix2->Array; pc=pMatrix3->Array;9 t& @2 ?* v. ?\\" B+ p

m=pMatrix1->Dim[0]; n=pMatrix1->Dim[1]; k=pMatrix2->Dim[1];% Z9 I4 S, v' Z

for(i=0; i<m; i++)        //矩阵乘) M; ^0 a. b* B1 O( c

{8 R4 H2 ]. K0 f

for(j=0; j<k; j++)1 F' ^) N& j5 Y! S

{ 
- c4 N# N) V/ ^- E8 w2 ]3 [
                                u=i*k+j; pc[u]=0.0;3 F4 j1 _; L- ~* V- e\\" n

for (v=0; v<n; v++)9 z0 E  c6 Z1 d

{+ L% N6 A0 o0 C: l

pc[u]=pc[u]+pa[i*n+v]*pb[v*k+j]; 
\\" O2 C: Q/ _) ]) T% Y
                                }6 c\\" b# ?' O3 U1 S, a$ {

}7 j' v6 [) H/ _2 _

}: V6 U' |4 I. |% _, E7 Y

FunReObj(hFor);        //告诉Lu，返回一个动态对象 
* I% n. x6 N) s' h3 k2 V  K
                a.BType=Matrix; a.VType=Matrix; a.x=0; *(luVOID *)&(a.x)=(luVOID)pMatrix3;4 q9 w9 q( u5 K, i8 G1 h

break; 
- h; d  T6 A\\" x; K0 Q: M
        case 25:        //重载运算符.*\\" u! w6 C# ]2 o

pMatrix1=(myMatrix *)SearchKey((char *)&(xx->x),sizeof(luVOID),Matrix);0 R- ?+ s: F8 N; m3 C- b6 J

pMatrix2=(myMatrix *)SearchKey((char *)&((xx+1)->x),sizeof(luVOID),Matrix); 
2 m8 ^* G% Q6 t: C0 |
                if(!pMatrix1 || !pMatrix2) break;        //对象句柄无效，不是矩阵 
- V1 T& y! s. a$ Z6 U
                if(pMatrix1->Dim[0]!=pMatrix2->Dim[0] || pMatrix1->Dim[1]!=pMatrix2->Dim[1]) break;        //维数不相同 
5 p  z: O9 ]8 w/ L1 z, m- ~
                pMatrix3=NewMatrix(pMatrix1->Dim[0],pMatrix1->Dim[1]);        //生成新矩阵 
8 j4 Z) _% P( _9 Y% N\\" E& m
                if(!pMatrix3) break;/ j\\" m9 j; i2 p+ e6 W5 ]8 S

for(i=0;i<pMatrix1->ArrayLen;i++) pMatrix3->Array[i]=pMatrix1->Array[i]*pMatrix2->Array[i];        //矩阵点乘 
7 d1 E2 i+ `4 u0 A$ Y0 L
                FunReObj(hFor);        //告诉Lu，返回一个动态对象 
  \  E6 W4 x- I& ~# I$ f; C
                a.BType=Matrix; a.VType=Matrix; a.x=0; *(luVOID *)&(a.x)=(luVOID)pMatrix3; 
+ F9 @$ ^* S$ O; e8 ^' G1 c& O  H, X5 A
                break; 
4 U' O% ]) Y4 V6 [! R! i& `: s
        case 46:        //重载函数new* |\\" }) x: v' J8 Z! R* O

if(mm<2) break; 
. v& n7 ~: c' S& D, n6 U! \: T$ l
                if((xx+1)->x<1 || (xx+2)->x<1 || (xx+1)->BType!=luStaData_int64 || (xx+2)->BType!=luStaData_int64) break; 
\\" j  \6 ~) G9 L; j6 V- g' F: l
                pMatrix3=NewMatrix((luVOID)(xx+1)->x,(luVOID)(xx+2)->x);//生成新矩阵 
\\" u4 o% Q8 B( Y& t
                if(!pMatrix3) break;* |\\" m$ X; `; h( `- Z/ L; ~

for(j=0,i=3;i<=mm;i++,j++)        //赋初值 
8 o\\" ~, o3 p3 D/ x! P
                {, X4 C0 Q. a2 v3 m

if(j>=pMatrix3->ArrayLen) break; 
8 P) |+ z- m4 @/ h4 l% |! }: Q
                        if((xx+i)->BType!=luStaData_double) break;        //只接受实数参数 
# [/ S; W' ~  a1 C2 f
                        pMatrix3->Array[j]=*(double *)&((xx+i)->x);. T+ R& [9 j/ X

}7 w& ^. W* i2 j2 T+ [6 h7 h

FunReObj(hFor);        //告诉Lu，返回一个动态对象6 `, M* U. F8 l! E

a.BType=Matrix; a.VType=Matrix; a.x=0; *(luVOID *)&(a.x)=(luVOID)pMatrix3;) E. Y8 L5 y! p, y

break;, i! W& x$ M/ u5 ^\\" b7 ?

case 49:        //重载函数o 
\\" ]$ C& g0 F$ @+ d- D, H
                pMessage=(luMessage)SearchKey("\0\0\0\0",sizeof(luVOID),luPubKey_User);8 ?2 _\\" F+ K2 Y\\" N

if(!pMessage) break;' P  G5 L# d5 ]& H' h& m

pMatrix1=(myMatrix *)SearchKey((char *)&(xx->x),sizeof(luVOID),Matrix); 
2 A8 \0 n$ W( h, U' d. F4 k* l( R
                if(!pMatrix1) break;        //对象句柄无效，不是矩阵 
9 S) z\\" k  k# U# Y
                pa=pMatrix1->Array;. M' o$ g- w4 K\\" U

m=pMatrix1->Dim[0]; n=pMatrix1->Dim[1]; k=0;- u1 i7 [# A3 q/ a6 G+ i

for(i=0; i<m; i++)        //输出矩阵 
  M2 [$ K2 G, d3 m
                { 
8 F$ C1 z' l! v3 l( V' {! J
                        pMessage(L"\r\n"); k+=2; 
) x0 V$ Z3 {4 d; L7 n/ _  \+ d% @
                        for(j=0; j<n; j++)/ I/ ]\\" d' [+ L- A% e) V% X$ e2 @& ]

{ 
% S; P, S2 l% u$ i: N9 f) c
                                _gcvt_s(chNum,pa[i*n+j],16); 
! F8 y' D: ^& y# m1 j3 k) h# ^
                                for(u=0;chNum[u];u++) {wchNum[u]=chNum[u]; k++;}* e% s( |/ U0 b/ _6 j; |

wchNum[u]='\0'; 
. A; S$ n/ P$ c, Q' I$ |$ \
                                pMessage(wchNum); pMessage(L"  "); k+=2;# S4 D9 G\\" w/ e0 U9 @2 R

} 
( I2 v\\" q1 G5 h! o  o
                } 
$ |6 e8 o, Q9 M7 g0 k2 t
                pMessage(L"\r\n"); k+=2;8 @7 e. B\\" ^! r$ k: D

a.BType=luStaData_int64; a.VType=luStaData_int64; a.x=k;        //按函数o的要求，返回输出的字符总数 
  W# c2 ?2 f2 p1 m
                break; 
' r7 Y8 Y1 k5 R9 B# F* G
        default: 
' R! \# N8 V$ [5 n\\" a0 o
                break;\\" U1 P5 U, Z% G8 k

} 
, F\\" ]. x  m! }' d
        return a;3 F- A! [\\" B+ u$ \  v/ D9 |+ T# \

} 
8 Z$ L7 q4 |# z
void main(void). N4 m( ?* @$ C

{ 
2 p8 l( Q' e/ b! P& }
        void *hFor;                //表达式句柄& Z. ?, m\\" G' p& e+ V* p' A

luINT nPara;                //存放表达式的自变量个数: J- c2 f5 {- k' N

LuData *pPara;                //存放输入自变量的数组指针 
; G4 x. D/ E  E5 o) x
        luINT ErrBegin,ErrEnd;        //表达式编译出错的初始位置和结束位置 
. C, k; A0 a; |$ R% L( e* ]2 k
        int ErrCode;                //错误代码 
6 O% s! N\\" U+ @& b0 v! d6 Z0 y! l
        void *v; 
& l: K. ?  L/ s* W7 h3 e/ L; C2 ^! Q
        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.]}";//字符串表达式，矩阵乘 
% P. o, ]5 U  ^; a
        //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.]}";//字符串表达式，矩阵点乘! o0 N! V; w0 ~5 p

LuData Val; 
# ]  i7 Q  y5 z: l; A) s* a
        if(!InitLu()) return;        //初始化Lu 
2 t9 W; w, g! l- K# t# T$ {
        while(LockKey(Matrix,DelMatrix,OpMatrix)){Matrix--;}        //锁定一个键，用于存储矩阵扩展类型8 T. H: q( [( V0 }

4 G% R* z: v& R+ i& _8 H' h  h' x

Val.BType=luStaData_int64; Val.VType=luStaData_int64; Val.x=Matrix;        //定义整数常量4 V& H) w: `9 q. i

SetConst(L"matrix",&Val);        //设置整数常量 
# [* I; K& q. U, a( ^: y6 R
        InsertKey("\0\0\0\0",4,luPubKey_User,LuMessage,NULL,NULL,1,v); //使Lu运行时可输出函数信息5 r; V/ @6 K1 r1 Z$ v: A7 ^

wcout.imbue(locale("chs"));        //设置输出的locale为中文 
5 @5 F3 h. v2 `( k* V' c$ y
   
. M0 M2 W, M! T. q) R! u\\" `5 D: q
        ErrCode=LuCom(ForStr,0,0,0,hFor,nPara,pPara,ErrBegin,ErrEnd); //编译表达式 
' e/ g2 Q( _- c; E  t
        if(ErrCode) 
+ ^. O, M4 N# H
        {! d' b9 s( _- z$ o: R

wcout<<L"表达式有错误！错误代码："<<ErrCode<<endl; 
  A0 x, w2 l& o8 M2 k& p2 n% Y' M& [
        }, I* E. v2 x$ ~

else\\" O' C, X, g! G0 m$ j& v  O

{8 E9 B& Q\\" l6 y3 m8 K  ]: p8 v

LuCal(hFor,pPara);        //计算表达式的值 
0 d& K- \- g/ |! C' c2 Y
        }5 D2 ^/ O$ E9 n1 a

LockKey(Matrix,NULL,OpMatrix);//解锁键Matrix，本例中，该函数可以不用 
* a- V' @7 B\\" I5 H1 Z: g; {
        FreeLu();                        //释放Lu 
8 B\\" k/ n9 D! D+ }
}

习题：

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

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

main(:a,b,c,d,t,i)=
0 |+ {4 {$ ?* u/ a, L- Z
a=new[matrix,2,2: 1.,2.,2.,1.],2 ?! e B' q0 N' K1 I
b=new[matrix,2,2: 2.,1.,1.,2.],
0 a* b' }* {, N8 T. T% j6 u/ I) a
c=new[matrix,2,2: 2/3.,-1/3.,-1/3.,2/3.],1 s! m1 w& ^0 u7 ]. W0 q; N
t=clock(),! N* x4 D5 m! O
d=a*b, i=0, while{i<1000000, d=d*c*b, i++},4 Q5 K# r, e0 n- b$ k; x2 o
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\"}";//字符串表达式

复制代码

结果：