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

查看: 8853|回复: 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>
3 ?& T7 F7 }7 T( v5 b8 E8 l4 ?1 R2 o
#include <iostream>7 h& f% p2 o. ?& `
#include <math.h>
. G2 r* G9 `* [# T- \
#include "lu32.h"1 u) g) u\\" x4 Y( U3 q' j2 n
#pragma comment( lib, "lu32.lib" ). ?9 B. \+ N- z
using namespace std;
7 X% \$ M$ P [6 k( d
//自定义矩阵: {\\" i& F7 l8 r\\" ~' R\\" V: n# r
class myMatrix
7 W1 `/ B7 W$ L! @& q- o
{. @& x6 S4 p% b( O4 e9 o
public:
1 {! g0 V% e! K7 r# z4 B5 G
double *Array; //数据缓冲区1 d7 j6 E\\" O5 P# ~# m, M
luVOID ArrayLen; //数据缓冲区长度
+ p1 f2 s6 G6 Y1 h& V\\" I
luVOID Dim[2]; //矩阵维数
- p9 j9 S9 e\\" L
myMatrix(){Array=NULL; ArrayLen=0; Dim[0]=0; Dim[1]=0;}
7 S1 n2 m; w: f* Q$ P
~myMatrix()
; r) ^4 ?& S/ Q* v- o6 P! c
{7 e1 S1 ]7 o% u( ~: _0 x; d$ S9 ]) A$ p
if(Array) delete[] Array;
, c1 |- i4 A& j }' {- R
}6 x\\" l3 @- K g4 r, V2 Y
};! d* m* m4 u: E1 s' K/ d- N\\" q9 t
luKEY Matrix=-1000; //标识矩阵类型，最终的Matrix由LockKey决定
4 ?5 J$ ]- T2 D7 W9 ?# u5 q
void _stdcall LuMessage(wchar_t *pch)//输出动态库信息，该函数注册到Lu，由Lu二级函数调用
' A& q) c$ Y0 V9 @2 d- y4 f# |
{
6 \* G W9 h; `4 _3 i
wcout<<pch;3 n* W* }0 g0 s; t\\" e
}
2 ^2 h$ R7 A p
void _stdcall DelMatrix(void *me) //用于LockKey函数及InsertKey函数，使Lu能自动销毁myMatrix对象+ n1 C, j4 p- Y& p/ ~ ]
{
Y. V# g7 c4 ^( e' b. x7 x' x
delete (myMatrix *)me; ~& F5 h$ a# ]
}! F# J! c9 I) m# w$ _4 I: u
myMatrix * _stdcall NewMatrix(luVOID m,luVOID n) //生成一个myMatrix对象
7 k0 @+ d. n1 A! q3 K
{
, z5 R; t y# l\\" P: z% C
myMatrix *pMatrix;
/ b\\" }- W. a\\" k, R* |/ C5 r
luVOID k;
+ g( g2 v( r( D# R H9 A+ F
double *pa;
/ }) Y* n2 u& r, h `
char keyname[sizeof(luVOID)];
/ G6 C0 d3 M# a+ i: Z$ W' m
void *NowKey;' f) @\\" V# X& r\\" Y2 E% R. c\\" r
k=m*n;, [ M6 m7 C( D( x1 k
pMatrix=(myMatrix *)GetBufObj(Matrix,keyname);//先尝试从缓冲区中获取一个矩阵对象
) q! l# z3 G6 B+ E1 V\\" t! q6 g
if(pMatrix)+ g4 i7 m' {3 V3 @9 B
{% R+ D+ s! `0 k4 z
if(pMatrix->ArrayLen!=k) //重置矩阵的大小
, ^& ~% x* j( X\\" t1 i
{; f; x8 U, c7 D6 Y6 @' D+ d
pa=new double[k];\\" K# _: N8 Y! u4 y# H% L
if(!pa)- L0 u8 z7 V3 e! n9 b9 v
{
( s+ a/ M4 c' Q, ~* G6 ~
DeleteKey(keyname,sizeof(luVOID),Matrix,DelMatrix,1); //将矩阵对象放回缓冲区
0 [3 L7 ]+ Z/ [/ x
return NULL;
9 i( I9 ^1 P* g- j- K
}- u$ K+ Z* L- F' W4 \; A# p, x
delete[] pMatrix->Array;
$ d0 C n8 P: Q: P4 P* B( g
pMatrix->Array=pa;( ]\\" b! `5 ]+ |4 O3 r, N\\" {
}9 g1 n& C4 x C% T
}2 L' {7 {# o8 u7 t% Q! l* }/ c9 y
else6 n! U8 d9 }$ t3 l/ Z
{, b- W* ^- R3 L
pMatrix=new myMatrix; //创建矩阵对象
: K3 o1 f4 ?) r, G# U
if(!pMatrix) return NULL;/ E4 ~( c7 H' l& m z
pMatrix->Array=new double[k];- \1 G: c& U2 v( F, G7 }1 h
if(!pMatrix->Array)
9 t4 a, J8 |5 L* F, ^# {2 a$ |
{
' q3 Y0 V% j: U2 N0 V
delete pMatrix;+ Z. J8 T% ?0 z+ H2 V2 y& c- D* S
return NULL;
3 S) o* ~8 H: S
} @ K$ r- U+ ~( g& K
if(InsertKey((char *)&pMatrix,-1,Matrix,pMatrix,DelMatrix,NULL,0,NowKey)) //将矩阵对象注册到Lu$ V& v3 l5 `$ T+ N. f/ n2 h
{
- b1 v; _& q( A8 v9 s1 \
delete pMatrix;+ ^7 Z1 T U! ~( \7 p
return NULL;% h0 F8 x% x% G/ u7 V
}5 }6 K6 ^2 y$ u- I0 b
}0 p\\" |! m\\" _1 w! ?4 ~) ~
pMatrix->ArrayLen=k; pMatrix->Dim[0]=m; pMatrix->Dim[1]=n;7 ~\\" z5 |; }6 H$ k1 S
return pMatrix;
7 g& g1 L+ E7 o+ z0 s2 r) Q/ g q
}
1 @\\" H! _, F2 F3 V7 e
LuData _stdcall OpMatrix(luINT mm,LuData *xx,void *hFor,int theOperator) //运算符重载函数，用于LockKey函数& P5 ^1 v9 }$ E; m+ Y9 h+ B( ~
{
n9 k: ?, X4 x$ f) i
LuData a;
3 l9 t( H2 s\\" n7 c! [
myMatrix *pMatrix1,*pMatrix2,*pMatrix3;; K8 ^! m; k$ A8 x F* B/ D
luVOID i,j,k,m,n,u,v;
5 i6 X/ p; W( X; a) }+ e$ B2 |
double *pa,*pb,*pc;2 R/ ` ]& a0 l7 |' ]
luMessage pMessage;2 |& C/ _# h6 o( O8 y! l, o
wchar_t wchNum[32];% n5 f, E; F2 j4 i* P
char chNum[32];. r; ~\\" A+ j( p8 Q m
a.BType=luStaData_nil; a.VType=luStaData_nil; a.x=0;, v6 L$ }8 R: t% Q# `$ I
switch(theOperator)6 J\\" I0 V( x* Z; V. r4 i9 H
{ M( G1 g) K/ U
case 2: //重载运算符*$ N; ^; K! ~. ?
pMatrix1=(myMatrix *)SearchKey((char *)&(xx->x),sizeof(luVOID),Matrix);, @$ |: _8 m- i# D' K
pMatrix2=(myMatrix *)SearchKey((char *)&((xx+1)->x),sizeof(luVOID),Matrix);; K6 ]; T [; i: x9 ~
if(!pMatrix1 || !pMatrix2) break; //对象句柄无效，不是矩阵5 L' M4 c, \) S/ I. V
if(pMatrix1->Dim[1]!=pMatrix2->Dim[0]) break; //维数不匹配) u0 Z0 S! n( G( U$ D1 M6 P# u
pMatrix3=NewMatrix(pMatrix1->Dim[0],pMatrix2->Dim[1]); //生成新矩阵
) S. ?3 V3 i9 L' Z
if(!pMatrix3) break;5 k7 z0 u, ]/ q& b\\" y4 s6 s
pa=pMatrix1->Array; pb=pMatrix2->Array; pc=pMatrix3->Array;
' U7 K1 F9 b+ T& f
m=pMatrix1->Dim[0]; n=pMatrix1->Dim[1]; k=pMatrix2->Dim[1];* k\\" C; W4 q2 [
for(i=0; i<m; i++) //矩阵乘 b. O4 b) l( X
{
: k3 l+ w# R4 o6 R
for(j=0; j<k; j++)/ D: ~) Q9 R5 H& i, W& z3 u' Q
{
2 k8 b& ]: L* T1 s
u=i*k+j; pc[u]=0.0;6 Y3 {9 Y, J9 u1 ^5 q
for (v=0; v<n; v++)
% b6 N0 g5 l4 {# Q9 p( {
{ m; u/ a2 S' J4 c3 _0 d/ b
pc[u]=pc[u]+pa[i*n+v]*pb[v*k+j];
9 E$ ~ ^4 }4 {; U0 W' ~
}& P: Z8 R9 f; |* W% j
}
% y' l% V# E( [1 a
}
; O- F* M* S7 }$ g
FunReObj(hFor); //告诉Lu，返回一个动态对象0 R3 S\\" y5 z/ {- s4 Q\\" I
a.BType=Matrix; a.VType=Matrix; a.x=0; *(luVOID *)&(a.x)=(luVOID)pMatrix3;
4 i( }# w! \. |$ |2 c* i6 b) y5 p
break;1 Z) H0 W* @! o\\" Z: r& e1 Y
case 25: //重载运算符.*
& ~: l6 n9 s1 i
pMatrix1=(myMatrix *)SearchKey((char *)&(xx->x),sizeof(luVOID),Matrix);
. L: t! A) {4 r- e
pMatrix2=(myMatrix *)SearchKey((char *)&((xx+1)->x),sizeof(luVOID),Matrix);
- {4 }3 W8 _2 L9 K5 \
if(!pMatrix1 || !pMatrix2) break; //对象句柄无效，不是矩阵! h6 E& ?( S2 s: N# o# z: q/ N6 k
if(pMatrix1->Dim[0]!=pMatrix2->Dim[0] || pMatrix1->Dim[1]!=pMatrix2->Dim[1]) break; //维数不相同\\" J% j: d& E V5 L% n/ E
pMatrix3=NewMatrix(pMatrix1->Dim[0],pMatrix1->Dim[1]); //生成新矩阵4 k\\" {\\" [/ d6 ~3 I) x2 F
if(!pMatrix3) break;. C! ]1 q' ` s4 H0 I3 V' u* z* c
for(i=0;i<pMatrix1->ArrayLen;i++) pMatrix3->Array[i]=pMatrix1->Array[i]*pMatrix2->Array[i]; //矩阵点乘
$ d. |2 }2 Z' M, @* X0 B W
FunReObj(hFor); //告诉Lu，返回一个动态对象0 f, z# D4 l! q6 B
a.BType=Matrix; a.VType=Matrix; a.x=0; *(luVOID *)&(a.x)=(luVOID)pMatrix3;
& c/ p8 |, t% J4 A, r0 G( B
break;1 B! i3 c2 j6 [; G% i0 w5 _: _; T
case 46: //重载函数new
* W0 V( {/ W4 K! Z, q* \+ ^
if(mm<2) break;\\" P1 ~3 ^# f: p/ D& V
if((xx+1)->x<1 || (xx+2)->x<1 || (xx+1)->BType!=luStaData_int64 || (xx+2)->BType!=luStaData_int64) break;! L) K) M% s3 ?
pMatrix3=NewMatrix((luVOID)(xx+1)->x,(luVOID)(xx+2)->x);//生成新矩阵# H+ E5 D\\" u. H7 e+ v% Y
if(!pMatrix3) break;! c/ N4 @! K u m- X0 e
for(j=0,i=3;i<=mm;i++,j++) //赋初值! O4 \. A& K7 M/ X. @4 ?) J; P
{
# A2 q* e; b& I+ f2 w
if(j>=pMatrix3->ArrayLen) break;
6 u6 f! i$ j( ?* A6 |+ m+ [) F
if((xx+i)->BType!=luStaData_double) break; //只接受实数参数
( o3 Z! B& M, G\\" p; m
pMatrix3->Array[j]=*(double *)&((xx+i)->x);2 d. p$ W) e; y/ {/ j\\" U
}
! l L\\" W% `1 N- Y$ v9 c! N
FunReObj(hFor); //告诉Lu，返回一个动态对象+ q( f! q: N, e; q8 `7 D! C* @& }
a.BType=Matrix; a.VType=Matrix; a.x=0; *(luVOID *)&(a.x)=(luVOID)pMatrix3;
% j/ {: y1 t, K# a* f; w
break; U6 d( w; {* E
case 49: //重载函数o% b+ D. H8 J2 S# p7 x- F
pMessage=(luMessage)SearchKey("\0\0\0\0",sizeof(luVOID),luPubKey_User);\\" a% i& S8 l: E' n
if(!pMessage) break;+ b8 z/ S! C! A* ?
pMatrix1=(myMatrix *)SearchKey((char *)&(xx->x),sizeof(luVOID),Matrix);' ~2 U4 ^& `8 e. m- X( Q! y+ ^9 {\\" t
if(!pMatrix1) break; //对象句柄无效，不是矩阵
$ Q5 v8 d8 u2 g0 y+ x( d
pa=pMatrix1->Array;
/ e6 T- ~4 j- Z* o: g9 h/ S( Y
m=pMatrix1->Dim[0]; n=pMatrix1->Dim[1]; k=0;
+ o6 i% Z) |. i) q
for(i=0; i<m; i++) //输出矩阵\\" z5 @/ H' w: N5 ^: |: s
{, D: k- v. w( x& p5 p% {( S5 g
pMessage(L"\r\n"); k+=2;4 ` |5 r$ j z; r
for(j=0; j<n; j++)% ^( i1 ?' r1 R9 G- z( G
{
# z$ \: K\\" V+ G\\" k
_gcvt_s(chNum,pa[i*n+j],16);- b2 X) d t. l; ?# B
for(u=0;chNum[u];u++) {wchNum[u]=chNum[u]; k++;}0 K2 C9 \2 I u
wchNum[u]='\0';/ P- Q+ l7 r/ R# U+ c! \ Q. j$ G# v
pMessage(wchNum); pMessage(L" "); k+=2;
/ s0 W2 D, X- R- h6 h1 s
}) R j2 c1 w) r0 y3 ?) j8 P* R$ w
}\\" b' B( ]2 G' N, t
pMessage(L"\r\n"); k+=2;. K; g\\" U8 j+ Y, D. V# r
a.BType=luStaData_int64; a.VType=luStaData_int64; a.x=k; //按函数o的要求，返回输出的字符总数
' F( T- x8 R9 h6 O% w3 H. c
break;; q$ A; }& |# B) _4 B! _' h1 g9 o
default:& ~8 Q, H; S9 y3 l* a8 i
break;
7 e8 ^6 g. E8 `2 Z
}
. D, b$ v0 v& @7 A6 }$ |4 O
return a;; ~% v/ G6 i9 @! `
}
V* h E' x7 n, e$ M: [
void main(void)3 A6 H2 b: L5 S! E
{; A8 t4 k y7 t2 p. M
void *hFor; //表达式句柄
- n$ C! b O\\" x- r# s
luINT nPara; //存放表达式的自变量个数
\\" ?; f. b+ G( ~# k) S$ k
LuData *pPara; //存放输入自变量的数组指针
4 ?( `/ ~$ u# T
luINT ErrBegin,ErrEnd; //表达式编译出错的初始位置和结束位置5 ?4 ^- l) b+ n2 h. n4 b# D* l+ U
int ErrCode; //错误代码
7 v$ @9 Q, c0 O- X\\" h
void *v;$ S' O8 f0 i# P( e2 L0 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.]}";//字符串表达式，矩阵乘8 {/ i; p$ ~6 c. L1 \7 i0 z\\" Z
//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.]}";//字符串表达式，矩阵点乘
& s5 c' A3 z) f |\\" h8 Z\\" \5 C% `
LuData Val;
( r2 Z- k5 A. \! J, \6 W7 s# Z
if(!InitLu()) return; //初始化Lu q\\" A2 z& [( \\\" B0 m# a
while(LockKey(Matrix,DelMatrix,OpMatrix)){Matrix--;} //锁定一个键，用于存储矩阵扩展类型, e6 e# N6 _/ u) C4 V/ |/ Y+ y
0 S: \. Y& I+ ]. A; `
Val.BType=luStaData_int64; Val.VType=luStaData_int64; Val.x=Matrix; //定义整数常量
* L; v( v5 l) G3 O/ D( t7 _
SetConst(L"matrix",&Val); //设置整数常量5 f, ~6 D. X, O
InsertKey("\0\0\0\0",4,luPubKey_User,LuMessage,NULL,NULL,1,v); //使Lu运行时可输出函数信息
7 n- E9 ^; _. H, B* B* s
wcout.imbue(locale("chs")); //设置输出的locale为中文 X A% i+ l$ i5 o\\" S
8 I, E ]$ p( T+ R9 s
ErrCode=LuCom(ForStr,0,0,0,hFor,nPara,pPara,ErrBegin,ErrEnd); //编译表达式
+ |( ~- S0 U% X1 K8 A2 g: {
if(ErrCode)
* F( N+ ~0 r: X; T4 x* X
{
3 O% v( r, @; x s9 y/ Y
wcout<<L"表达式有错误！错误代码："<<ErrCode<<endl;* Y1 A& P% ~9 u9 f% q
}. m- y( ] W( g\\" q
else
- Q\\" Q& E# c( U
{
- `7 t5 ~: ~' h h& _& ]
LuCal(hFor,pPara); //计算表达式的值) `4 P' t3 s9 r' ]\\" }/ x
}- `3 T$ z; S& |3 h! w6 m
LockKey(Matrix,NULL,OpMatrix);//解锁键Matrix，本例中，该函数可以不用
& v5 {3 O* Y% Y- D& |\\" `# S/ H
FreeLu(); //释放Lu
% h7 d5 H/ P5 ]* R& w
}

#include <windows.h> 
3 ?& T7 F7 }7 T( v5 b8 E8 l4 ?1 R2 o
#include <iostream>7 h& f% p2 o. ?& `

#include <math.h> 
. G2 r* G9 `* [# T- \
#include "lu32.h"1 u) g) u\\" x4 Y( U3 q' j2 n

#pragma comment( lib, "lu32.lib" ). ?9 B. \+ N- z

using namespace std; 
7 X% \$ M$ P  [6 k( d
//自定义矩阵: {\\" i& F7 l8 r\\" ~' R\\" V: n# r

class myMatrix 
7 W1 `/ B7 W$ L! @& q- o
{. @& x6 S4 p% b( O4 e9 o

public: 
1 {! g0 V% e! K7 r# z4 B5 G
        double *Array;        //数据缓冲区1 d7 j6 E\\" O5 P# ~# m, M

luVOID ArrayLen;        //数据缓冲区长度 
+ p1 f2 s6 G6 Y1 h& V\\" I
        luVOID Dim[2];        //矩阵维数 
- p9 j9 S9 e\\" L
        myMatrix(){Array=NULL; ArrayLen=0; Dim[0]=0; Dim[1]=0;} 
7 S1 n2 m; w: f* Q$ P
        ~myMatrix() 
; r) ^4 ?& S/ Q* v- o6 P! c
        {7 e1 S1 ]7 o% u( ~: _0 x; d$ S9 ]) A$ p

if(Array) delete[] Array; 
, c1 |- i4 A& j  }' {- R
        }6 x\\" l3 @- K  g4 r, V2 Y

};! d* m* m4 u: E1 s' K/ d- N\\" q9 t

luKEY Matrix=-1000;        //标识矩阵类型，最终的Matrix由LockKey决定 
4 ?5 J$ ]- T2 D7 W9 ?# u5 q
void _stdcall LuMessage(wchar_t *pch)//输出动态库信息，该函数注册到Lu，由Lu二级函数调用 
' A& q) c$ Y0 V9 @2 d- y4 f# |
{ 
6 \* G  W9 h; `4 _3 i
        wcout<<pch;3 n* W* }0 g0 s; t\\" e

} 
2 ^2 h$ R7 A  p
void _stdcall DelMatrix(void *me)        //用于LockKey函数及InsertKey函数，使Lu能自动销毁myMatrix对象+ n1 C, j4 p- Y& p/ ~  ]

{ 
  Y. V# g7 c4 ^( e' b. x7 x' x
        delete (myMatrix *)me;  ~& F5 h$ a# ]

}! F# J! c9 I) m# w$ _4 I: u

myMatrix * _stdcall NewMatrix(luVOID m,luVOID n)        //生成一个myMatrix对象 
7 k0 @+ d. n1 A! q3 K
{ 
, z5 R; t  y# l\\" P: z% C
        myMatrix *pMatrix; 
/ b\\" }- W. a\\" k, R* |/ C5 r
        luVOID k; 
+ g( g2 v( r( D# R  H9 A+ F
        double *pa; 
/ }) Y* n2 u& r, h  `
        char keyname[sizeof(luVOID)]; 
/ G6 C0 d3 M# a+ i: Z$ W' m
        void *NowKey;' f) @\\" V# X& r\\" Y2 E% R. c\\" r

k=m*n;, [  M6 m7 C( D( x1 k

pMatrix=(myMatrix *)GetBufObj(Matrix,keyname);//先尝试从缓冲区中获取一个矩阵对象 
) q! l# z3 G6 B+ E1 V\\" t! q6 g
        if(pMatrix)+ g4 i7 m' {3 V3 @9 B

{% R+ D+ s! `0 k4 z

if(pMatrix->ArrayLen!=k)        //重置矩阵的大小 
, ^& ~% x* j( X\\" t1 i
                {; f; x8 U, c7 D6 Y6 @' D+ d

pa=new double[k];\\" K# _: N8 Y! u4 y# H% L

if(!pa)- L0 u8 z7 V3 e! n9 b9 v

{ 
( s+ a/ M4 c' Q, ~* G6 ~
                                DeleteKey(keyname,sizeof(luVOID),Matrix,DelMatrix,1);        //将矩阵对象放回缓冲区 
0 [3 L7 ]+ Z/ [/ x
                                return NULL; 
9 i( I9 ^1 P* g- j- K
                        }- u$ K+ Z* L- F' W4 \; A# p, x

delete[] pMatrix->Array; 
$ d0 C  n8 P: Q: P4 P* B( g
                        pMatrix->Array=pa;( ]\\" b! `5 ]+ |4 O3 r, N\\" {

}9 g1 n& C4 x  C% T

}2 L' {7 {# o8 u7 t% Q! l* }/ c9 y

else6 n! U8 d9 }$ t3 l/ Z

{, b- W* ^- R3 L

pMatrix=new myMatrix;        //创建矩阵对象 
: K3 o1 f4 ?) r, G# U
                if(!pMatrix) return NULL;/ E4 ~( c7 H' l& m  z

pMatrix->Array=new double[k];- \1 G: c& U2 v( F, G7 }1 h

if(!pMatrix->Array) 
9 t4 a, J8 |5 L* F, ^# {2 a$ |
                { 
' q3 Y0 V% j: U2 N0 V
                        delete pMatrix;+ Z. J8 T% ?0 z+ H2 V2 y& c- D* S

return NULL; 
3 S) o* ~8 H: S
                }  @  K$ r- U+ ~( g& K

if(InsertKey((char *)&pMatrix,-1,Matrix,pMatrix,DelMatrix,NULL,0,NowKey))        //将矩阵对象注册到Lu$ V& v3 l5 `$ T+ N. f/ n2 h

{ 
- b1 v; _& q( A8 v9 s1 \
                        delete pMatrix;+ ^7 Z1 T  U! ~( \7 p

return NULL;% h0 F8 x% x% G/ u7 V

}5 }6 K6 ^2 y$ u- I0 b

}0 p\\" |! m\\" _1 w! ?4 ~) ~

pMatrix->ArrayLen=k; pMatrix->Dim[0]=m; pMatrix->Dim[1]=n;7 ~\\" z5 |; }6 H$ k1 S

return pMatrix; 
7 g& g1 L+ E7 o+ z0 s2 r) Q/ g  q
} 
1 @\\" H! _, F2 F3 V7 e
LuData _stdcall OpMatrix(luINT mm,LuData *xx,void *hFor,int theOperator)        //运算符重载函数，用于LockKey函数& P5 ^1 v9 }$ E; m+ Y9 h+ B( ~

{ 
  n9 k: ?, X4 x$ f) i
        LuData a; 
3 l9 t( H2 s\\" n7 c! [
        myMatrix *pMatrix1,*pMatrix2,*pMatrix3;; K8 ^! m; k$ A8 x  F* B/ D

luVOID i,j,k,m,n,u,v; 
5 i6 X/ p; W( X; a) }+ e$ B2 |
        double *pa,*pb,*pc;2 R/ `  ]& a0 l7 |' ]

luMessage pMessage;2 |& C/ _# h6 o( O8 y! l, o

wchar_t wchNum[32];% n5 f, E; F2 j4 i* P

char chNum[32];. r; ~\\" A+ j( p8 Q  m

a.BType=luStaData_nil; a.VType=luStaData_nil; a.x=0;, v6 L$ }8 R: t% Q# `$ I

switch(theOperator)6 J\\" I0 V( x* Z; V. r4 i9 H

{  M( G1 g) K/ U

case 2:        //重载运算符*$ N; ^; K! ~. ?

pMatrix1=(myMatrix *)SearchKey((char *)&(xx->x),sizeof(luVOID),Matrix);, @$ |: _8 m- i# D' K

pMatrix2=(myMatrix *)SearchKey((char *)&((xx+1)->x),sizeof(luVOID),Matrix);; K6 ]; T  [; i: x9 ~

if(!pMatrix1 || !pMatrix2) break;        //对象句柄无效，不是矩阵5 L' M4 c, \) S/ I. V

if(pMatrix1->Dim[1]!=pMatrix2->Dim[0]) break;        //维数不匹配) u0 Z0 S! n( G( U$ D1 M6 P# u

pMatrix3=NewMatrix(pMatrix1->Dim[0],pMatrix2->Dim[1]);        //生成新矩阵 
) S. ?3 V3 i9 L' Z
                if(!pMatrix3) break;5 k7 z0 u, ]/ q& b\\" y4 s6 s

pa=pMatrix1->Array; pb=pMatrix2->Array; pc=pMatrix3->Array; 
' U7 K1 F9 b+ T& f
                m=pMatrix1->Dim[0]; n=pMatrix1->Dim[1]; k=pMatrix2->Dim[1];* k\\" C; W4 q2 [

for(i=0; i<m; i++)        //矩阵乘  b. O4 b) l( X

{ 
: k3 l+ w# R4 o6 R
                        for(j=0; j<k; j++)/ D: ~) Q9 R5 H& i, W& z3 u' Q

{ 
2 k8 b& ]: L* T1 s
                                u=i*k+j; pc[u]=0.0;6 Y3 {9 Y, J9 u1 ^5 q

for (v=0; v<n; v++) 
% b6 N0 g5 l4 {# Q9 p( {
                                {  m; u/ a2 S' J4 c3 _0 d/ b

pc[u]=pc[u]+pa[i*n+v]*pb[v*k+j]; 
9 E$ ~  ^4 }4 {; U0 W' ~
                                }& P: Z8 R9 f; |* W% j

} 
% y' l% V# E( [1 a
                } 
; O- F* M* S7 }$ g
                FunReObj(hFor);        //告诉Lu，返回一个动态对象0 R3 S\\" y5 z/ {- s4 Q\\" I

a.BType=Matrix; a.VType=Matrix; a.x=0; *(luVOID *)&(a.x)=(luVOID)pMatrix3; 
4 i( }# w! \. |$ |2 c* i6 b) y5 p
                break;1 Z) H0 W* @! o\\" Z: r& e1 Y

case 25:        //重载运算符.* 
& ~: l6 n9 s1 i
                pMatrix1=(myMatrix *)SearchKey((char *)&(xx->x),sizeof(luVOID),Matrix); 
. L: t! A) {4 r- e
                pMatrix2=(myMatrix *)SearchKey((char *)&((xx+1)->x),sizeof(luVOID),Matrix); 
- {4 }3 W8 _2 L9 K5 \
                if(!pMatrix1 || !pMatrix2) break;        //对象句柄无效，不是矩阵! h6 E& ?( S2 s: N# o# z: q/ N6 k

if(pMatrix1->Dim[0]!=pMatrix2->Dim[0] || pMatrix1->Dim[1]!=pMatrix2->Dim[1]) break;        //维数不相同\\" J% j: d& E  V5 L% n/ E

pMatrix3=NewMatrix(pMatrix1->Dim[0],pMatrix1->Dim[1]);        //生成新矩阵4 k\\" {\\" [/ d6 ~3 I) x2 F

if(!pMatrix3) break;. C! ]1 q' `  s4 H0 I3 V' u* z* c

for(i=0;i<pMatrix1->ArrayLen;i++) pMatrix3->Array[i]=pMatrix1->Array[i]*pMatrix2->Array[i];        //矩阵点乘 
$ d. |2 }2 Z' M, @* X0 B  W
                FunReObj(hFor);        //告诉Lu，返回一个动态对象0 f, z# D4 l! q6 B

a.BType=Matrix; a.VType=Matrix; a.x=0; *(luVOID *)&(a.x)=(luVOID)pMatrix3; 
& c/ p8 |, t% J4 A, r0 G( B
                break;1 B! i3 c2 j6 [; G% i0 w5 _: _; T

case 46:        //重载函数new 
* W0 V( {/ W4 K! Z, q* \+ ^
                if(mm<2) break;\\" P1 ~3 ^# f: p/ D& V

if((xx+1)->x<1 || (xx+2)->x<1 || (xx+1)->BType!=luStaData_int64 || (xx+2)->BType!=luStaData_int64) break;! L) K) M% s3 ?

pMatrix3=NewMatrix((luVOID)(xx+1)->x,(luVOID)(xx+2)->x);//生成新矩阵# H+ E5 D\\" u. H7 e+ v% Y

if(!pMatrix3) break;! c/ N4 @! K  u  m- X0 e

for(j=0,i=3;i<=mm;i++,j++)        //赋初值! O4 \. A& K7 M/ X. @4 ?) J; P

{ 
# A2 q* e; b& I+ f2 w
                        if(j>=pMatrix3->ArrayLen) break; 
6 u6 f! i$ j( ?* A6 |+ m+ [) F
                        if((xx+i)->BType!=luStaData_double) break;        //只接受实数参数 
( o3 Z! B& M, G\\" p; m
                        pMatrix3->Array[j]=*(double *)&((xx+i)->x);2 d. p$ W) e; y/ {/ j\\" U

} 
! l  L\\" W% `1 N- Y$ v9 c! N
                FunReObj(hFor);        //告诉Lu，返回一个动态对象+ q( f! q: N, e; q8 `7 D! C* @& }

a.BType=Matrix; a.VType=Matrix; a.x=0; *(luVOID *)&(a.x)=(luVOID)pMatrix3; 
% j/ {: y1 t, K# a* f; w
                break;  U6 d( w; {* E

case 49:        //重载函数o% b+ D. H8 J2 S# p7 x- F

pMessage=(luMessage)SearchKey("\0\0\0\0",sizeof(luVOID),luPubKey_User);\\" a% i& S8 l: E' n

if(!pMessage) break;+ b8 z/ S! C! A* ?

pMatrix1=(myMatrix *)SearchKey((char *)&(xx->x),sizeof(luVOID),Matrix);' ~2 U4 ^& `8 e. m- X( Q! y+ ^9 {\\" t

if(!pMatrix1) break;        //对象句柄无效，不是矩阵 
$ Q5 v8 d8 u2 g0 y+ x( d
                pa=pMatrix1->Array; 
/ e6 T- ~4 j- Z* o: g9 h/ S( Y
                m=pMatrix1->Dim[0]; n=pMatrix1->Dim[1]; k=0; 
+ o6 i% Z) |. i) q
                for(i=0; i<m; i++)        //输出矩阵\\" z5 @/ H' w: N5 ^: |: s

{, D: k- v. w( x& p5 p% {( S5 g

pMessage(L"\r\n"); k+=2;4 `  |5 r$ j  z; r

for(j=0; j<n; j++)% ^( i1 ?' r1 R9 G- z( G

{ 
# z$ \: K\\" V+ G\\" k
                                _gcvt_s(chNum,pa[i*n+j],16);- b2 X) d  t. l; ?# B

for(u=0;chNum[u];u++) {wchNum[u]=chNum[u]; k++;}0 K2 C9 \2 I  u

wchNum[u]='\0';/ P- Q+ l7 r/ R# U+ c! \  Q. j$ G# v

pMessage(wchNum); pMessage(L"  "); k+=2; 
/ s0 W2 D, X- R- h6 h1 s
                        }) R  j2 c1 w) r0 y3 ?) j8 P* R$ w

}\\" b' B( ]2 G' N, t

pMessage(L"\r\n"); k+=2;. K; g\\" U8 j+ Y, D. V# r

a.BType=luStaData_int64; a.VType=luStaData_int64; a.x=k;        //按函数o的要求，返回输出的字符总数 
' F( T- x8 R9 h6 O% w3 H. c
                break;; q$ A; }& |# B) _4 B! _' h1 g9 o

default:& ~8 Q, H; S9 y3 l* a8 i

break; 
7 e8 ^6 g. E8 `2 Z
        } 
. D, b$ v0 v& @7 A6 }$ |4 O
        return a;; ~% v/ G6 i9 @! `

} 
  V* h  E' x7 n, e$ M: [
void main(void)3 A6 H2 b: L5 S! E

{; A8 t4 k  y7 t2 p. M

void *hFor;                //表达式句柄 
- n$ C! b  O\\" x- r# s
        luINT nPara;                //存放表达式的自变量个数 
\\" ?; f. b+ G( ~# k) S$ k
        LuData *pPara;                //存放输入自变量的数组指针 
4 ?( `/ ~$ u# T
        luINT ErrBegin,ErrEnd;        //表达式编译出错的初始位置和结束位置5 ?4 ^- l) b+ n2 h. n4 b# D* l+ U

int ErrCode;                //错误代码 
7 v$ @9 Q, c0 O- X\\" h
        void *v;$ S' O8 f0 i# P( e2 L0 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.]}";//字符串表达式，矩阵乘8 {/ i; p$ ~6 c. L1 \7 i0 z\\" Z

//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.]}";//字符串表达式，矩阵点乘 
& s5 c' A3 z) f  |\\" h8 Z\\" \5 C% `
        LuData Val; 
( r2 Z- k5 A. \! J, \6 W7 s# Z
        if(!InitLu()) return;        //初始化Lu  q\\" A2 z& [( \\\" B0 m# a

while(LockKey(Matrix,DelMatrix,OpMatrix)){Matrix--;}        //锁定一个键，用于存储矩阵扩展类型, e6 e# N6 _/ u) C4 V/ |/ Y+ y

0 S: \. Y& I+ ]. A; `

Val.BType=luStaData_int64; Val.VType=luStaData_int64; Val.x=Matrix;        //定义整数常量 
* L; v( v5 l) G3 O/ D( t7 _
        SetConst(L"matrix",&Val);        //设置整数常量5 f, ~6 D. X, O

InsertKey("\0\0\0\0",4,luPubKey_User,LuMessage,NULL,NULL,1,v); //使Lu运行时可输出函数信息 
7 n- E9 ^; _. H, B* B* s
        wcout.imbue(locale("chs"));        //设置输出的locale为中文  X  A% i+ l$ i5 o\\" S

8 I, E  ]$ p( T+ R9 s
        ErrCode=LuCom(ForStr,0,0,0,hFor,nPara,pPara,ErrBegin,ErrEnd); //编译表达式 
+ |( ~- S0 U% X1 K8 A2 g: {
        if(ErrCode) 
* F( N+ ~0 r: X; T4 x* X
        { 
3 O% v( r, @; x  s9 y/ Y
                wcout<<L"表达式有错误！错误代码："<<ErrCode<<endl;* Y1 A& P% ~9 u9 f% q

}. m- y( ]  W( g\\" q

else 
- Q\\" Q& E# c( U
        { 
- `7 t5 ~: ~' h  h& _& ]
                LuCal(hFor,pPara);        //计算表达式的值) `4 P' t3 s9 r' ]\\" }/ x

}- `3 T$ z; S& |3 h! w6 m

LockKey(Matrix,NULL,OpMatrix);//解锁键Matrix，本例中，该函数可以不用 
& v5 {3 O* Y% Y- D& |\\" `# S/ H
        FreeLu();                        //释放Lu 
% h7 d5 H/ P5 ]* R& w
}

习题：

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

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

main(:a,b,c,d,t,i)=; R9 L: R. t O: G
a=new[matrix,2,2: 1.,2.,2.,1.],1 q5 {7 x5 o1 i+ e: ^# M! L. ]! U
b=new[matrix,2,2: 2.,1.,1.,2.],
' C0 ~1 a: w) j
c=new[matrix,2,2: 2/3.,-1/3.,-1/3.,2/3.],
T+ ~/ V: u4 j6 @' v
t=clock(),. r5 V) e) z( c6 D
d=a*b, i=0, while{i<1000000, d=d*c*b, i++},
\- @/ N2 {$ O( X% L* }
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\"}";//字符串表达式

复制代码

结果：