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

查看: 8634|回复: 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>
, q3 k# i# a2 A% ?6 o2 k
#include <iostream>4 i5 y\\" ]' o- W
#include <math.h>1 E- ~; o) a, H3 \' r
#include "lu32.h"
#pragma comment( lib, "lu32.lib" )
3 l0 s$ o2 E2 x6 [& s
using namespace std;. W3 z7 o) l) B- t. j: b
//自定义矩阵, Q$ j, @9 t6 {' i( r
class myMatrix
+ e+ m( n, K# y1 x! _
{
2 `& q6 h( M& C8 f* O* I- I
public:% b- e1 K# e ?! ?' w4 l6 G
double *Array; //数据缓冲区% v& ~3 H( \# Q# x( j7 Z. T6 C
luVOID ArrayLen; //数据缓冲区长度2 q3 a) ?$ S7 E* I: x
luVOID Dim[2]; //矩阵维数4 ]) e' C5 y8 z
myMatrix(){Array=NULL; ArrayLen=0; Dim[0]=0; Dim[1]=0;}% L) S: ?5 n7 ~7 {& {9 S4 n8 h8 m
~myMatrix(), V4 u, w7 P |4 C$ p7 z
{$ }+ G\\" b0 X: Q- f. j
if(Array) delete[] Array;
- ?3 T: Y) {8 A% R4 ?2 ?
}\\" E% q/ l+ q2 _ h5 I/ s
};* Z$ Q' w7 b+ L0 s/ S
luKEY Matrix=-1000; //标识矩阵类型，最终的Matrix由LockKey决定/ Z% o- ~1 v3 O\\" h; G7 y
void _stdcall LuMessage(wchar_t *pch)//输出动态库信息，该函数注册到Lu，由Lu二级函数调用 : A. O- F$ V+ H G1 _0 ?
{( {1 A5 W9 \4 b* r
wcout<<pch;
2 ]\\" Q3 ^, r; i+ r. C
}
) P7 @3 L8 _% Z( R
void _stdcall DelMatrix(void *me) //用于LockKey函数及InsertKey函数，使Lu能自动销毁myMatrix对象
/ ]; e N+ M6 d3 @3 K
{
delete (myMatrix *)me;5 O$ z+ k: x9 P- v$ P7 Z
}9 P' O& U\\" t1 M+ r
myMatrix * _stdcall NewMatrix(luVOID m,luVOID n) //生成一个myMatrix对象) k. [* H+ `9 N/ k
{% O: ?! P. p; Q& }! S4 L3 m\\" A
myMatrix *pMatrix;
( Y, e9 V9 q& a6 ~9 W# Q0 I% H# ]
luVOID k;% b2 O\\" p: e% n. h, {* Z\\" M
double *pa;2 @: z2 c: d+ b/ n* }* a
char keyname[sizeof(luVOID)];1 ?( }1 F; J+ T
void *NowKey;
+ u! T! e5 Y\\" d6 ~% I2 n$ F* ?, o
k=m*n;
; [+ |) o& q) N) ?/ L
pMatrix=(myMatrix *)GetBufObj(Matrix,keyname);//先尝试从缓冲区中获取一个矩阵对象\\" |3 s, F. G0 q% }\\" t* r8 W
if(pMatrix)
+ k( N' [$ J\\" M4 a# N
{: f! C7 j) G1 S: a! m x& H\\" i\\" W; h
if(pMatrix->ArrayLen!=k) //重置矩阵的大小
- ~' f# Y$ Z# I/ O
{# e+ q3 t' W5 k5 ?, k3 ?
pa=new double[k];
: w0 F7 {# r6 _0 e4 B. o
if(!pa)7 K8 p1 d, e- b0 X0 B\\" {: @7 u8 P7 I& H
{5 j# b% e: R& i9 N9 c1 n
DeleteKey(keyname,sizeof(luVOID),Matrix,DelMatrix,1); //将矩阵对象放回缓冲区/ y* m$ y9 p) j) e7 b6 I# V$ ~4 w* h) q
return NULL;, C, [2 E2 Q3 Z9 t
}
( L% U/ Y/ ]4 }# a\\" n! e+ W
delete[] pMatrix->Array;! k# {( X! d1 U. S
pMatrix->Array=pa;' L\\" ^1 D' k, v- ]! r8 h
}
( U' ]) @% T9 ]# {& t$ S
}! j( D: z7 f# Y8 }
else: C\\" l1 d& ~- r' C
{
: B: V9 H1 K' Z! L9 {
pMatrix=new myMatrix; //创建矩阵对象
\\" {! c$ k: b1 ^$ D5 m4 u
if(!pMatrix) return NULL;
$ Z0 s8 M! P% @
pMatrix->Array=new double[k];# m7 E2 V8 n V+ D i+ d3 C; b
if(!pMatrix->Array)7 U5 K& @/ k; p- I- b7 p
{
! p U5 n2 C& ~& H4 }
delete pMatrix;: p) `8 k( r6 y7 m- r# p
return NULL;4 G3 G7 O* I% z6 |# s5 R$ F\\" i/ O' F
}
5 j x5 h7 C+ A, M8 l
if(InsertKey((char *)&pMatrix,-1,Matrix,pMatrix,DelMatrix,NULL,0,NowKey)) //将矩阵对象注册到Lu9 d% F) h* o ^3 p- M. B
{
9 v1 P' y\\" N: H, c) E' c
delete pMatrix;* b) C0 y$ U6 ~) b/ V
return NULL;
# q2 s3 x/ |% P2 A& G
}
}) L3 ~( V0 u! _; s h
pMatrix->ArrayLen=k; pMatrix->Dim[0]=m; pMatrix->Dim[1]=n;
9 V\\" f) B* D% n; C& u4 f
return pMatrix;! g# ^' k2 _ a+ k. q
}
: Y5 @& z0 ]+ ]\\" J* B: U
LuData _stdcall OpMatrix(luINT mm,LuData *xx,void *hFor,int theOperator) //运算符重载函数，用于LockKey函数& Z\\" u3 z\\" G\\" ?% s8 _4 s1 u
{
* p* p/ y9 K# ^5 O1 Y: @$ `6 n
LuData a;
@, ]5 o3 l4 @' |; z
myMatrix *pMatrix1,*pMatrix2,*pMatrix3;
' f! C$ j\\" J) H# Y( ]
luVOID i,j,k,m,n,u,v;
3 _; Q) A+ W/ U
double *pa,*pb,*pc;# ^$ `( w* Q\\" J* z- t
luMessage pMessage;\\" t0 j% O/ J: c& `' ~
wchar_t wchNum[32];
( W! i2 r K3 ?# y
char chNum[32];
0 H' s' _8 r2 i
a.BType=luStaData_nil; a.VType=luStaData_nil; a.x=0;\\" X\\" H: C$ O% @% o* R- T
switch(theOperator)
' [9 @6 W5 R) r0 D
{
% ]8 Y* o0 d/ M4 O Z
case 2: //重载运算符*
, N5 E/ ~. u' U3 L
pMatrix1=(myMatrix *)SearchKey((char *)&(xx->x),sizeof(luVOID),Matrix);$ X. x& d& p9 i7 r
pMatrix2=(myMatrix *)SearchKey((char *)&((xx+1)->x),sizeof(luVOID),Matrix);( r5 S, e/ `6 O7 b+ }) i. U
if(!pMatrix1 || !pMatrix2) break; //对象句柄无效，不是矩阵# C I8 F7 h0 x1 F/ T5 Z
if(pMatrix1->Dim[1]!=pMatrix2->Dim[0]) break; //维数不匹配6 B/ u$ g7 U0 Y9 R
pMatrix3=NewMatrix(pMatrix1->Dim[0],pMatrix2->Dim[1]); //生成新矩阵. |, C. u! L( {. ?( T0 J
if(!pMatrix3) break;
\\" q, e$ e3 u2 y( D# N G2 W0 y
pa=pMatrix1->Array; pb=pMatrix2->Array; pc=pMatrix3->Array;
4 d a; x8 }4 c
m=pMatrix1->Dim[0]; n=pMatrix1->Dim[1]; k=pMatrix2->Dim[1];
6 W( F* ~! G K/ L8 `1 I
for(i=0; i<m; i++) //矩阵乘
, C8 X5 F8 n! h5 \6 u# I
{
' P' v' m# g7 ?: D
for(j=0; j<k; j++)
! M- ?' D5 \2 U. ^
{& U, Q% q2 b8 f# L4 r- B8 _0 T) I
u=i*k+j; pc[u]=0.0;& }( d- _0 n! e7 X- d# J
for (v=0; v<n; v++)
4 w/ V2 B/ M( a. I6 ?\\" p
{
3 q/ x) Q( W\\" t: N% i; h* A* X
pc[u]=pc[u]+pa[i*n+v]*pb[v*k+j];0 l( Y! `4 W4 x9 g# O& }! `
}; ~7 W: o6 i. f1 a2 Q8 M7 q
}
/ @5 V& ~$ r9 w5 d+ Q+ [9 h4 M: G
}
& ?# Q- _* ~$ S* n$ |
FunReObj(hFor); //告诉Lu，返回一个动态对象
7 I\\" k/ W8 r4 l; _
a.BType=Matrix; a.VType=Matrix; a.x=0; *(luVOID *)&(a.x)=(luVOID)pMatrix3;
/ q l- |8 T, l e. s
break;
% V3 }/ Q; r, M: y* ?
case 25: //重载运算符.*
9 k9 c1 U s) f& ?$ z& a8 N
pMatrix1=(myMatrix *)SearchKey((char *)&(xx->x),sizeof(luVOID),Matrix);
( x, Z$ w1 F4 F/ e/ \/ t3 F
pMatrix2=(myMatrix *)SearchKey((char *)&((xx+1)->x),sizeof(luVOID),Matrix);4 e6 D0 G0 S( P% K4 V
if(!pMatrix1 || !pMatrix2) break; //对象句柄无效，不是矩阵7 E2 b4 X6 j% h1 R% p1 }( Y/ x. L: x
if(pMatrix1->Dim[0]!=pMatrix2->Dim[0] || pMatrix1->Dim[1]!=pMatrix2->Dim[1]) break; //维数不相同
% v; T2 i! Z8 k( q- }
pMatrix3=NewMatrix(pMatrix1->Dim[0],pMatrix1->Dim[1]); //生成新矩阵
7 o6 ?& M% A: F# P
if(!pMatrix3) break;! U7 |) T: Q6 ^# c/ ^- @1 V
for(i=0;i<pMatrix1->ArrayLen;i++) pMatrix3->Array[i]=pMatrix1->Array[i]*pMatrix2->Array[i]; //矩阵点乘2 O2 [- S' U# q' Z! Y' _+ r
FunReObj(hFor); //告诉Lu，返回一个动态对象
+ y# }) F+ P9 c7 U7 V4 s/ y
a.BType=Matrix; a.VType=Matrix; a.x=0; *(luVOID *)&(a.x)=(luVOID)pMatrix3;7 k( ?& C/ ?+ z: J. z4 r
break;
( `3 G7 H7 ^* m/ v
case 46: //重载函数new# [- M5 p6 Y& F
if(mm<2) break;! l8 D+ q; ]) D L
if((xx+1)->x<1 || (xx+2)->x<1 || (xx+1)->BType!=luStaData_int64 || (xx+2)->BType!=luStaData_int64) break;
0 R' B8 R7 i/ j
pMatrix3=NewMatrix((luVOID)(xx+1)->x,(luVOID)(xx+2)->x);//生成新矩阵
% I: X6 Q3 S; S) D, b: y
if(!pMatrix3) break;) {/ U; L6 {5 J0 y! ]
for(j=0,i=3;i<=mm;i++,j++) //赋初值
5 E, z+ K\\" |2 S
{& w! D- d% I; W6 H: j+ W
if(j>=pMatrix3->ArrayLen) break;
: F( `\\" D$ ~\\" e3 A% q5 h' [
if((xx+i)->BType!=luStaData_double) break; //只接受实数参数. S6 y# c0 a) O: j8 j$ S
pMatrix3->Array[j]=*(double *)&((xx+i)->x);
2 q3 e3 B% P4 q* q }% l# O
}8 [/ y1 _\\" i\\" K8 A9 x2 }
FunReObj(hFor); //告诉Lu，返回一个动态对象3 u X9 m* R1 |$ x1 b
a.BType=Matrix; a.VType=Matrix; a.x=0; *(luVOID *)&(a.x)=(luVOID)pMatrix3;$ \0 L1 g9 N7 v3 N3 h4 @6 \1 `
break;
, S( S( Y8 |5 ~3 t
case 49: //重载函数o
( ~$ q! A, V* J# d* F$ ?\\" Z
pMessage=(luMessage)SearchKey("\0\0\0\0",sizeof(luVOID),luPubKey_User);
7 n5 f& D4 j: T; r
if(!pMessage) break;
# W1 a6 g/ s, A4 S
pMatrix1=(myMatrix *)SearchKey((char *)&(xx->x),sizeof(luVOID),Matrix);
6 e; }( [7 ~( ?- j( {+ U
if(!pMatrix1) break; //对象句柄无效，不是矩阵\\" O$ G/ t, @3 ~4 P/ R9 w8 Y
pa=pMatrix1->Array; b# _/ j3 O- M/ O
m=pMatrix1->Dim[0]; n=pMatrix1->Dim[1]; k=0;$ E/ Z\\" u4 c/ N8 b
for(i=0; i<m; i++) //输出矩阵' I( U* r, i/ E Q0 l\\" g! {/ ^+ c
{% D6 d6 L3 f) y) T5 m
pMessage(L"\r\n"); k+=2;8 T2 q; k; A! t( _9 [+ G
for(j=0; j<n; j++)
6 _$ h) w% m\\" H; F0 A9 d5 f+ j
{
. }; k4 O' i( A, `, R9 W6 o
_gcvt_s(chNum,pa[i*n+j],16);+ H8 @ d! N' Z
for(u=0;chNum[u];u++) {wchNum[u]=chNum[u]; k++;}
0 B/ ~2 X) \$ g# ? a( O$ B* r/ {
wchNum[u]='\0';
6 X6 G6 D- f& W; j2 u6 B6 Y7 y
pMessage(wchNum); pMessage(L" "); k+=2;
7 P0 W4 ^8 r0 C6 Z N( F* p
}3 k4 H# ?: b* X5 {0 [
}+ j/ a( l, m) K P
pMessage(L"\r\n"); k+=2;$ l1 e4 _( V9 f% w; V# l
a.BType=luStaData_int64; a.VType=luStaData_int64; a.x=k; //按函数o的要求，返回输出的字符总数9 |* `: M' z7 Z& V5 R; m
break;
6 ]8 B6 u6 A2 G: A0 E/ o0 d
default:
) a; x) s r8 U, P! A2 |
break;
( M6 Q% n+ W; A; x8 a7 Z3 b
}! d- S* Z* m* V3 \; n8 l
return a;
9 E1 H# O5 \2 u, U5 p: V. M8 Q. S
}
4 T1 x J' f) j3 ~. x
void main(void)0 \/ J8 c\\" y8 |' A+ K5 E# L; l6 D
{
6 M3 t8 y4 b7 J6 W) [6 D5 R
void *hFor; //表达式句柄/ s- f: b8 t. j4 q. S, W( f: c( ]
luINT nPara; //存放表达式的自变量个数
& y( m$ j8 {6 Q7 F W3 E' X% a
LuData *pPara; //存放输入自变量的数组指针% w8 s, z7 K8 @+ C\\" e
luINT ErrBegin,ErrEnd; //表达式编译出错的初始位置和结束位置
0 T) i\\" C. Q: b: q
int ErrCode; //错误代码# i\\" d* D! c* o1 C3 h
void *v;
4 Z3 X$ \& ?3 o7 _+ [9 o [
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.]}";//字符串表达式，矩阵乘7 E8 L# r5 ?, V0 d- h; y9 n; `, q* H3 k
//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.]}";//字符串表达式，矩阵点乘
Z8 P1 h: i- q+ n# f8 b/ a' F
LuData Val;3 C% _/ J1 x6 h; }7 e4 U3 j
if(!InitLu()) return; //初始化Lu
* N p# _2 Y7 w7 C/ t
while(LockKey(Matrix,DelMatrix,OpMatrix)){Matrix--;} //锁定一个键，用于存储矩阵扩展类型
' ?( r2 w: `8 w, y$ n9 S5 S. m9 K0 ]
! B\\" K4 u1 Q* N' _
Val.BType=luStaData_int64; Val.VType=luStaData_int64; Val.x=Matrix; //定义整数常量& o D; v8 \# _) e% L
SetConst(L"matrix",&Val); //设置整数常量
$ T2 p5 O% w: e) `% l0 J* s
InsertKey("\0\0\0\0",4,luPubKey_User,LuMessage,NULL,NULL,1,v); //使Lu运行时可输出函数信息
, n\\" }\\" P' c' x
wcout.imbue(locale("chs")); //设置输出的locale为中文, U1 M& C8 r. V: B
! e: c! x B1 c8 f% s) y; H3 i9 L
ErrCode=LuCom(ForStr,0,0,0,hFor,nPara,pPara,ErrBegin,ErrEnd); //编译表达式: K; E* `& p( b. _4 u
if(ErrCode)3 ?& V+ m0 J+ @* J
{1 r6 H; V\\" Y3 S. B/ E; ~- u) f
wcout<<L"表达式有错误！错误代码："<<ErrCode<<endl;3 {. v3 X0 v\\" T2 k! Q
}0 q& G' i' F$ Z! e% @; C- R
else
6 ?0 q( M& A g, p/ ]# c; [
{
3 S) w! I+ z; J, H. e
LuCal(hFor,pPara); //计算表达式的值
* }0 o2 Y0 I1 b& k$ t
}8 c: b# K; V4 c. M) P. L% \: c6 i
LockKey(Matrix,NULL,OpMatrix);//解锁键Matrix，本例中，该函数可以不用. u\\" l\\" E$ ?. Q, w* h7 w0 ?
FreeLu(); //释放Lu, s1 Y5 b+ W+ V @3 b7 D
}

#include <windows.h> 
, q3 k# i# a2 A% ?6 o2 k
#include <iostream>4 i5 y\\" ]' o- W

#include <math.h>1 E- ~; o) a, H3 \' r

#include "lu32.h" 
( L8 L. m: [: L6 U( r\\" e7 q: D/ \/ L5 p
#pragma comment( lib, "lu32.lib" ) 
3 l0 s$ o2 E2 x6 [& s
using namespace std;. W3 z7 o) l) B- t. j: b

//自定义矩阵, Q$ j, @9 t6 {' i( r

class myMatrix 
+ e+ m( n, K# y1 x! _
{ 
2 `& q6 h( M& C8 f* O* I- I
public:% b- e1 K# e  ?! ?' w4 l6 G

double *Array;        //数据缓冲区% v& ~3 H( \# Q# x( j7 Z. T6 C

luVOID ArrayLen;        //数据缓冲区长度2 q3 a) ?$ S7 E* I: x

luVOID Dim[2];        //矩阵维数4 ]) e' C5 y8 z

myMatrix(){Array=NULL; ArrayLen=0; Dim[0]=0; Dim[1]=0;}% L) S: ?5 n7 ~7 {& {9 S4 n8 h8 m

~myMatrix(), V4 u, w7 P  |4 C$ p7 z

{$ }+ G\\" b0 X: Q- f. j

if(Array) delete[] Array; 
- ?3 T: Y) {8 A% R4 ?2 ?
        }\\" E% q/ l+ q2 _  h5 I/ s

};* Z$ Q' w7 b+ L0 s/ S

luKEY Matrix=-1000;        //标识矩阵类型，最终的Matrix由LockKey决定/ Z% o- ~1 v3 O\\" h; G7 y

void _stdcall LuMessage(wchar_t *pch)//输出动态库信息，该函数注册到Lu，由Lu二级函数调用 : A. O- F$ V+ H  G1 _0 ?

{( {1 A5 W9 \4 b* r

wcout<<pch; 
2 ]\\" Q3 ^, r; i+ r. C
} 
) P7 @3 L8 _% Z( R
void _stdcall DelMatrix(void *me)        //用于LockKey函数及InsertKey函数，使Lu能自动销毁myMatrix对象 
/ ]; e  N+ M6 d3 @3 K
{ 
9 U6 e( y\\" E\\" P; c/ V- [1 @6 [. [( ]
        delete (myMatrix *)me;5 O$ z+ k: x9 P- v$ P7 Z

}9 P' O& U\\" t1 M+ r

myMatrix * _stdcall NewMatrix(luVOID m,luVOID n)        //生成一个myMatrix对象) k. [* H+ `9 N/ k

{% O: ?! P. p; Q& }! S4 L3 m\\" A

myMatrix *pMatrix; 
( Y, e9 V9 q& a6 ~9 W# Q0 I% H# ]
        luVOID k;% b2 O\\" p: e% n. h, {* Z\\" M

double *pa;2 @: z2 c: d+ b/ n* }* a

char keyname[sizeof(luVOID)];1 ?( }1 F; J+ T

void *NowKey; 
+ u! T! e5 Y\\" d6 ~% I2 n$ F* ?, o
        k=m*n; 
; [+ |) o& q) N) ?/ L
        pMatrix=(myMatrix *)GetBufObj(Matrix,keyname);//先尝试从缓冲区中获取一个矩阵对象\\" |3 s, F. G0 q% }\\" t* r8 W

if(pMatrix) 
+ k( N' [$ J\\" M4 a# N
        {: f! C7 j) G1 S: a! m  x& H\\" i\\" W; h

if(pMatrix->ArrayLen!=k)        //重置矩阵的大小 
- ~' f# Y$ Z# I/ O
                {# e+ q3 t' W5 k5 ?, k3 ?

pa=new double[k]; 
: w0 F7 {# r6 _0 e4 B. o
                        if(!pa)7 K8 p1 d, e- b0 X0 B\\" {: @7 u8 P7 I& H

{5 j# b% e: R& i9 N9 c1 n

DeleteKey(keyname,sizeof(luVOID),Matrix,DelMatrix,1);        //将矩阵对象放回缓冲区/ y* m$ y9 p) j) e7 b6 I# V$ ~4 w* h) q

return NULL;, C, [2 E2 Q3 Z9 t

} 
( L% U/ Y/ ]4 }# a\\" n! e+ W
                        delete[] pMatrix->Array;! k# {( X! d1 U. S

pMatrix->Array=pa;' L\\" ^1 D' k, v- ]! r8 h

} 
( U' ]) @% T9 ]# {& t$ S
        }! j( D: z7 f# Y8 }

else: C\\" l1 d& ~- r' C

{ 
: B: V9 H1 K' Z! L9 {
                pMatrix=new myMatrix;        //创建矩阵对象 
\\" {! c$ k: b1 ^$ D5 m4 u
                if(!pMatrix) return NULL; 
$ Z0 s8 M! P% @
                pMatrix->Array=new double[k];# m7 E2 V8 n  V+ D  i+ d3 C; b

if(!pMatrix->Array)7 U5 K& @/ k; p- I- b7 p

{ 
! p  U5 n2 C& ~& H4 }
                        delete pMatrix;: p) `8 k( r6 y7 m- r# p

return NULL;4 G3 G7 O* I% z6 |# s5 R$ F\\" i/ O' F

} 
5 j  x5 h7 C+ A, M8 l
                if(InsertKey((char *)&pMatrix,-1,Matrix,pMatrix,DelMatrix,NULL,0,NowKey))        //将矩阵对象注册到Lu9 d% F) h* o  ^3 p- M. B

{ 
9 v1 P' y\\" N: H, c) E' c
                        delete pMatrix;* b) C0 y$ U6 ~) b/ V

return NULL; 
# q2 s3 x/ |% P2 A& G
                } 
- c  V) T( \. r. A/ v; S. P! |3 W7 S( d
        }) L3 ~( V0 u! _; s  h

pMatrix->ArrayLen=k; pMatrix->Dim[0]=m; pMatrix->Dim[1]=n; 
9 V\\" f) B* D% n; C& u4 f
        return pMatrix;! g# ^' k2 _  a+ k. q

} 
: Y5 @& z0 ]+ ]\\" J* B: U
LuData _stdcall OpMatrix(luINT mm,LuData *xx,void *hFor,int theOperator)        //运算符重载函数，用于LockKey函数& Z\\" u3 z\\" G\\" ?% s8 _4 s1 u

{ 
* p* p/ y9 K# ^5 O1 Y: @$ `6 n
        LuData a; 
  @, ]5 o3 l4 @' |; z
        myMatrix *pMatrix1,*pMatrix2,*pMatrix3; 
' f! C$ j\\" J) H# Y( ]
        luVOID i,j,k,m,n,u,v; 
3 _; Q) A+ W/ U
        double *pa,*pb,*pc;# ^$ `( w* Q\\" J* z- t

luMessage pMessage;\\" t0 j% O/ J: c& `' ~

wchar_t wchNum[32]; 
( W! i2 r  K3 ?# y
        char chNum[32]; 
0 H' s' _8 r2 i
        a.BType=luStaData_nil; a.VType=luStaData_nil; a.x=0;\\" X\\" H: C$ O% @% o* R- T

switch(theOperator) 
' [9 @6 W5 R) r0 D
        { 
% ]8 Y* o0 d/ M4 O  Z
        case 2:        //重载运算符* 
, N5 E/ ~. u' U3 L
                pMatrix1=(myMatrix *)SearchKey((char *)&(xx->x),sizeof(luVOID),Matrix);$ X. x& d& p9 i7 r

pMatrix2=(myMatrix *)SearchKey((char *)&((xx+1)->x),sizeof(luVOID),Matrix);( r5 S, e/ `6 O7 b+ }) i. U

if(!pMatrix1 || !pMatrix2) break;        //对象句柄无效，不是矩阵# C  I8 F7 h0 x1 F/ T5 Z

if(pMatrix1->Dim[1]!=pMatrix2->Dim[0]) break;        //维数不匹配6 B/ u$ g7 U0 Y9 R

pMatrix3=NewMatrix(pMatrix1->Dim[0],pMatrix2->Dim[1]);        //生成新矩阵. |, C. u! L( {. ?( T0 J

if(!pMatrix3) break; 
\\" q, e$ e3 u2 y( D# N  G2 W0 y
                pa=pMatrix1->Array; pb=pMatrix2->Array; pc=pMatrix3->Array; 
4 d  a; x8 }4 c
                m=pMatrix1->Dim[0]; n=pMatrix1->Dim[1]; k=pMatrix2->Dim[1]; 
6 W( F* ~! G  K/ L8 `1 I
                for(i=0; i<m; i++)        //矩阵乘 
, C8 X5 F8 n! h5 \6 u# I
                { 
' P' v' m# g7 ?: D
                        for(j=0; j<k; j++) 
! M- ?' D5 \2 U. ^
                        {& U, Q% q2 b8 f# L4 r- B8 _0 T) I

u=i*k+j; pc[u]=0.0;& }( d- _0 n! e7 X- d# J

for (v=0; v<n; v++) 
4 w/ V2 B/ M( a. I6 ?\\" p
                                { 
3 q/ x) Q( W\\" t: N% i; h* A* X
                                        pc[u]=pc[u]+pa[i*n+v]*pb[v*k+j];0 l( Y! `4 W4 x9 g# O& }! `

}; ~7 W: o6 i. f1 a2 Q8 M7 q

} 
/ @5 V& ~$ r9 w5 d+ Q+ [9 h4 M: G
                } 
& ?# Q- _* ~$ S* n$ |
                FunReObj(hFor);        //告诉Lu，返回一个动态对象 
7 I\\" k/ W8 r4 l; _
                a.BType=Matrix; a.VType=Matrix; a.x=0; *(luVOID *)&(a.x)=(luVOID)pMatrix3; 
/ q  l- |8 T, l  e. s
                break; 
% V3 }/ Q; r, M: y* ?
        case 25:        //重载运算符.* 
9 k9 c1 U  s) f& ?$ z& a8 N
                pMatrix1=(myMatrix *)SearchKey((char *)&(xx->x),sizeof(luVOID),Matrix); 
( x, Z$ w1 F4 F/ e/ \/ t3 F
                pMatrix2=(myMatrix *)SearchKey((char *)&((xx+1)->x),sizeof(luVOID),Matrix);4 e6 D0 G0 S( P% K4 V

if(!pMatrix1 || !pMatrix2) break;        //对象句柄无效，不是矩阵7 E2 b4 X6 j% h1 R% p1 }( Y/ x. L: x

if(pMatrix1->Dim[0]!=pMatrix2->Dim[0] || pMatrix1->Dim[1]!=pMatrix2->Dim[1]) break;        //维数不相同 
% v; T2 i! Z8 k( q- }
                pMatrix3=NewMatrix(pMatrix1->Dim[0],pMatrix1->Dim[1]);        //生成新矩阵 
7 o6 ?& M% A: F# P
                if(!pMatrix3) break;! U7 |) T: Q6 ^# c/ ^- @1 V

for(i=0;i<pMatrix1->ArrayLen;i++) pMatrix3->Array[i]=pMatrix1->Array[i]*pMatrix2->Array[i];        //矩阵点乘2 O2 [- S' U# q' Z! Y' _+ r

FunReObj(hFor);        //告诉Lu，返回一个动态对象 
+ y# }) F+ P9 c7 U7 V4 s/ y
                a.BType=Matrix; a.VType=Matrix; a.x=0; *(luVOID *)&(a.x)=(luVOID)pMatrix3;7 k( ?& C/ ?+ z: J. z4 r

break; 
( `3 G7 H7 ^* m/ v
        case 46:        //重载函数new# [- M5 p6 Y& F

if(mm<2) break;! l8 D+ q; ]) D  L

if((xx+1)->x<1 || (xx+2)->x<1 || (xx+1)->BType!=luStaData_int64 || (xx+2)->BType!=luStaData_int64) break; 
0 R' B8 R7 i/ j
                pMatrix3=NewMatrix((luVOID)(xx+1)->x,(luVOID)(xx+2)->x);//生成新矩阵 
% I: X6 Q3 S; S) D, b: y
                if(!pMatrix3) break;) {/ U; L6 {5 J0 y! ]

for(j=0,i=3;i<=mm;i++,j++)        //赋初值 
5 E, z+ K\\" |2 S
                {& w! D- d% I; W6 H: j+ W

if(j>=pMatrix3->ArrayLen) break; 
: F( `\\" D$ ~\\" e3 A% q5 h' [
                        if((xx+i)->BType!=luStaData_double) break;        //只接受实数参数. S6 y# c0 a) O: j8 j$ S

pMatrix3->Array[j]=*(double *)&((xx+i)->x); 
2 q3 e3 B% P4 q* q  }% l# O
                }8 [/ y1 _\\" i\\" K8 A9 x2 }

FunReObj(hFor);        //告诉Lu，返回一个动态对象3 u  X9 m* R1 |$ x1 b

a.BType=Matrix; a.VType=Matrix; a.x=0; *(luVOID *)&(a.x)=(luVOID)pMatrix3;$ \0 L1 g9 N7 v3 N3 h4 @6 \1 `

break; 
, S( S( Y8 |5 ~3 t
        case 49:        //重载函数o 
( ~$ q! A, V* J# d* F$ ?\\" Z
                pMessage=(luMessage)SearchKey("\0\0\0\0",sizeof(luVOID),luPubKey_User); 
7 n5 f& D4 j: T; r
                if(!pMessage) break; 
# W1 a6 g/ s, A4 S
                pMatrix1=(myMatrix *)SearchKey((char *)&(xx->x),sizeof(luVOID),Matrix); 
6 e; }( [7 ~( ?- j( {+ U
                if(!pMatrix1) break;        //对象句柄无效，不是矩阵\\" O$ G/ t, @3 ~4 P/ R9 w8 Y

pa=pMatrix1->Array;  b# _/ j3 O- M/ O

m=pMatrix1->Dim[0]; n=pMatrix1->Dim[1]; k=0;$ E/ Z\\" u4 c/ N8 b

for(i=0; i<m; i++)        //输出矩阵' I( U* r, i/ E  Q0 l\\" g! {/ ^+ c

{% D6 d6 L3 f) y) T5 m

pMessage(L"\r\n"); k+=2;8 T2 q; k; A! t( _9 [+ G

for(j=0; j<n; j++) 
6 _$ h) w% m\\" H; F0 A9 d5 f+ j
                        { 
. }; k4 O' i( A, `, R9 W6 o
                                _gcvt_s(chNum,pa[i*n+j],16);+ H8 @  d! N' Z

for(u=0;chNum[u];u++) {wchNum[u]=chNum[u]; k++;} 
0 B/ ~2 X) \$ g# ?  a( O$ B* r/ {
                                wchNum[u]='\0'; 
6 X6 G6 D- f& W; j2 u6 B6 Y7 y
                                pMessage(wchNum); pMessage(L"  "); k+=2; 
7 P0 W4 ^8 r0 C6 Z  N( F* p
                        }3 k4 H# ?: b* X5 {0 [

}+ j/ a( l, m) K  P

pMessage(L"\r\n"); k+=2;$ l1 e4 _( V9 f% w; V# l

a.BType=luStaData_int64; a.VType=luStaData_int64; a.x=k;        //按函数o的要求，返回输出的字符总数9 |* `: M' z7 Z& V5 R; m

break; 
6 ]8 B6 u6 A2 G: A0 E/ o0 d
        default: 
) a; x) s  r8 U, P! A2 |
                break; 
( M6 Q% n+ W; A; x8 a7 Z3 b
        }! d- S* Z* m* V3 \; n8 l

return a; 
9 E1 H# O5 \2 u, U5 p: V. M8 Q. S
} 
4 T1 x  J' f) j3 ~. x
void main(void)0 \/ J8 c\\" y8 |' A+ K5 E# L; l6 D

{ 
6 M3 t8 y4 b7 J6 W) [6 D5 R
        void *hFor;                //表达式句柄/ s- f: b8 t. j4 q. S, W( f: c( ]

luINT nPara;                //存放表达式的自变量个数 
& y( m$ j8 {6 Q7 F  W3 E' X% a
        LuData *pPara;                //存放输入自变量的数组指针% w8 s, z7 K8 @+ C\\" e

luINT ErrBegin,ErrEnd;        //表达式编译出错的初始位置和结束位置 
0 T) i\\" C. Q: b: q
        int ErrCode;                //错误代码# i\\" d* D! c* o1 C3 h

void *v; 
4 Z3 X$ \& ?3 o7 _+ [9 o  [
        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.]}";//字符串表达式，矩阵乘7 E8 L# r5 ?, V0 d- h; y9 n; `, q* H3 k

//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.]}";//字符串表达式，矩阵点乘 
  Z8 P1 h: i- q+ n# f8 b/ a' F
        LuData Val;3 C% _/ J1 x6 h; }7 e4 U3 j

if(!InitLu()) return;        //初始化Lu 
* N  p# _2 Y7 w7 C/ t
        while(LockKey(Matrix,DelMatrix,OpMatrix)){Matrix--;}        //锁定一个键，用于存储矩阵扩展类型 
' ?( r2 w: `8 w, y$ n9 S5 S. m9 K0 ]
 
! B\\" K4 u1 Q* N' _
        Val.BType=luStaData_int64; Val.VType=luStaData_int64; Val.x=Matrix;        //定义整数常量& o  D; v8 \# _) e% L

SetConst(L"matrix",&Val);        //设置整数常量 
$ T2 p5 O% w: e) `% l0 J* s
        InsertKey("\0\0\0\0",4,luPubKey_User,LuMessage,NULL,NULL,1,v); //使Lu运行时可输出函数信息 
, n\\" }\\" P' c' x
        wcout.imbue(locale("chs"));        //设置输出的locale为中文, U1 M& C8 r. V: B

! e: c! x  B1 c8 f% s) y; H3 i9 L
        ErrCode=LuCom(ForStr,0,0,0,hFor,nPara,pPara,ErrBegin,ErrEnd); //编译表达式: K; E* `& p( b. _4 u

if(ErrCode)3 ?& V+ m0 J+ @* J

{1 r6 H; V\\" Y3 S. B/ E; ~- u) f

wcout<<L"表达式有错误！错误代码："<<ErrCode<<endl;3 {. v3 X0 v\\" T2 k! Q

}0 q& G' i' F$ Z! e% @; C- R

else 
6 ?0 q( M& A  g, p/ ]# c; [
        { 
3 S) w! I+ z; J, H. e
                LuCal(hFor,pPara);        //计算表达式的值 
* }0 o2 Y0 I1 b& k$ t
        }8 c: b# K; V4 c. M) P. L% \: c6 i

LockKey(Matrix,NULL,OpMatrix);//解锁键Matrix，本例中，该函数可以不用. u\\" l\\" E$ ?. Q, w* h7 w0 ?

FreeLu();                        //释放Lu, s1 Y5 b+ W+ V  @3 b7 D

}

习题：

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

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

main(:a,b,c,d,t,i)=
6 {1 d6 g! u* V( h5 o/ i( F
a=new[matrix,2,2: 1.,2.,2.,1.],
& n. ] U f! p6 g. C# C7 d
b=new[matrix,2,2: 2.,1.,1.,2.],
5 C$ Z1 Y& A\" C W( A8 G& `- y- T/ _
c=new[matrix,2,2: 2/3.,-1/3.,-1/3.,2/3.],\" k, [& x6 h d\" z+ n/ x
t=clock(),( S0 F* q7 h. ]# n2 @2 F
d=a*b, i=0, while{i<1000000, d=d*c*b, i++},- \& h7 [\" l! h, s2 l$ W4 N
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\"}";//字符串表达式

复制代码

结果：