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

查看: 9061|回复: 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>
6 C8 G2 i% G, s
#include <iostream>5 ^6 u) G) j; S8 a+ {
#include <math.h>
; ~# t- F% i$ ?( a2 n7 F
#include "lu32.h"
1 C4 ~\\" _* J! ~' m( M\\" B/ w
#pragma comment( lib, "lu32.lib" ) T' b' U0 |/ T
using namespace std;
1 I- ^& \* B e
//自定义矩阵1 }* z& l5 O1 V% j9 `9 X9 y' |
class myMatrix* T0 y. A7 J4 A9 G
{
' r5 j/ o t' u
public:5 k. y* B4 ]5 _$ f$ e3 W% E& B\\" D
double *Array; //数据缓冲区2 \) `8 G3 ?8 s
luVOID ArrayLen; //数据缓冲区长度
. w: z5 b, o1 u- v! V3 v& s
luVOID Dim[2]; //矩阵维数
& O, b7 c* ], C+ D
myMatrix(){Array=NULL; ArrayLen=0; Dim[0]=0; Dim[1]=0;}8 G$ P3 ?0 _+ L8 a\\" ~! O
~myMatrix()
$ ~$ k; Q! {7 y% v- B
{$ n. e& s' }8 ^* B$ c! D( _! P2 g
if(Array) delete[] Array;
; {- j8 j* g% @\\" x6 L
}. |+ Y% N, I) T/ o4 h& A0 K) u
};9 ^; B# A: t8 l
luKEY Matrix=-1000; //标识矩阵类型，最终的Matrix由LockKey决定
, C7 W2 h\\" M4 d, O. s! U
void _stdcall LuMessage(wchar_t *pch)//输出动态库信息，该函数注册到Lu，由Lu二级函数调用 8 ?% m3 w0 t, z0 D$ E$ M
{
, y# \3 R% `9 C7 F: m8 b- e9 ^
wcout<<pch;, I, h$ J& I/ C. r8 F
}
. b* P; @; g; n% S6 n% p' n
void _stdcall DelMatrix(void *me) //用于LockKey函数及InsertKey函数，使Lu能自动销毁myMatrix对象
7 Q' ^6 z( W5 G- o8 S
{
2 A* |! j! e5 `* n
delete (myMatrix *)me;+ F0 O' i2 D9 k- }
}+ J8 q) r* ^6 `8 W: W2 s* ~
myMatrix * _stdcall NewMatrix(luVOID m,luVOID n) //生成一个myMatrix对象
/ Q2 n$ U' r7 i. V8 _
{
2 g& u) } C+ O1 A% g
myMatrix *pMatrix;
! Q$ R$ ~% L: k8 m
luVOID k;
: O, [ n2 G. r& }9 L& C
double *pa;
$ T9 Q o; K2 b L, I: u
char keyname[sizeof(luVOID)];' |3 ? z8 {* }- j7 w& P
void *NowKey;, W. O$ j0 ?6 x\\" \/ c3 y; c+ V; C
k=m*n;; p, q- J( x# ]1 a( v7 {
pMatrix=(myMatrix *)GetBufObj(Matrix,keyname);//先尝试从缓冲区中获取一个矩阵对象
; r) S9 Q5 B I7 m# j5 e
if(pMatrix)
2 |* ^6 n! d. @, a( t5 ?* S! D
{
5 F' W\\" R3 A$ W# j6 a
if(pMatrix->ArrayLen!=k) //重置矩阵的大小
2 |& P a- ?! J8 ] S+ H& T
{% c& _1 C1 N! C/ K- ] S$ h% i: {
pa=new double[k];
D9 N. u9 R( F9 w2 u0 N
if(!pa)
( F* C: n0 r w! Q7 y0 R! b, m
{
. n- n2 p- @' }% d5 y
DeleteKey(keyname,sizeof(luVOID),Matrix,DelMatrix,1); //将矩阵对象放回缓冲区- @& W% w3 f9 J6 p
return NULL;
, a: j( d: \, C
}6 R' }% I\\" O# Z
delete[] pMatrix->Array;
8 t\\" g7 s, t( \: N' h( S. R
pMatrix->Array=pa;
; H x& U! O8 g: q
}' m1 f: z) A% Q% U4 |2 `
}: m$ f* K+ |8 S2 v$ Q5 R
else6 d' I; _2 P) X: L- b0 w2 L
{
2 N$ Q1 h4 Q& j M4 p5 [
pMatrix=new myMatrix; //创建矩阵对象
6 E: I( _! Z7 j2 Y8 \
if(!pMatrix) return NULL;. n0 M2 I) { z! t9 P; {% z7 V+ `
pMatrix->Array=new double[k];
9 D! a: R K4 {( d8 [+ Q) ^
if(!pMatrix->Array)7 J1 K1 T f# _# r; I) U. \/ M: m/ y
{% W2 F* z- f: ]/ v8 H5 T
delete pMatrix;6 g% O+ ]\\" |, b+ n( \& r
return NULL;
/ x' P }( F, d! c7 M
}
) ^7 ?/ ^. o! @7 x+ s% ~
if(InsertKey((char *)&pMatrix,-1,Matrix,pMatrix,DelMatrix,NULL,0,NowKey)) //将矩阵对象注册到Lu
. o& `0 w\\" J& j; ?6 ^0 j
{4 {3 B% o# D. [( M- I\\" k4 d
delete pMatrix;9 a5 x5 I' m4 @! M1 L$ a& q
return NULL;
$ e' z V9 O3 N9 {$ j% }
}; M2 [! f% @8 P) Q\\" u. u) z* J
}- H Q$ N) ~4 K8 R& i& b6 \4 r
pMatrix->ArrayLen=k; pMatrix->Dim[0]=m; pMatrix->Dim[1]=n;
: Q- C& k$ n# C9 G( q4 X, L
return pMatrix;! E- y; {' M7 y1 ]' S$ b
}
/ g! x0 g* `7 v8 N: d4 p! w
LuData _stdcall OpMatrix(luINT mm,LuData *xx,void *hFor,int theOperator) //运算符重载函数，用于LockKey函数9 l\\" p3 ~0 D3 |9 ~6 h {) k
{
' P9 I: |) r3 _3 K1 B* t2 K' _: ^
LuData a;# [& I5 `\\" o' C$ N+ A* d
myMatrix *pMatrix1,*pMatrix2,*pMatrix3;
/ b' ~9 c2 V2 t9 ?8 X3 X. i: o; F- b
luVOID i,j,k,m,n,u,v;4 t9 Z8 m0 H8 Q5 ?! G4 o
double *pa,*pb,*pc;
- i/ e8 Y+ H/ z- |! G9 D
luMessage pMessage;7 h( @$ ?8 }4 y6 p+ Z' T. H
wchar_t wchNum[32];\\" {) Z- H& s) x |. G
char chNum[32];
! Z5 ~6 b/ k; A2 G# w% p2 j
a.BType=luStaData_nil; a.VType=luStaData_nil; a.x=0;3 p. a; _0 g6 k\\" A: q* j8 ^, M& q( d& e
switch(theOperator)
' O2 v# t+ |: T' N3 \! B1 R
{; u6 P$ G6 [6 A# x5 ?+ p' l; P
case 2: //重载运算符*( m3 {, U0 T0 r7 m- c' K6 w
pMatrix1=(myMatrix *)SearchKey((char *)&(xx->x),sizeof(luVOID),Matrix);
, E. Y+ P4 ?9 _
pMatrix2=(myMatrix *)SearchKey((char *)&((xx+1)->x),sizeof(luVOID),Matrix);
: k4 _# Y, c' h1 W% g' i: k# @$ ?+ |
if(!pMatrix1 || !pMatrix2) break; //对象句柄无效，不是矩阵0 }: Q- V8 \5 U6 p
if(pMatrix1->Dim[1]!=pMatrix2->Dim[0]) break; //维数不匹配
h# Y0 A$ X% N7 Q' H: q3 J
pMatrix3=NewMatrix(pMatrix1->Dim[0],pMatrix2->Dim[1]); //生成新矩阵
0 o3 T/ q, n9 h' B h, @
if(!pMatrix3) break;: ~2 @8 p/ k0 n3 ~3 @* S
pa=pMatrix1->Array; pb=pMatrix2->Array; pc=pMatrix3->Array;
/ A: G7 V, k3 M1 e' [
m=pMatrix1->Dim[0]; n=pMatrix1->Dim[1]; k=pMatrix2->Dim[1];8 n3 ?+ Z8 }& v4 Q% V
for(i=0; i<m; i++) //矩阵乘
3 I$ G! b5 Q& m7 Q1 f/ x0 K e
{+ |% M5 a7 B3 t7 r. o! G1 k
for(j=0; j<k; j++) y' N3 ^' [/ [
{
\\" X2 g& T5 b' q& w
u=i*k+j; pc[u]=0.0;
. i# z! B# f* y
for (v=0; v<n; v++)
) z\\" T8 s9 M O5 K\\" ]
{* z\\" o+ a4 R5 v; V
pc[u]=pc[u]+pa[i*n+v]*pb[v*k+j];8 w. J% G3 V5 h8 ^ Z
}
\\" O: ~\\" G1 a) x2 W A\\" m
}4 W1 ?2 i$ t* Y; @& x7 S* F8 H; L
}
9 I4 ]) o- X% e7 F6 A0 `# O5 V
FunReObj(hFor); //告诉Lu，返回一个动态对象% G- s* t\\" p) W' l5 b9 |! N6 e
a.BType=Matrix; a.VType=Matrix; a.x=0; *(luVOID *)&(a.x)=(luVOID)pMatrix3;
* b6 _; Y& Y, W. e$ M+ S- f
break;
! Q, y' r: }; O L
case 25: //重载运算符.*4 F\\" z, N6 a/ g4 ?/ i( F; l
pMatrix1=(myMatrix *)SearchKey((char *)&(xx->x),sizeof(luVOID),Matrix);! p/ }! v8 t6 a! B. n3 B
pMatrix2=(myMatrix *)SearchKey((char *)&((xx+1)->x),sizeof(luVOID),Matrix);4 d# A\\" l3 S5 w$ z9 h, C! M
if(!pMatrix1 || !pMatrix2) break; //对象句柄无效，不是矩阵7 w& z\\" I3 i% ]9 N
if(pMatrix1->Dim[0]!=pMatrix2->Dim[0] || pMatrix1->Dim[1]!=pMatrix2->Dim[1]) break; //维数不相同
9 s8 ]! J! c6 a
pMatrix3=NewMatrix(pMatrix1->Dim[0],pMatrix1->Dim[1]); //生成新矩阵0 i+ w& \# E$ ?5 _' Z
if(!pMatrix3) break;2 j& n9 k7 g5 Y W4 M
for(i=0;i<pMatrix1->ArrayLen;i++) pMatrix3->Array[i]=pMatrix1->Array[i]*pMatrix2->Array[i]; //矩阵点乘+ @( f) {# z\\" W& ~. H( \7 ]4 E$ v
FunReObj(hFor); //告诉Lu，返回一个动态对象8 w4 ~( f2 t( p+ S& Q+ ~9 h
a.BType=Matrix; a.VType=Matrix; a.x=0; *(luVOID *)&(a.x)=(luVOID)pMatrix3;; h& `9 m5 c! u
break;
6 c\\" C2 ?+ v- W' H+ ^
case 46: //重载函数new$ E8 v( S: J\\" ^
if(mm<2) break;$ _6 X- E9 d\\" m6 o
if((xx+1)->x<1 || (xx+2)->x<1 || (xx+1)->BType!=luStaData_int64 || (xx+2)->BType!=luStaData_int64) break;6 g5 r0 }9 | G$ ? @% o1 F% g- s
pMatrix3=NewMatrix((luVOID)(xx+1)->x,(luVOID)(xx+2)->x);//生成新矩阵0 M% p2 F: ?6 U# R; M9 W/ I
if(!pMatrix3) break;
7 U# @1 `! M- j7 r0 }. R) h
for(j=0,i=3;i<=mm;i++,j++) //赋初值$ J* K$ ^4 j. g
{
\\" f& R# j* c, {- |9 W2 X
if(j>=pMatrix3->ArrayLen) break;# O3 i+ v' M! ]9 K$ U\\" W
if((xx+i)->BType!=luStaData_double) break; //只接受实数参数/ c1 S% y) ]4 _0 ?! c
pMatrix3->Array[j]=*(double *)&((xx+i)->x);
}
9 q0 ^+ d) C9 b, Q* l
FunReObj(hFor); //告诉Lu，返回一个动态对象
5 J1 f2 p% D6 P, ]( x
a.BType=Matrix; a.VType=Matrix; a.x=0; *(luVOID *)&(a.x)=(luVOID)pMatrix3;' S) p: @: h/ ^
break;
! e* S. s+ H( l- J; e1 ]3 c. J
case 49: //重载函数o
/ v\\" X' F. H3 S# B: r9 P' L
pMessage=(luMessage)SearchKey("\0\0\0\0",sizeof(luVOID),luPubKey_User);
' c# z% Z4 m, e I9 _1 W8 h% U$ Z
if(!pMessage) break;
# x5 l9 E( L! S2 z6 {6 `' \
pMatrix1=(myMatrix *)SearchKey((char *)&(xx->x),sizeof(luVOID),Matrix);\\" V% A L& T2 k9 J
if(!pMatrix1) break; //对象句柄无效，不是矩阵
6 z2 W+ ^! @% q+ i
pa=pMatrix1->Array;
3 l* |\\" D\\" j) v; W M3 C, i9 i
m=pMatrix1->Dim[0]; n=pMatrix1->Dim[1]; k=0;7 A+ W' c) Q6 T6 T
for(i=0; i<m; i++) //输出矩阵- R/ y( b9 S0 F x! V& ?
{* b$ _4 R7 X: p0 I\\" A! j3 p
pMessage(L"\r\n"); k+=2;6 }$ H) o6 w. _$ A- C! X
for(j=0; j<n; j++)
7 R7 y+ c1 w, F( S) T3 M8 N) ?% o
{
5 V6 z7 c9 m1 O/ D1 Z
_gcvt_s(chNum,pa[i*n+j],16);
# b3 s7 S6 ~( U2 \
for(u=0;chNum[u];u++) {wchNum[u]=chNum[u]; k++;}( k0 m$ J( ?) l+ W
wchNum[u]='\0';* K1 K8 n& p$ E. e9 {
pMessage(wchNum); pMessage(L" "); k+=2;
1 e/ ^5 a' T+ o3 e& R
}1 _9 }6 Z3 c- r% |- U) h0 K. Q5 R
}
% x' E* M6 H$ B# o' {8 B2 W/ X
pMessage(L"\r\n"); k+=2;6 n. |/ ^6 N6 c* B! @
a.BType=luStaData_int64; a.VType=luStaData_int64; a.x=k; //按函数o的要求，返回输出的字符总数) x! g+ l\\" _3 X\\" U% X9 P0 r9 F
break;' y, i2 b8 J\\" w! ]
default:
- G) u1 z3 S8 N% e
break;
$ O/ {- ?% Q M# l1 d6 x
}
( ?, G4 _/ l- n: ?3 ?1 M- d- Z
return a;
, a9 }* ]7 E- _7 ]\\" Y2 {7 a
}5 ?' X5 Z4 |+ ?4 ]3 [! h: O+ k
void main(void)) I: V) M' f# Z( p1 _
{
; K7 T% R2 C* e2 j# k }4 X
void *hFor; //表达式句柄\\" A5 \' ?% E& Y8 S
luINT nPara; //存放表达式的自变量个数
( k# P! S$ `2 F8 C( k5 m
LuData *pPara; //存放输入自变量的数组指针. B% b* g. I/ Q\\" B1 ~9 B
luINT ErrBegin,ErrEnd; //表达式编译出错的初始位置和结束位置. W, n9 W% J. W0 N: g: ^ E1 |) w; D: J
int ErrCode; //错误代码( D\\" O; U( L6 e* z2 o; \2 a
void *v;+ u, L+ F* Y3 s; c5 q3 m
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.]}";//字符串表达式，矩阵乘
2 X9 M4 f2 c; |0 k) I
//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.]}";//字符串表达式，矩阵点乘: F1 H( u$ \5 z9 ]$ E6 h5 T
LuData Val;
8 {9 j* p- i; M/ x
if(!InitLu()) return; //初始化Lu- R- z1 g9 H0 Q! @/ I3 J
while(LockKey(Matrix,DelMatrix,OpMatrix)){Matrix--;} //锁定一个键，用于存储矩阵扩展类型# a* @9 Z6 l$ g\\" L$ v7 D
/ g& r) G S5 l+ s8 L7 o, Y
Val.BType=luStaData_int64; Val.VType=luStaData_int64; Val.x=Matrix; //定义整数常量
# J u0 D8 o1 _5 @; l6 @
SetConst(L"matrix",&Val); //设置整数常量
4 l1 a( \' d `8 G( l, }' @1 p4 H- _
InsertKey("\0\0\0\0",4,luPubKey_User,LuMessage,NULL,NULL,1,v); //使Lu运行时可输出函数信息! s1 u& E/ L- M! Z
wcout.imbue(locale("chs")); //设置输出的locale为中文2 G5 U# I1 w- N5 G1 W* R\\" _! q
9 D. N+ [: S, u1 J- k$ c
ErrCode=LuCom(ForStr,0,0,0,hFor,nPara,pPara,ErrBegin,ErrEnd); //编译表达式
/ h/ k( G6 H# z# f8 N- y2 |
if(ErrCode)3 m5 c4 W& f% C6 g; l& M* X+ c
{: p1 F' h2 C. T4 f2 ]3 p6 U
wcout<<L"表达式有错误！错误代码："<<ErrCode<<endl;
- K( \8 ^% C$ _! ]% o
}
0 |8 b/ a& P% d+ Y j4 e% T- u
else6 d! K, J ?6 B. a) C: f( `
{: `% C- R) B8 {+ D
LuCal(hFor,pPara); //计算表达式的值
2 R; h/ v# G+ o7 j9 q
}0 g# p! y' U+ i( n2 Q2 r, [
LockKey(Matrix,NULL,OpMatrix);//解锁键Matrix，本例中，该函数可以不用4 c, n9 M B; \\\" @& D
FreeLu(); //释放Lu. n& G5 P8 h) m S) G/ a& Y
}

#include <windows.h> 
6 C8 G2 i% G, s
#include <iostream>5 ^6 u) G) j; S8 a+ {

#include <math.h> 
; ~# t- F% i$ ?( a2 n7 F
#include "lu32.h" 
1 C4 ~\\" _* J! ~' m( M\\" B/ w
#pragma comment( lib, "lu32.lib" )  T' b' U0 |/ T

using namespace std; 
1 I- ^& \* B  e
//自定义矩阵1 }* z& l5 O1 V% j9 `9 X9 y' |

class myMatrix* T0 y. A7 J4 A9 G

{ 
' r5 j/ o  t' u
public:5 k. y* B4 ]5 _$ f$ e3 W% E& B\\" D

double *Array;        //数据缓冲区2 \) `8 G3 ?8 s

luVOID ArrayLen;        //数据缓冲区长度 
. w: z5 b, o1 u- v! V3 v& s
        luVOID Dim[2];        //矩阵维数 
& O, b7 c* ], C+ D
        myMatrix(){Array=NULL; ArrayLen=0; Dim[0]=0; Dim[1]=0;}8 G$ P3 ?0 _+ L8 a\\" ~! O

~myMatrix() 
$ ~$ k; Q! {7 y% v- B
        {$ n. e& s' }8 ^* B$ c! D( _! P2 g

if(Array) delete[] Array; 
; {- j8 j* g% @\\" x6 L
        }. |+ Y% N, I) T/ o4 h& A0 K) u

};9 ^; B# A: t8 l

luKEY Matrix=-1000;        //标识矩阵类型，最终的Matrix由LockKey决定 
, C7 W2 h\\" M4 d, O. s! U
void _stdcall LuMessage(wchar_t *pch)//输出动态库信息，该函数注册到Lu，由Lu二级函数调用 8 ?% m3 w0 t, z0 D$ E$ M

{ 
, y# \3 R% `9 C7 F: m8 b- e9 ^
        wcout<<pch;, I, h$ J& I/ C. r8 F

} 
. b* P; @; g; n% S6 n% p' n
void _stdcall DelMatrix(void *me)        //用于LockKey函数及InsertKey函数，使Lu能自动销毁myMatrix对象 
7 Q' ^6 z( W5 G- o8 S
{ 
2 A* |! j! e5 `* n
        delete (myMatrix *)me;+ F0 O' i2 D9 k- }

}+ J8 q) r* ^6 `8 W: W2 s* ~

myMatrix * _stdcall NewMatrix(luVOID m,luVOID n)        //生成一个myMatrix对象 
/ Q2 n$ U' r7 i. V8 _
{ 
2 g& u) }  C+ O1 A% g
        myMatrix *pMatrix; 
! Q$ R$ ~% L: k8 m
        luVOID k; 
: O, [  n2 G. r& }9 L& C
        double *pa; 
$ T9 Q  o; K2 b  L, I: u
        char keyname[sizeof(luVOID)];' |3 ?  z8 {* }- j7 w& P

void *NowKey;, W. O$ j0 ?6 x\\" \/ c3 y; c+ V; C

k=m*n;; p, q- J( x# ]1 a( v7 {

pMatrix=(myMatrix *)GetBufObj(Matrix,keyname);//先尝试从缓冲区中获取一个矩阵对象 
; r) S9 Q5 B  I7 m# j5 e
        if(pMatrix) 
2 |* ^6 n! d. @, a( t5 ?* S! D
        { 
5 F' W\\" R3 A$ W# j6 a
                if(pMatrix->ArrayLen!=k)        //重置矩阵的大小 
2 |& P  a- ?! J8 ]  S+ H& T
                {% c& _1 C1 N! C/ K- ]  S$ h% i: {

pa=new double[k]; 
  D9 N. u9 R( F9 w2 u0 N
                        if(!pa) 
( F* C: n0 r  w! Q7 y0 R! b, m
                        { 
. n- n2 p- @' }% d5 y
                                DeleteKey(keyname,sizeof(luVOID),Matrix,DelMatrix,1);        //将矩阵对象放回缓冲区- @& W% w3 f9 J6 p

return NULL; 
, a: j( d: \, C
                        }6 R' }% I\\" O# Z

delete[] pMatrix->Array; 
8 t\\" g7 s, t( \: N' h( S. R
                        pMatrix->Array=pa; 
; H  x& U! O8 g: q
                }' m1 f: z) A% Q% U4 |2 `

}: m$ f* K+ |8 S2 v$ Q5 R

else6 d' I; _2 P) X: L- b0 w2 L

{ 
2 N$ Q1 h4 Q& j  M4 p5 [
                pMatrix=new myMatrix;        //创建矩阵对象 
6 E: I( _! Z7 j2 Y8 \
                if(!pMatrix) return NULL;. n0 M2 I) {  z! t9 P; {% z7 V+ `

pMatrix->Array=new double[k]; 
9 D! a: R  K4 {( d8 [+ Q) ^
                if(!pMatrix->Array)7 J1 K1 T  f# _# r; I) U. \/ M: m/ y

{% W2 F* z- f: ]/ v8 H5 T

delete pMatrix;6 g% O+ ]\\" |, b+ n( \& r

return NULL; 
/ x' P  }( F, d! c7 M
                } 
) ^7 ?/ ^. o! @7 x+ s% ~
                if(InsertKey((char *)&pMatrix,-1,Matrix,pMatrix,DelMatrix,NULL,0,NowKey))        //将矩阵对象注册到Lu 
. o& `0 w\\" J& j; ?6 ^0 j
                {4 {3 B% o# D. [( M- I\\" k4 d

delete pMatrix;9 a5 x5 I' m4 @! M1 L$ a& q

return NULL; 
$ e' z  V9 O3 N9 {$ j% }
                }; M2 [! f% @8 P) Q\\" u. u) z* J

}- H  Q$ N) ~4 K8 R& i& b6 \4 r

pMatrix->ArrayLen=k; pMatrix->Dim[0]=m; pMatrix->Dim[1]=n; 
: Q- C& k$ n# C9 G( q4 X, L
        return pMatrix;! E- y; {' M7 y1 ]' S$ b

} 
/ g! x0 g* `7 v8 N: d4 p! w
LuData _stdcall OpMatrix(luINT mm,LuData *xx,void *hFor,int theOperator)        //运算符重载函数，用于LockKey函数9 l\\" p3 ~0 D3 |9 ~6 h  {) k

{ 
' P9 I: |) r3 _3 K1 B* t2 K' _: ^
        LuData a;# [& I5 `\\" o' C$ N+ A* d

myMatrix *pMatrix1,*pMatrix2,*pMatrix3; 
/ b' ~9 c2 V2 t9 ?8 X3 X. i: o; F- b
        luVOID i,j,k,m,n,u,v;4 t9 Z8 m0 H8 Q5 ?! G4 o

double *pa,*pb,*pc; 
- i/ e8 Y+ H/ z- |! G9 D
        luMessage pMessage;7 h( @$ ?8 }4 y6 p+ Z' T. H

wchar_t wchNum[32];\\" {) Z- H& s) x  |. G

char chNum[32]; 
! Z5 ~6 b/ k; A2 G# w% p2 j
        a.BType=luStaData_nil; a.VType=luStaData_nil; a.x=0;3 p. a; _0 g6 k\\" A: q* j8 ^, M& q( d& e

switch(theOperator) 
' O2 v# t+ |: T' N3 \! B1 R
        {; u6 P$ G6 [6 A# x5 ?+ p' l; P

case 2:        //重载运算符*( m3 {, U0 T0 r7 m- c' K6 w

pMatrix1=(myMatrix *)SearchKey((char *)&(xx->x),sizeof(luVOID),Matrix); 
, E. Y+ P4 ?9 _
                pMatrix2=(myMatrix *)SearchKey((char *)&((xx+1)->x),sizeof(luVOID),Matrix); 
: k4 _# Y, c' h1 W% g' i: k# @$ ?+ |
                if(!pMatrix1 || !pMatrix2) break;        //对象句柄无效，不是矩阵0 }: Q- V8 \5 U6 p

if(pMatrix1->Dim[1]!=pMatrix2->Dim[0]) break;        //维数不匹配 
  h# Y0 A$ X% N7 Q' H: q3 J
                pMatrix3=NewMatrix(pMatrix1->Dim[0],pMatrix2->Dim[1]);        //生成新矩阵 
0 o3 T/ q, n9 h' B  h, @
                if(!pMatrix3) break;: ~2 @8 p/ k0 n3 ~3 @* S

pa=pMatrix1->Array; pb=pMatrix2->Array; pc=pMatrix3->Array; 
/ A: G7 V, k3 M1 e' [
                m=pMatrix1->Dim[0]; n=pMatrix1->Dim[1]; k=pMatrix2->Dim[1];8 n3 ?+ Z8 }& v4 Q% V

for(i=0; i<m; i++)        //矩阵乘 
3 I$ G! b5 Q& m7 Q1 f/ x0 K  e
                {+ |% M5 a7 B3 t7 r. o! G1 k

for(j=0; j<k; j++)  y' N3 ^' [/ [

{ 
\\" X2 g& T5 b' q& w
                                u=i*k+j; pc[u]=0.0; 
. i# z! B# f* y
                                for (v=0; v<n; v++) 
) z\\" T8 s9 M  O5 K\\" ]
                                {* z\\" o+ a4 R5 v; V

pc[u]=pc[u]+pa[i*n+v]*pb[v*k+j];8 w. J% G3 V5 h8 ^  Z

} 
\\" O: ~\\" G1 a) x2 W  A\\" m
                        }4 W1 ?2 i$ t* Y; @& x7 S* F8 H; L

} 
9 I4 ]) o- X% e7 F6 A0 `# O5 V
                FunReObj(hFor);        //告诉Lu，返回一个动态对象% G- s* t\\" p) W' l5 b9 |! N6 e

a.BType=Matrix; a.VType=Matrix; a.x=0; *(luVOID *)&(a.x)=(luVOID)pMatrix3; 
* b6 _; Y& Y, W. e$ M+ S- f
                break; 
! Q, y' r: }; O  L
        case 25:        //重载运算符.*4 F\\" z, N6 a/ g4 ?/ i( F; l

pMatrix1=(myMatrix *)SearchKey((char *)&(xx->x),sizeof(luVOID),Matrix);! p/ }! v8 t6 a! B. n3 B

pMatrix2=(myMatrix *)SearchKey((char *)&((xx+1)->x),sizeof(luVOID),Matrix);4 d# A\\" l3 S5 w$ z9 h, C! M

if(!pMatrix1 || !pMatrix2) break;        //对象句柄无效，不是矩阵7 w& z\\" I3 i% ]9 N

if(pMatrix1->Dim[0]!=pMatrix2->Dim[0] || pMatrix1->Dim[1]!=pMatrix2->Dim[1]) break;        //维数不相同 
9 s8 ]! J! c6 a
                pMatrix3=NewMatrix(pMatrix1->Dim[0],pMatrix1->Dim[1]);        //生成新矩阵0 i+ w& \# E$ ?5 _' Z

if(!pMatrix3) break;2 j& n9 k7 g5 Y  W4 M

for(i=0;i<pMatrix1->ArrayLen;i++) pMatrix3->Array[i]=pMatrix1->Array[i]*pMatrix2->Array[i];        //矩阵点乘+ @( f) {# z\\" W& ~. H( \7 ]4 E$ v

FunReObj(hFor);        //告诉Lu，返回一个动态对象8 w4 ~( f2 t( p+ S& Q+ ~9 h

a.BType=Matrix; a.VType=Matrix; a.x=0; *(luVOID *)&(a.x)=(luVOID)pMatrix3;; h& `9 m5 c! u

break; 
6 c\\" C2 ?+ v- W' H+ ^
        case 46:        //重载函数new$ E8 v( S: J\\" ^

if(mm<2) break;$ _6 X- E9 d\\" m6 o

if((xx+1)->x<1 || (xx+2)->x<1 || (xx+1)->BType!=luStaData_int64 || (xx+2)->BType!=luStaData_int64) break;6 g5 r0 }9 |  G$ ?  @% o1 F% g- s

pMatrix3=NewMatrix((luVOID)(xx+1)->x,(luVOID)(xx+2)->x);//生成新矩阵0 M% p2 F: ?6 U# R; M9 W/ I

if(!pMatrix3) break; 
7 U# @1 `! M- j7 r0 }. R) h
                for(j=0,i=3;i<=mm;i++,j++)        //赋初值$ J* K$ ^4 j. g

{ 
\\" f& R# j* c, {- |9 W2 X
                        if(j>=pMatrix3->ArrayLen) break;# O3 i+ v' M! ]9 K$ U\\" W

if((xx+i)->BType!=luStaData_double) break;        //只接受实数参数/ c1 S% y) ]4 _0 ?! c

pMatrix3->Array[j]=*(double *)&((xx+i)->x); 
\\" X  @( J5 z& u# L( t( t+ {\\" N. R4 o
                } 
9 q0 ^+ d) C9 b, Q* l
                FunReObj(hFor);        //告诉Lu，返回一个动态对象 
5 J1 f2 p% D6 P, ]( x
                a.BType=Matrix; a.VType=Matrix; a.x=0; *(luVOID *)&(a.x)=(luVOID)pMatrix3;' S) p: @: h/ ^

break; 
! e* S. s+ H( l- J; e1 ]3 c. J
        case 49:        //重载函数o 
/ v\\" X' F. H3 S# B: r9 P' L
                pMessage=(luMessage)SearchKey("\0\0\0\0",sizeof(luVOID),luPubKey_User); 
' c# z% Z4 m, e  I9 _1 W8 h% U$ Z
                if(!pMessage) break; 
# x5 l9 E( L! S2 z6 {6 `' \
                pMatrix1=(myMatrix *)SearchKey((char *)&(xx->x),sizeof(luVOID),Matrix);\\" V% A  L& T2 k9 J

if(!pMatrix1) break;        //对象句柄无效，不是矩阵 
6 z2 W+ ^! @% q+ i
                pa=pMatrix1->Array; 
3 l* |\\" D\\" j) v; W  M3 C, i9 i
                m=pMatrix1->Dim[0]; n=pMatrix1->Dim[1]; k=0;7 A+ W' c) Q6 T6 T

for(i=0; i<m; i++)        //输出矩阵- R/ y( b9 S0 F  x! V& ?

{* b$ _4 R7 X: p0 I\\" A! j3 p

pMessage(L"\r\n"); k+=2;6 }$ H) o6 w. _$ A- C! X

for(j=0; j<n; j++) 
7 R7 y+ c1 w, F( S) T3 M8 N) ?% o
                        { 
5 V6 z7 c9 m1 O/ D1 Z
                                _gcvt_s(chNum,pa[i*n+j],16); 
# b3 s7 S6 ~( U2 \
                                for(u=0;chNum[u];u++) {wchNum[u]=chNum[u]; k++;}( k0 m$ J( ?) l+ W

wchNum[u]='\0';* K1 K8 n& p$ E. e9 {

pMessage(wchNum); pMessage(L"  "); k+=2; 
1 e/ ^5 a' T+ o3 e& R
                        }1 _9 }6 Z3 c- r% |- U) h0 K. Q5 R

} 
% x' E* M6 H$ B# o' {8 B2 W/ X
                pMessage(L"\r\n"); k+=2;6 n. |/ ^6 N6 c* B! @

a.BType=luStaData_int64; a.VType=luStaData_int64; a.x=k;        //按函数o的要求，返回输出的字符总数) x! g+ l\\" _3 X\\" U% X9 P0 r9 F

break;' y, i2 b8 J\\" w! ]

default: 
- G) u1 z3 S8 N% e
                break; 
$ O/ {- ?% Q  M# l1 d6 x
        } 
( ?, G4 _/ l- n: ?3 ?1 M- d- Z
        return a; 
, a9 }* ]7 E- _7 ]\\" Y2 {7 a
}5 ?' X5 Z4 |+ ?4 ]3 [! h: O+ k

void main(void)) I: V) M' f# Z( p1 _

{ 
; K7 T% R2 C* e2 j# k  }4 X
        void *hFor;                //表达式句柄\\" A5 \' ?% E& Y8 S

luINT nPara;                //存放表达式的自变量个数 
( k# P! S$ `2 F8 C( k5 m
        LuData *pPara;                //存放输入自变量的数组指针. B% b* g. I/ Q\\" B1 ~9 B

luINT ErrBegin,ErrEnd;        //表达式编译出错的初始位置和结束位置. W, n9 W% J. W0 N: g: ^  E1 |) w; D: J

int ErrCode;                //错误代码( D\\" O; U( L6 e* z2 o; \2 a

void *v;+ u, L+ F* Y3 s; c5 q3 m

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.]}";//字符串表达式，矩阵乘 
2 X9 M4 f2 c; |0 k) I
        //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.]}";//字符串表达式，矩阵点乘: F1 H( u$ \5 z9 ]$ E6 h5 T

LuData Val; 
8 {9 j* p- i; M/ x
        if(!InitLu()) return;        //初始化Lu- R- z1 g9 H0 Q! @/ I3 J

while(LockKey(Matrix,DelMatrix,OpMatrix)){Matrix--;}        //锁定一个键，用于存储矩阵扩展类型# a* @9 Z6 l$ g\\" L$ v7 D

/ g& r) G  S5 l+ s8 L7 o, Y

Val.BType=luStaData_int64; Val.VType=luStaData_int64; Val.x=Matrix;        //定义整数常量 
# J  u0 D8 o1 _5 @; l6 @
        SetConst(L"matrix",&Val);        //设置整数常量 
4 l1 a( \' d  `8 G( l, }' @1 p4 H- _
        InsertKey("\0\0\0\0",4,luPubKey_User,LuMessage,NULL,NULL,1,v); //使Lu运行时可输出函数信息! s1 u& E/ L- M! Z

wcout.imbue(locale("chs"));        //设置输出的locale为中文2 G5 U# I1 w- N5 G1 W* R\\" _! q

9 D. N+ [: S, u1 J- k$ c
        ErrCode=LuCom(ForStr,0,0,0,hFor,nPara,pPara,ErrBegin,ErrEnd); //编译表达式 
/ h/ k( G6 H# z# f8 N- y2 |
        if(ErrCode)3 m5 c4 W& f% C6 g; l& M* X+ c

{: p1 F' h2 C. T4 f2 ]3 p6 U

wcout<<L"表达式有错误！错误代码："<<ErrCode<<endl; 
- K( \8 ^% C$ _! ]% o
        } 
0 |8 b/ a& P% d+ Y  j4 e% T- u
        else6 d! K, J  ?6 B. a) C: f( `

{: `% C- R) B8 {+ D

LuCal(hFor,pPara);        //计算表达式的值 
2 R; h/ v# G+ o7 j9 q
        }0 g# p! y' U+ i( n2 Q2 r, [

LockKey(Matrix,NULL,OpMatrix);//解锁键Matrix，本例中，该函数可以不用4 c, n9 M  B; \\\" @& D

FreeLu();                        //释放Lu. n& G5 P8 h) m  S) G/ a& Y

}

习题：

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

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

main(:a,b,c,d,t,i)=
/ i8 E\" K\" N- U+ A
a=new[matrix,2,2: 1.,2.,2.,1.],
; r) f$ e) Z1 v5 F
b=new[matrix,2,2: 2.,1.,1.,2.],% r+ M. l# K. Y' p
c=new[matrix,2,2: 2/3.,-1/3.,-1/3.,2/3.],, L7 Z9 P# I3 R* m3 K# O
t=clock(),, W, U ?% A2 u: I
d=a*b, i=0, while{i<1000000, d=d*c*b, i++},! E% M- A! P! C) n9 C! d
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\"}";//字符串表达式

复制代码

结果：