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

查看: 8601|回复: 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>
v9 i1 `& r' ?' R4 H
#include <iostream>
! i8 k; h% k, t% @, O: ?5 W$ R
#include <math.h>% I7 S0 ?$ m! @
#include "lu32.h"
$ l4 I) p& A\\" u) X4 V- F* X
#pragma comment( lib, "lu32.lib" )4 z, C, P' ^; z8 T \& T, w' y
using namespace std;3 r! B( O4 C C, g\\" n
//自定义矩阵
- {0 t. ^2 z' _6 o+ ?# k
class myMatrix* _- M) T3 E( x e5 l ?
{; }. {; r/ ?) X$ a
public:
' T! O0 W! m1 L+ g1 Y- o0 r
double *Array; //数据缓冲区
+ {1 n% N- P/ ]2 x! O
luVOID ArrayLen; //数据缓冲区长度
# ]4 z$ `' a+ ]! U2 U& n( u
luVOID Dim[2]; //矩阵维数
/ B- t( _2 v, s9 l3 k$ n, q
myMatrix(){Array=NULL; ArrayLen=0; Dim[0]=0; Dim[1]=0;}% ~\\" a$ Y\\" `4 `7 ]* [1 A\\" ?5 P
~myMatrix()
; ^ D( D- b& X. ~$ {8 M# u0 n
{% i$ J+ U\\" P9 X# n) x
if(Array) delete[] Array;, m, w8 ?9 @. |- G
}
9 k0 H& M3 j\\" y+ @
};
0 k( G, Q3 ~ B M! y
luKEY Matrix=-1000; //标识矩阵类型，最终的Matrix由LockKey决定1 d: v3 _1 O4 ]* O6 Z4 n
void _stdcall LuMessage(wchar_t *pch)//输出动态库信息，该函数注册到Lu，由Lu二级函数调用 0 J2 X8 L2 g/ K6 R+ t
{
! v- s- ?4 c! x, r
wcout<<pch;# F2 n1 h5 J8 }# z Q5 ~$ P9 n
}+ }* v( r. m1 x/ H
void _stdcall DelMatrix(void *me) //用于LockKey函数及InsertKey函数，使Lu能自动销毁myMatrix对象$ o6 G8 z- S) \/ ^$ U6 U* h5 \
{% f* W5 T4 W0 w7 [2 e3 h
delete (myMatrix *)me;
4 D n$ K* Q& t
}
# c4 y2 q8 u2 b* ?, w7 S
myMatrix * _stdcall NewMatrix(luVOID m,luVOID n) //生成一个myMatrix对象
/ T; O2 g6 G\\" |1 t\\" k9 a: O1 ]
{
7 o\\" J\\" k' a: B0 w- \2 c1 G
myMatrix *pMatrix;
8 q2 ~4 ?6 J- @% i& v* k
luVOID k;
' M1 D, |\\" Q1 b/ m
double *pa;. I9 V1 v' l* P$ {3 d
char keyname[sizeof(luVOID)];- f8 F/ ~) w3 W$ w! I0 \2 b
void *NowKey;9 E# m5 V4 M# t/ T2 ?8 f, A+ Y
k=m*n;
: y3 R0 _$ h4 C6 R
pMatrix=(myMatrix *)GetBufObj(Matrix,keyname);//先尝试从缓冲区中获取一个矩阵对象 ^* |0 M! R, C: _0 s) p. l
if(pMatrix)
& i+ H1 |7 L( C
{
( j0 c S g! x f' L; g; d
if(pMatrix->ArrayLen!=k) //重置矩阵的大小
* N( X8 z5 B' G+ ~4 }0 v
{
. W& ?- m7 m2 n& V
pa=new double[k];8 f' T# x8 i: x Y( o/ q
if(!pa)
0 D3 x7 \8 T1 V6 ^
{
7 e( y& D7 f5 T7 P+ k5 R0 ~
DeleteKey(keyname,sizeof(luVOID),Matrix,DelMatrix,1); //将矩阵对象放回缓冲区
) T/ X5 w j, g0 W8 \2 j
return NULL;5 H% q6 a. w: U) `6 N
}
' P, i9 C l/ x4 t
delete[] pMatrix->Array;
, n3 g' o ~1 Y. I% A: v! y: A
pMatrix->Array=pa;0 E1 \5 B; \, I% f3 ]# F! k6 b
}! B' x7 R, i7 q( H1 `7 g
}3 q% K& {9 Y% R7 G3 k+ @6 D
else }& O! b$ v: W9 ]
{6 P3 c `5 g- F i1 t' R$ ]
pMatrix=new myMatrix; //创建矩阵对象0 r* _% y% \- h4 ? ]/ J$ l+ G/ O- ^
if(!pMatrix) return NULL;. v: K8 @) y5 g' Q X\\" r. H
pMatrix->Array=new double[k];
0 A/ w9 W, ?, U2 S
if(!pMatrix->Array). g8 j: S2 H$ q7 n* a; n
{
3 w- m! r* C! S5 E4 T+ q+ k
delete pMatrix;
) F( y* J( o+ E3 \; F+ J1 ]
return NULL;' g5 x# K' N l* O
}
' W6 J; O% u2 J# n* ~
if(InsertKey((char *)&pMatrix,-1,Matrix,pMatrix,DelMatrix,NULL,0,NowKey)) //将矩阵对象注册到Lu
+ f* Q/ f8 \: y* [) `) b
{
% t* Q6 F8 @+ n0 e
delete pMatrix;
9 m5 k7 c/ E# N, W& Y' O6 m
return NULL;
1 h! `1 ?: H\\" v
}6 a( G3 Y( G: A' B# X
}
% g7 f+ O; B$ P/ N5 ]: Q
pMatrix->ArrayLen=k; pMatrix->Dim[0]=m; pMatrix->Dim[1]=n;
8 M5 _% `8 g& v5 H+ y6 v# ?' I2 e
return pMatrix;; t4 |9 c. r6 f0 {. w1 s$ w
}
% ~( L1 s5 K6 B( e, T+ s: v
LuData _stdcall OpMatrix(luINT mm,LuData *xx,void *hFor,int theOperator) //运算符重载函数，用于LockKey函数( b& u\\" i5 v, w2 o2 v! N0 _
{
\\" t& z& h5 D( [
LuData a;' I1 e0 P3 [+ W* r- m2 E9 S# ]* U
myMatrix *pMatrix1,*pMatrix2,*pMatrix3;
! _9 |. j6 Y& i* Y% M; c4 T- k
luVOID i,j,k,m,n,u,v;* `& S! b l4 c% j* |
double *pa,*pb,*pc;& c' H- g# ?) V1 K3 b& U
luMessage pMessage;
$ |/ B. W# [. [, ^2 ~
wchar_t wchNum[32];0 N3 V: P7 H2 f9 E! @8 M$ i4 f5 j' z
char chNum[32];$ Q\\" v: c9 w- |
a.BType=luStaData_nil; a.VType=luStaData_nil; a.x=0;
/ K2 h$ I i- c, K; C
switch(theOperator)
; b5 ^; W+ @5 t$ m7 B
{
% a% S- k) P+ w! N% H
case 2: //重载运算符*
) J6 Y5 T, l\\" ^- w) j W+ h: u
pMatrix1=(myMatrix *)SearchKey((char *)&(xx->x),sizeof(luVOID),Matrix);' H\\" V* k$ a, K* W, w
pMatrix2=(myMatrix *)SearchKey((char *)&((xx+1)->x),sizeof(luVOID),Matrix);
/ P/ A+ q v- a* n) r: A
if(!pMatrix1 || !pMatrix2) break; //对象句柄无效，不是矩阵6 Y9 P; u( _3 [1 g3 H9 z# Q7 c) {
if(pMatrix1->Dim[1]!=pMatrix2->Dim[0]) break; //维数不匹配
+ o3 T. e( ~( ]; r* N! |
pMatrix3=NewMatrix(pMatrix1->Dim[0],pMatrix2->Dim[1]); //生成新矩阵 s1 i7 n }! X0 C! S6 _
if(!pMatrix3) break;
6 q* Q) P: p- t/ w7 L7 `2 q\\" Z
pa=pMatrix1->Array; pb=pMatrix2->Array; pc=pMatrix3->Array;
- B L5 W/ D$ |: b8 b3 \
m=pMatrix1->Dim[0]; n=pMatrix1->Dim[1]; k=pMatrix2->Dim[1];1 |1 Z1 `6 i. o3 \1 O! @
for(i=0; i<m; i++) //矩阵乘0 `! \+ n- P5 K0 n- u
{3 b+ a% B& p; V6 [8 F- q
for(j=0; j<k; j++)+ w* D6 r9 K! l6 a
{\\" L: m8 T7 e8 P! q( m\\" J( d& ~. J9 E
u=i*k+j; pc[u]=0.0;
7 m, q+ v; L! Z/ R4 R+ z/ N
for (v=0; v<n; v++)
\\" l9 T: o; R+ D
{
$ D4 ~8 X. `% j\\" |' V$ l# v* X
pc[u]=pc[u]+pa[i*n+v]*pb[v*k+j];# Y1 V8 H2 y$ x& s8 t( x& @& |
}
2 ^6 _. E+ m' D; N$ F
}' F2 k$ O% c- d\\" m$ ]
}
\\" W& L! A9 o* R# F\\" T2 [! \% }
FunReObj(hFor); //告诉Lu，返回一个动态对象) {3 y\\" u& n( q! ?
a.BType=Matrix; a.VType=Matrix; a.x=0; *(luVOID *)&(a.x)=(luVOID)pMatrix3;1 h, \& O# J- e7 G5 K: f( |$ q
break;$ N( q7 h- {7 T) T4 q, w6 }
case 25: //重载运算符.*
* l- p% q0 f+ l( A7 Q; c
pMatrix1=(myMatrix *)SearchKey((char *)&(xx->x),sizeof(luVOID),Matrix);
\\" `7 i3 f/ \( F5 n+ h% D5 I! e
pMatrix2=(myMatrix *)SearchKey((char *)&((xx+1)->x),sizeof(luVOID),Matrix);
$ `: N1 S; p0 ^) b5 R$ A) d5 W2 Z
if(!pMatrix1 || !pMatrix2) break; //对象句柄无效，不是矩阵
5 a\\" r, M! n1 x
if(pMatrix1->Dim[0]!=pMatrix2->Dim[0] || pMatrix1->Dim[1]!=pMatrix2->Dim[1]) break; //维数不相同6 o, R+ U% f$ @: Q. G* K
pMatrix3=NewMatrix(pMatrix1->Dim[0],pMatrix1->Dim[1]); //生成新矩阵
3 D% i$ L3 K% [# K h
if(!pMatrix3) break;
- Z1 d' `& ^$ P; z8 C
for(i=0;i<pMatrix1->ArrayLen;i++) pMatrix3->Array[i]=pMatrix1->Array[i]*pMatrix2->Array[i]; //矩阵点乘; ]* K$ j4 x\\" L% O0 M8 q
FunReObj(hFor); //告诉Lu，返回一个动态对象
z3 [* P* X, k u# r
a.BType=Matrix; a.VType=Matrix; a.x=0; *(luVOID *)&(a.x)=(luVOID)pMatrix3;
0 ]- ~' m. ?( {: ]5 i P
break;
! L7 s; g9 E6 Q0 E0 X0 n
case 46: //重载函数new
, v1 Z7 p& ?- V\\" [& A4 ]6 H# G* W; m
if(mm<2) break;4 _% P' E' O& T, R6 n# x( b; p
if((xx+1)->x<1 || (xx+2)->x<1 || (xx+1)->BType!=luStaData_int64 || (xx+2)->BType!=luStaData_int64) break;
! F* V* k% p9 U5 [6 t0 [9 ]\\" i6 S
pMatrix3=NewMatrix((luVOID)(xx+1)->x,(luVOID)(xx+2)->x);//生成新矩阵! J: i6 L- M i U) A p
if(!pMatrix3) break;( _! R8 r9 x7 Z2 V& z\\" I
for(j=0,i=3;i<=mm;i++,j++) //赋初值! t# g\\" A7 g7 G5 y7 H' R4 G' \4 }
{9 f' j) s4 D1 m# e. @4 s
if(j>=pMatrix3->ArrayLen) break;
6 l( Z! {6 p- M6 f5 i( E
if((xx+i)->BType!=luStaData_double) break; //只接受实数参数
5 `6 D: [2 Z8 E2 [) l/ i
pMatrix3->Array[j]=*(double *)&((xx+i)->x);
\\" `/ k3 N( A0 t
}, v! Z3 p- l4 i+ b
FunReObj(hFor); //告诉Lu，返回一个动态对象
, B# {7 B/ W6 o0 W. ~
a.BType=Matrix; a.VType=Matrix; a.x=0; *(luVOID *)&(a.x)=(luVOID)pMatrix3;( X/ a) p2 V$ K) X% T
break;\\" p$ B! r! B+ Z' B% D! @% m% U; o; r- T
case 49: //重载函数o
6 O2 d$ [# X5 m( Y1 r
pMessage=(luMessage)SearchKey("\0\0\0\0",sizeof(luVOID),luPubKey_User);
; t0 n4 N. F. p% u7 T9 L
if(!pMessage) break;
- h) [! L9 k* `: u
pMatrix1=(myMatrix *)SearchKey((char *)&(xx->x),sizeof(luVOID),Matrix);% e y: v! @: w; |4 n7 y) n6 _( a( h
if(!pMatrix1) break; //对象句柄无效，不是矩阵! J0 s/ @$ x: J$ j: @
pa=pMatrix1->Array;9 L; ]. }; I5 \/ s
m=pMatrix1->Dim[0]; n=pMatrix1->Dim[1]; k=0;. B' }$ v. H v; q' H\\" T: C
for(i=0; i<m; i++) //输出矩阵. T1 W5 w5 _) Z/ ^& V2 e
{
m2 M5 R- ]9 G) t6 ]* D. ?: J
pMessage(L"\r\n"); k+=2;
for(j=0; j<n; j++)
* w8 V6 I1 X2 y
{
$ \; \3 Z7 l+ S, }2 s
_gcvt_s(chNum,pa[i*n+j],16);
$ [- ?# c+ e5 M# t9 \' M. j
for(u=0;chNum[u];u++) {wchNum[u]=chNum[u]; k++;}
; k1 B$ B$ T; }$ a N, T5 g
wchNum[u]='\0';
4 J; t3 {! J, Y0 |- w' |& z1 Q
pMessage(wchNum); pMessage(L" "); k+=2;
+ J; d( I5 t* J\\" {# D\\" P
}# u1 w$ d) J( _' l! [# p
}
, S( V- S) \4 N$ @8 b
pMessage(L"\r\n"); k+=2;5 |\\" q$ t# P( K; T! B& J
a.BType=luStaData_int64; a.VType=luStaData_int64; a.x=k; //按函数o的要求，返回输出的字符总数
\\" i, s9 G/ j& s6 q7 d+ n
break;# W; U& b1 w8 @
default:
. x3 c\\" K; Y/ N t0 ^7 r2 |
break;
3 K5 b6 p* ~9 B& T' R( a5 d
}
5 n( H7 \: n% l9 f4 ^
return a;
2 F# y7 X; b\\" S8 r( M
}
3 ]. X- j# S: P/ @+ p
void main(void)
4 z3 y; G+ b Y
{
' D6 o4 J/ q. O8 Y2 z/ p% N
void *hFor; //表达式句柄) B6 V \$ E0 s8 q! z. S
luINT nPara; //存放表达式的自变量个数 O+ \* j) G1 ?\\" E
LuData *pPara; //存放输入自变量的数组指针6 f' @2 v% ~) D\\" f+ Q
luINT ErrBegin,ErrEnd; //表达式编译出错的初始位置和结束位置
& o\\" @( y1 j/ g4 y& e3 U
int ErrCode; //错误代码( o6 |% U( ]3 r i+ j
void *v;8 e P( z5 G l: w: N3 O7 G
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.]}";//字符串表达式，矩阵乘
/ S2 ^6 V- u& a5 `& J2 L
//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.]}";//字符串表达式，矩阵点乘
$ y0 G. M, ?4 O) n# y
LuData Val;# F0 E+ P3 M\\" |3 m\\" w' W
if(!InitLu()) return; //初始化Lu
1 d. ^3 e$ @- Y5 c% Y. Y
while(LockKey(Matrix,DelMatrix,OpMatrix)){Matrix--;} //锁定一个键，用于存储矩阵扩展类型7 J0 J! W& N9 s$ D7 v# l5 }! R, ]
, h4 D* O x, n3 l+ v8 O
Val.BType=luStaData_int64; Val.VType=luStaData_int64; Val.x=Matrix; //定义整数常量
7 J9 I* L* ?9 E8 r5 b
SetConst(L"matrix",&Val); //设置整数常量5 O' Y7 e1 h9 j3 P
InsertKey("\0\0\0\0",4,luPubKey_User,LuMessage,NULL,NULL,1,v); //使Lu运行时可输出函数信息. j) ?, B1 J- {( R7 D; a
wcout.imbue(locale("chs")); //设置输出的locale为中文
3 N0 Y- R9 O; a8 n
# {9 j# M9 g( ?4 s# v
ErrCode=LuCom(ForStr,0,0,0,hFor,nPara,pPara,ErrBegin,ErrEnd); //编译表达式
. A0 B8 M8 j\\" l\\" _
if(ErrCode)
4 A2 S: d. I9 K& ]
{
4 Y7 n' F/ l8 x q+ v
wcout<<L"表达式有错误！错误代码："<<ErrCode<<endl;
. I1 H% M. ~3 m- T' i
}
\\" @5 P& C, w+ p' _) h
else
1 _. l( L g3 ~3 |
{
\\" y8 e9 S) n& E$ y/ r8 t* {
LuCal(hFor,pPara); //计算表达式的值
# k3 n\\" w+ \6 t/ x2 ?1 _
}
3 t! I, ^* `- j7 b N* X
LockKey(Matrix,NULL,OpMatrix);//解锁键Matrix，本例中，该函数可以不用
* T/ }9 c1 z' M# D: G( ~# I4 C) v
FreeLu(); //释放Lu. C/ I, ^$ o( z+ s! H9 y4 \
}

#include <windows.h> 
  v9 i1 `& r' ?' R4 H
#include <iostream> 
! i8 k; h% k, t% @, O: ?5 W$ R
#include <math.h>% I7 S0 ?$ m! @

#include "lu32.h" 
$ l4 I) p& A\\" u) X4 V- F* X
#pragma comment( lib, "lu32.lib" )4 z, C, P' ^; z8 T  \& T, w' y

using namespace std;3 r! B( O4 C  C, g\\" n

//自定义矩阵 
- {0 t. ^2 z' _6 o+ ?# k
class myMatrix* _- M) T3 E( x  e5 l  ?

{; }. {; r/ ?) X$ a

public: 
' T! O0 W! m1 L+ g1 Y- o0 r
        double *Array;        //数据缓冲区 
+ {1 n% N- P/ ]2 x! O
        luVOID ArrayLen;        //数据缓冲区长度 
# ]4 z$ `' a+ ]! U2 U& n( u
        luVOID Dim[2];        //矩阵维数 
/ B- t( _2 v, s9 l3 k$ n, q
        myMatrix(){Array=NULL; ArrayLen=0; Dim[0]=0; Dim[1]=0;}% ~\\" a$ Y\\" `4 `7 ]* [1 A\\" ?5 P

~myMatrix() 
; ^  D( D- b& X. ~$ {8 M# u0 n
        {% i$ J+ U\\" P9 X# n) x

if(Array) delete[] Array;, m, w8 ?9 @. |- G

} 
9 k0 H& M3 j\\" y+ @
}; 
0 k( G, Q3 ~  B  M! y
luKEY Matrix=-1000;        //标识矩阵类型，最终的Matrix由LockKey决定1 d: v3 _1 O4 ]* O6 Z4 n

void _stdcall LuMessage(wchar_t *pch)//输出动态库信息，该函数注册到Lu，由Lu二级函数调用 0 J2 X8 L2 g/ K6 R+ t

{ 
! v- s- ?4 c! x, r
        wcout<<pch;# F2 n1 h5 J8 }# z  Q5 ~$ P9 n

}+ }* v( r. m1 x/ H

void _stdcall DelMatrix(void *me)        //用于LockKey函数及InsertKey函数，使Lu能自动销毁myMatrix对象$ o6 G8 z- S) \/ ^$ U6 U* h5 \

{% f* W5 T4 W0 w7 [2 e3 h

delete (myMatrix *)me; 
4 D  n$ K* Q& t
} 
# c4 y2 q8 u2 b* ?, w7 S
myMatrix * _stdcall NewMatrix(luVOID m,luVOID n)        //生成一个myMatrix对象 
/ T; O2 g6 G\\" |1 t\\" k9 a: O1 ]
{ 
7 o\\" J\\" k' a: B0 w- \2 c1 G
        myMatrix *pMatrix; 
8 q2 ~4 ?6 J- @% i& v* k
        luVOID k; 
' M1 D, |\\" Q1 b/ m
        double *pa;. I9 V1 v' l* P$ {3 d

char keyname[sizeof(luVOID)];- f8 F/ ~) w3 W$ w! I0 \2 b

void *NowKey;9 E# m5 V4 M# t/ T2 ?8 f, A+ Y

k=m*n; 
: y3 R0 _$ h4 C6 R
        pMatrix=(myMatrix *)GetBufObj(Matrix,keyname);//先尝试从缓冲区中获取一个矩阵对象  ^* |0 M! R, C: _0 s) p. l

if(pMatrix) 
& i+ H1 |7 L( C
        { 
( j0 c  S  g! x  f' L; g; d
                if(pMatrix->ArrayLen!=k)        //重置矩阵的大小 
* N( X8 z5 B' G+ ~4 }0 v
                { 
. W& ?- m7 m2 n& V
                        pa=new double[k];8 f' T# x8 i: x  Y( o/ q

if(!pa) 
0 D3 x7 \8 T1 V6 ^
                        { 
7 e( y& D7 f5 T7 P+ k5 R0 ~
                                DeleteKey(keyname,sizeof(luVOID),Matrix,DelMatrix,1);        //将矩阵对象放回缓冲区 
) T/ X5 w  j, g0 W8 \2 j
                                return NULL;5 H% q6 a. w: U) `6 N

} 
' P, i9 C  l/ x4 t
                        delete[] pMatrix->Array; 
, n3 g' o  ~1 Y. I% A: v! y: A
                        pMatrix->Array=pa;0 E1 \5 B; \, I% f3 ]# F! k6 b

}! B' x7 R, i7 q( H1 `7 g

}3 q% K& {9 Y% R7 G3 k+ @6 D

else  }& O! b$ v: W9 ]

{6 P3 c  `5 g- F  i1 t' R$ ]

pMatrix=new myMatrix;        //创建矩阵对象0 r* _% y% \- h4 ?  ]/ J$ l+ G/ O- ^

if(!pMatrix) return NULL;. v: K8 @) y5 g' Q  X\\" r. H

pMatrix->Array=new double[k]; 
0 A/ w9 W, ?, U2 S
                if(!pMatrix->Array). g8 j: S2 H$ q7 n* a; n

{ 
3 w- m! r* C! S5 E4 T+ q+ k
                        delete pMatrix; 
) F( y* J( o+ E3 \; F+ J1 ]
                        return NULL;' g5 x# K' N  l* O

} 
' W6 J; O% u2 J# n* ~
                if(InsertKey((char *)&pMatrix,-1,Matrix,pMatrix,DelMatrix,NULL,0,NowKey))        //将矩阵对象注册到Lu 
+ f* Q/ f8 \: y* [) `) b
                { 
% t* Q6 F8 @+ n0 e
                        delete pMatrix; 
9 m5 k7 c/ E# N, W& Y' O6 m
                        return NULL; 
1 h! `1 ?: H\\" v
                }6 a( G3 Y( G: A' B# X

} 
% g7 f+ O; B$ P/ N5 ]: Q
        pMatrix->ArrayLen=k; pMatrix->Dim[0]=m; pMatrix->Dim[1]=n; 
8 M5 _% `8 g& v5 H+ y6 v# ?' I2 e
        return pMatrix;; t4 |9 c. r6 f0 {. w1 s$ w

} 
% ~( L1 s5 K6 B( e, T+ s: v
LuData _stdcall OpMatrix(luINT mm,LuData *xx,void *hFor,int theOperator)        //运算符重载函数，用于LockKey函数( b& u\\" i5 v, w2 o2 v! N0 _

{ 
\\" t& z& h5 D( [
        LuData a;' I1 e0 P3 [+ W* r- m2 E9 S# ]* U

myMatrix *pMatrix1,*pMatrix2,*pMatrix3; 
! _9 |. j6 Y& i* Y% M; c4 T- k
        luVOID i,j,k,m,n,u,v;* `& S! b  l4 c% j* |

double *pa,*pb,*pc;& c' H- g# ?) V1 K3 b& U

luMessage pMessage; 
$ |/ B. W# [. [, ^2 ~
        wchar_t wchNum[32];0 N3 V: P7 H2 f9 E! @8 M$ i4 f5 j' z

char chNum[32];$ Q\\" v: c9 w- |

a.BType=luStaData_nil; a.VType=luStaData_nil; a.x=0; 
/ K2 h$ I  i- c, K; C
        switch(theOperator) 
; b5 ^; W+ @5 t$ m7 B
        { 
% a% S- k) P+ w! N% H
        case 2:        //重载运算符* 
) J6 Y5 T, l\\" ^- w) j  W+ h: u
                pMatrix1=(myMatrix *)SearchKey((char *)&(xx->x),sizeof(luVOID),Matrix);' H\\" V* k$ a, K* W, w

pMatrix2=(myMatrix *)SearchKey((char *)&((xx+1)->x),sizeof(luVOID),Matrix); 
/ P/ A+ q  v- a* n) r: A
                if(!pMatrix1 || !pMatrix2) break;        //对象句柄无效，不是矩阵6 Y9 P; u( _3 [1 g3 H9 z# Q7 c) {

if(pMatrix1->Dim[1]!=pMatrix2->Dim[0]) break;        //维数不匹配 
+ o3 T. e( ~( ]; r* N! |
                pMatrix3=NewMatrix(pMatrix1->Dim[0],pMatrix2->Dim[1]);        //生成新矩阵  s1 i7 n  }! X0 C! S6 _

if(!pMatrix3) break; 
6 q* Q) P: p- t/ w7 L7 `2 q\\" Z
                pa=pMatrix1->Array; pb=pMatrix2->Array; pc=pMatrix3->Array; 
- B  L5 W/ D$ |: b8 b3 \
                m=pMatrix1->Dim[0]; n=pMatrix1->Dim[1]; k=pMatrix2->Dim[1];1 |1 Z1 `6 i. o3 \1 O! @

for(i=0; i<m; i++)        //矩阵乘0 `! \+ n- P5 K0 n- u

{3 b+ a% B& p; V6 [8 F- q

for(j=0; j<k; j++)+ w* D6 r9 K! l6 a

{\\" L: m8 T7 e8 P! q( m\\" J( d& ~. J9 E

u=i*k+j; pc[u]=0.0; 
7 m, q+ v; L! Z/ R4 R+ z/ N
                                for (v=0; v<n; v++) 
\\" l9 T: o; R+ D
                                { 
$ D4 ~8 X. `% j\\" |' V$ l# v* X
                                        pc[u]=pc[u]+pa[i*n+v]*pb[v*k+j];# Y1 V8 H2 y$ x& s8 t( x& @& |

} 
2 ^6 _. E+ m' D; N$ F
                        }' F2 k$ O% c- d\\" m$ ]

} 
\\" W& L! A9 o* R# F\\" T2 [! \% }
                FunReObj(hFor);        //告诉Lu，返回一个动态对象) {3 y\\" u& n( q! ?

a.BType=Matrix; a.VType=Matrix; a.x=0; *(luVOID *)&(a.x)=(luVOID)pMatrix3;1 h, \& O# J- e7 G5 K: f( |$ q

break;$ N( q7 h- {7 T) T4 q, w6 }

case 25:        //重载运算符.* 
* l- p% q0 f+ l( A7 Q; c
                pMatrix1=(myMatrix *)SearchKey((char *)&(xx->x),sizeof(luVOID),Matrix); 
\\" `7 i3 f/ \( F5 n+ h% D5 I! e
                pMatrix2=(myMatrix *)SearchKey((char *)&((xx+1)->x),sizeof(luVOID),Matrix); 
$ `: N1 S; p0 ^) b5 R$ A) d5 W2 Z
                if(!pMatrix1 || !pMatrix2) break;        //对象句柄无效，不是矩阵 
5 a\\" r, M! n1 x
                if(pMatrix1->Dim[0]!=pMatrix2->Dim[0] || pMatrix1->Dim[1]!=pMatrix2->Dim[1]) break;        //维数不相同6 o, R+ U% f$ @: Q. G* K

pMatrix3=NewMatrix(pMatrix1->Dim[0],pMatrix1->Dim[1]);        //生成新矩阵 
3 D% i$ L3 K% [# K  h
                if(!pMatrix3) break; 
- Z1 d' `& ^$ P; z8 C
                for(i=0;i<pMatrix1->ArrayLen;i++) pMatrix3->Array[i]=pMatrix1->Array[i]*pMatrix2->Array[i];        //矩阵点乘; ]* K$ j4 x\\" L% O0 M8 q

FunReObj(hFor);        //告诉Lu，返回一个动态对象 
  z3 [* P* X, k  u# r
                a.BType=Matrix; a.VType=Matrix; a.x=0; *(luVOID *)&(a.x)=(luVOID)pMatrix3; 
0 ]- ~' m. ?( {: ]5 i  P
                break; 
! L7 s; g9 E6 Q0 E0 X0 n
        case 46:        //重载函数new 
, v1 Z7 p& ?- V\\" [& A4 ]6 H# G* W; m
                if(mm<2) break;4 _% P' E' O& T, R6 n# x( b; p

if((xx+1)->x<1 || (xx+2)->x<1 || (xx+1)->BType!=luStaData_int64 || (xx+2)->BType!=luStaData_int64) break; 
! F* V* k% p9 U5 [6 t0 [9 ]\\" i6 S
                pMatrix3=NewMatrix((luVOID)(xx+1)->x,(luVOID)(xx+2)->x);//生成新矩阵! J: i6 L- M  i  U) A  p

if(!pMatrix3) break;( _! R8 r9 x7 Z2 V& z\\" I

for(j=0,i=3;i<=mm;i++,j++)        //赋初值! t# g\\" A7 g7 G5 y7 H' R4 G' \4 }

{9 f' j) s4 D1 m# e. @4 s

if(j>=pMatrix3->ArrayLen) break; 
6 l( Z! {6 p- M6 f5 i( E
                        if((xx+i)->BType!=luStaData_double) break;        //只接受实数参数 
5 `6 D: [2 Z8 E2 [) l/ i
                        pMatrix3->Array[j]=*(double *)&((xx+i)->x); 
\\" `/ k3 N( A0 t
                }, v! Z3 p- l4 i+ b

FunReObj(hFor);        //告诉Lu，返回一个动态对象 
, B# {7 B/ W6 o0 W. ~
                a.BType=Matrix; a.VType=Matrix; a.x=0; *(luVOID *)&(a.x)=(luVOID)pMatrix3;( X/ a) p2 V$ K) X% T

break;\\" p$ B! r! B+ Z' B% D! @% m% U; o; r- T

case 49:        //重载函数o 
6 O2 d$ [# X5 m( Y1 r
                pMessage=(luMessage)SearchKey("\0\0\0\0",sizeof(luVOID),luPubKey_User); 
; t0 n4 N. F. p% u7 T9 L
                if(!pMessage) break; 
- h) [! L9 k* `: u
                pMatrix1=(myMatrix *)SearchKey((char *)&(xx->x),sizeof(luVOID),Matrix);% e  y: v! @: w; |4 n7 y) n6 _( a( h

if(!pMatrix1) break;        //对象句柄无效，不是矩阵! J0 s/ @$ x: J$ j: @

pa=pMatrix1->Array;9 L; ]. }; I5 \/ s

m=pMatrix1->Dim[0]; n=pMatrix1->Dim[1]; k=0;. B' }$ v. H  v; q' H\\" T: C

for(i=0; i<m; i++)        //输出矩阵. T1 W5 w5 _) Z/ ^& V2 e

{ 
  m2 M5 R- ]9 G) t6 ]* D. ?: J
                        pMessage(L"\r\n"); k+=2; 
7 R8 N! d. [$ g, y+ P; R9 s! F- t8 U; S* T
                        for(j=0; j<n; j++) 
* w8 V6 I1 X2 y
                        { 
$ \; \3 Z7 l+ S, }2 s
                                _gcvt_s(chNum,pa[i*n+j],16); 
$ [- ?# c+ e5 M# t9 \' M. j
                                for(u=0;chNum[u];u++) {wchNum[u]=chNum[u]; k++;} 
; k1 B$ B$ T; }$ a  N, T5 g
                                wchNum[u]='\0'; 
4 J; t3 {! J, Y0 |- w' |& z1 Q
                                pMessage(wchNum); pMessage(L"  "); k+=2; 
+ J; d( I5 t* J\\" {# D\\" P
                        }# u1 w$ d) J( _' l! [# p

} 
, S( V- S) \4 N$ @8 b
                pMessage(L"\r\n"); k+=2;5 |\\" q$ t# P( K; T! B& J

a.BType=luStaData_int64; a.VType=luStaData_int64; a.x=k;        //按函数o的要求，返回输出的字符总数 
\\" i, s9 G/ j& s6 q7 d+ n
                break;# W; U& b1 w8 @

default: 
. x3 c\\" K; Y/ N  t0 ^7 r2 |
                break; 
3 K5 b6 p* ~9 B& T' R( a5 d
        } 
5 n( H7 \: n% l9 f4 ^
        return a; 
2 F# y7 X; b\\" S8 r( M
} 
3 ]. X- j# S: P/ @+ p
void main(void) 
4 z3 y; G+ b  Y
{ 
' D6 o4 J/ q. O8 Y2 z/ p% N
        void *hFor;                //表达式句柄) B6 V  \$ E0 s8 q! z. S

luINT nPara;                //存放表达式的自变量个数  O+ \* j) G1 ?\\" E

LuData *pPara;                //存放输入自变量的数组指针6 f' @2 v% ~) D\\" f+ Q

luINT ErrBegin,ErrEnd;        //表达式编译出错的初始位置和结束位置 
& o\\" @( y1 j/ g4 y& e3 U
        int ErrCode;                //错误代码( o6 |% U( ]3 r  i+ j

void *v;8 e  P( z5 G  l: w: N3 O7 G

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.]}";//字符串表达式，矩阵乘 
/ S2 ^6 V- u& a5 `& J2 L
        //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.]}";//字符串表达式，矩阵点乘 
$ y0 G. M, ?4 O) n# y
        LuData Val;# F0 E+ P3 M\\" |3 m\\" w' W

if(!InitLu()) return;        //初始化Lu 
1 d. ^3 e$ @- Y5 c% Y. Y
        while(LockKey(Matrix,DelMatrix,OpMatrix)){Matrix--;}        //锁定一个键，用于存储矩阵扩展类型7 J0 J! W& N9 s$ D7 v# l5 }! R, ]

, h4 D* O  x, n3 l+ v8 O

Val.BType=luStaData_int64; Val.VType=luStaData_int64; Val.x=Matrix;        //定义整数常量 
7 J9 I* L* ?9 E8 r5 b
        SetConst(L"matrix",&Val);        //设置整数常量5 O' Y7 e1 h9 j3 P

InsertKey("\0\0\0\0",4,luPubKey_User,LuMessage,NULL,NULL,1,v); //使Lu运行时可输出函数信息. j) ?, B1 J- {( R7 D; a

wcout.imbue(locale("chs"));        //设置输出的locale为中文 
3 N0 Y- R9 O; a8 n
   
# {9 j# M9 g( ?4 s# v
        ErrCode=LuCom(ForStr,0,0,0,hFor,nPara,pPara,ErrBegin,ErrEnd); //编译表达式 
. A0 B8 M8 j\\" l\\" _
        if(ErrCode) 
4 A2 S: d. I9 K& ]
        { 
4 Y7 n' F/ l8 x  q+ v
                wcout<<L"表达式有错误！错误代码："<<ErrCode<<endl; 
. I1 H% M. ~3 m- T' i
        } 
\\" @5 P& C, w+ p' _) h
        else 
1 _. l( L  g3 ~3 |
        { 
\\" y8 e9 S) n& E$ y/ r8 t* {
                LuCal(hFor,pPara);        //计算表达式的值 
# k3 n\\" w+ \6 t/ x2 ?1 _
        } 
3 t! I, ^* `- j7 b  N* X
        LockKey(Matrix,NULL,OpMatrix);//解锁键Matrix，本例中，该函数可以不用 
* T/ }9 c1 z' M# D: G( ~# I4 C) v
        FreeLu();                        //释放Lu. C/ I, ^$ o( z+ s! H9 y4 \

}

习题：

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

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

main(:a,b,c,d,t,i)=4 j6 ?% Y: ?\" t8 T5 \/ \: n! X# X
a=new[matrix,2,2: 1.,2.,2.,1.],
6 n. [+ k\" ]\" |7 N! F9 v. d
b=new[matrix,2,2: 2.,1.,1.,2.],' l0 r/ z3 m7 ?, C; s
c=new[matrix,2,2: 2/3.,-1/3.,-1/3.,2/3.],
7 A3 `* d\" O8 f7 U/ u I' {- ^
t=clock(),* v4 k6 A& [2 y) [% F# ]. y& r
d=a*b, i=0, while{i<1000000, d=d*c*b, i++},: t9 L; m; X8 a/ F1 i6 ?
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\"}";//字符串表达式

复制代码

结果：