数学建模社区-数学中国»论坛 › 【编程区】语言讨论 › Forcal程序设计 › Lu基于系统内置对象创建扩展数据类型，小矩阵乘效率测试

查看: 8675|回复: 0

Lu基于系统内置对象创建扩展数据类型，小矩阵乘效率测试

[复制链接]

字体大小: 正常放大

forcal

45 主题	3 听众	282 积分

升级 91%

TA的每日心情

	难过 2012-8-27 18:22

签到天数: 1 天

[LV.1]初来乍到

电梯直达

1^#

发表于 2011-10-23 09:37 |只看该作者 |倒序浏览

|招呼Ta 关注Ta

本例中，我们将基于系统内置实数数组创建矩阵（matrix）类型，即：基本类型为luDynData_realarray（标识实数数组），扩展类型为matrix（标识矩阵）。为了简单，我们仅处理二维实数数组即矩阵类型。

基本要点：

（1）为扩展类型matrix编写运算符重载函数OpMatrix。

（2）用函数LockKey将重载函数OpMatrix注册到Lu，锁定的键的类型即为matrix，要注册为常量，以便于使用。

（3）为扩展类型matrix编写其他操作函数（本例未提供）。

（4）用函数LockKey解锁键matrix（本例中，程序退出时会自动解锁，故可以不用）。

#include <windows.h>6 a- R1 g( ^4 h$ G/ ^
#include <iostream>1 O% L- ~; G% V. [
#include <math.h>
! w. J6 _% Q# k2 G) l0 r. v3 c
#include "lu32.h"
- ]; y7 y3 w' U* u9 d
$ V; M1 p4 k# \* m6 U' g$ ?3 S
#pragma comment( lib, "lu32.lib" )
' r# i1 ~* L% A' L
: [0 I0 h9 {6 {* q4 g4 P
using namespace std;! t8 J/ w5 W7 }
$ G3 v/ E5 J: Q# L0 i
luKEY Matrix=-1000; //标识矩阵类型，最终的Matrix由LockKey决定7 M' `4 r6 u& H- [! Q/ [
! w/ ^4 \' ~ i; s) H2 Z, k
void _stdcall LuMessage(wchar_t *pch)//输出动态库信息，该函数注册到Lu，由Lu二级函数调用
\\" ]- q6 _! E2 o3 P# K
{
% ]\\" U' w0 c- M
wcout<<pch;3 l) q) }; B* b& k4 _
}
void _stdcall DelMatrix(void *me) //用于LockKey函数，因为是基于系统内置实数数组创建矩阵，故该函数什么也不做
9 S6 C9 L% V! r8 R, G
{3 c! N, m\\" R( x( n4 W: m1 n5 ^& K
}
9 q; n5 E+ r9 M\\" g! w
LuData _stdcall OpMatrix(luINT mm,LuData *xx,void *hFor,int theOperator) //运算符重载函数，用于LockKey函数0 H* W3 M3 I& b' l4 J
{
, A# w% H4 b7 P\\" s- v/ M
LuData a;
z8 f- n: T2 m6 N# X\\" Q4 Z$ S
luRealArray *pRealArray1,*pRealArray2,*pRealArray3;
9 R5 x8 G- C% B6 Z1 R' S, n9 `
luVOID i,j,k,m,n,u,v;
\\" I' ^3 X\\" `: S4 c- [4 ?
double *pa,*pb,*pc;5 s% L9 f\\" J( j: u9 H9 C u) L7 G
luMessage pMessage;1 M. `! F6 V# b4 v
wchar_t wchNum[32];
- w7 T; d/ q, t
char chNum[32];
: s& |' Q6 [' O$ p0 v
a.BType=luStaData_nil; a.VType=luStaData_nil; a.x=0;
! c# N \* R( M! I+ Z) O4 ^9 ~
switch(theOperator)- N/ m5 Z5 f: x. y! @; z+ f8 \. @
{
I+ f4 [4 V: \' U\\" m
case 2: //重载运算符*5 Z( r2 D/ G# I
pRealArray1=(luRealArray *)SearchKey((char *)&(xx->x),sizeof(luVOID),luDynData_realarray);1 m( n2 A: n' v4 r9 s3 Y
pRealArray2=(luRealArray *)SearchKey((char *)&((xx+1)->x),sizeof(luVOID),luDynData_realarray);/ y) f7 z\\" Q. x
if(!pRealArray1 || !pRealArray2) break; //对象句柄无效，不是实数数组* E; j\\" `1 W% }* J+ c6 e% e
if(pRealArray1->DimLen!=2 || pRealArray2->DimLen!=2) break; //不是二维实数数组（矩阵）
! |6 ]+ A- b! G\\" z) o( t
if(pRealArray1->Dim[1]!=pRealArray2->Dim[0]) break; //维数不匹配8 `* M/ Z( A2 h. r% j; e- _
pRealArray3=(luRealArray *)NewSysObj(luDynData_realarray,pRealArray1->Dim[0]*pRealArray2->Dim[1],2); //创建矩阵对象
( z5 Y% m8 w' h* K3 D
if(!pRealArray3) break;
) U+ s9 f) `1 T: m9 ?8 W
pRealArray3->Dim[0]=pRealArray1->Dim[0]; pRealArray3->Dim[1]=pRealArray2->Dim[1]; //设置矩阵维数大小
' |) N+ Q* D0 A# j
pa=pRealArray1->Array; pb=pRealArray2->Array; pc=pRealArray3->Array;0 \+ S; M6 L, u |
m=pRealArray1->Dim[0]; n=pRealArray1->Dim[1]; k=pRealArray2->Dim[1];
1 o A$ t4 n: @4 b, y/ F
for(i=0; i<m; i++) //矩阵乘# B7 j- Z5 u+ `5 q- r/ o5 q+ W3 E
{& ]8 k; {6 _1 B) G! d( f
for(j=0; j<k; j++)
9 B2 A( O# u* \$ T/ c% L
{2 w' }7 u$ X\\" C: K3 J$ Q7 h8 f( ~
u=i*k+j; pc[u]=0.0;
; O! B/ ]+ h: b0 J
for (v=0; v<n; v++)& V5 r9 u3 N$ I9 L9 e+ w, b* z# |6 g
{
* k8 J/ Z6 L+ J! z
pc[u]=pc[u]+pa[i*n+v]*pb[v*k+j];. U5 k+ P+ v4 v
}9 ^5 z. Q( ^. w7 \8 w
}
4 ^: Y# ?) k. G+ O6 x+ h0 h
}, o# t s5 g0 O\\" j+ ^0 P, _# o
FunReObj(hFor); //告诉Lu，返回一个动态对象2 L. `. Y1 U4 u5 i\\" Z
a.BType=luDynData_realarray; a.VType=Matrix; a.x=0; *(luVOID *)&(a.x)=(luVOID)pRealArray3;
& Q z5 f: j5 k, V% I! Y
break;) S* F* O# \5 ~1 `# o
case 25: //重载运算符.*: @ c6 E0 k0 e! C
pRealArray1=(luRealArray *)SearchKey((char *)&(xx->x),sizeof(luVOID),luDynData_realarray);; Q9 f1 P( Y/ w# ^) ]
pRealArray2=(luRealArray *)SearchKey((char *)&((xx+1)->x),sizeof(luVOID),luDynData_realarray);% O2 G) a; {7 V* |4 C
if(!pRealArray1 || !pRealArray2) break; //对象句柄无效，不是实数数组
) X$ w6 g& E\\" {, `
if(pRealArray1->DimLen!=2 || pRealArray2->DimLen!=2) break; //不是二维实数数组（矩阵）
8 A- A( { X8 g B7 \4 S
if(pRealArray1->Dim[0]!=pRealArray2->Dim[0] || pRealArray1->Dim[1]!=pRealArray2->Dim[1]) break; //维数不相同
$ P; a$ F! }. C# P. e7 y9 G
pRealArray3=(luRealArray *)NewSysObj(luDynData_realarray,pRealArray1->ArrayLen,2); //创建矩阵对象% b4 y% w* Y% b\\" r
if(!pRealArray3) break;\\" i m/ w) a! j
pRealArray3->Dim[0]=pRealArray1->Dim[0]; pRealArray3->Dim[1]=pRealArray1->Dim[1]; //设置矩阵维数大小7 L9 [2 ~% b( d9 R- {5 }( k+ w
for(i=0;i<pRealArray1->ArrayLen;i++) pRealArray3->Array[i]=pRealArray1->Array[i]*pRealArray2->Array[i];//矩阵点乘
5 S, m: I2 b\\" P\\" ^1 ?/ B
FunReObj(hFor); //告诉Lu，返回一个动态对象
x. O! B7 z3 G0 k% y' c6 x
a.BType=luDynData_realarray; a.VType=Matrix; a.x=0; *(luVOID *)&(a.x)=(luVOID)pRealArray3;* _+ v9 P. x5 y+ `/ H8 t
break;
' k\\" Y. B9 [; C3 C
case 46: //重载函数new
6 @; z' j( }4 F
a=ExeOperator(mm,xx,hFor,theOperator,luDynData_realarray); //直接调用基本类型luDynData_realarray的new函数. c5 g |8 C% y! q3 y
if(a.VType==luDynData_realarray) a.VType=Matrix; //设置扩展类型为自定义的Matrix类型- |3 z& \6 m' k6 T: z1 x/ {. {) L
break;, P' t) `( \- G) B
case 49: //重载函数o! D G- `6 b3 p$ y. l/ [& X+ O
pMessage=(luMessage)SearchKey("\0\0\0\0",sizeof(luVOID),luPubKey_User);
2 l. Z8 s# ^2 K* A I) |. j! p
if(!pMessage) break;
. Z- H1 `5 P& L v! z) V' ~. ~
pRealArray1=(luRealArray *)SearchKey((char *)&(xx->x),sizeof(luVOID),luDynData_realarray);
* Q' P% b- L3 X& n2 Q) Y
if(!pRealArray1) break; //对象句柄无效，不是实数数组2 G4 b$ `9 l: A
if(pRealArray1->DimLen!=2) break; //不是二维实数数组（矩阵）
3 `) m5 z& ]& \& C8 p
pa=pRealArray1->Array;2 k' C2 S- h5 R. p n2 L
m=pRealArray1->Dim[0]; n=pRealArray1->Dim[1]; k=0;* ?% s' S% m, F\\" ^) A' f% o
for(i=0; i<m; i++) //输出矩阵8 U2 I! W# r: w! J2 @
{
3 D0 U0 \- v( l
pMessage(L"\r\n"); k+=2;. S- _4 ?9 w1 A, n! v' c! _
for(j=0; j<n; j++)7 d3 ?) C& p' z% i' c) L* c
{* Q# h! M, U' h; c% u: L
_gcvt_s(chNum,pa[i*n+j],16);
8 K8 I; |\\" O2 f6 ~% N$ ~9 B6 _
for(u=0;chNum[u];u++) {wchNum[u]=chNum[u]; k++;}
$ D1 u [9 |0 r& E3 {
wchNum[u]='\0';5 \; c, H6 _4 l/ Q. I3 x# M/ e% ~7 S$ l- Q
pMessage(wchNum); pMessage(L" "); k+=2;
% h- W/ [7 G7 ~8 p( D
}
+ x6 p1 n- s; s; W& c6 c
}8 I$ u6 n+ h! z2 s$ Y* V: s
pMessage(L"\r\n"); k+=2;
% X$ j% G0 Y8 w% W& C2 F
a.BType=luStaData_int64; a.VType=luStaData_int64; a.x=k; //按函数o的要求，返回输出的字符总数1 J2 f% g+ S t/ A
break;9 H& S4 N0 q) [% `
default:# G6 ^) b% Z1 _5 _$ A) z
break;3 k, W* k\\" P1 p8 L2 _/ }) K' O1 m
}
) n$ o# N& _4 c% \9 f9 o% i
return a;
% Z {; _0 k4 z/ z
}/ }2 T) J8 G) o7 k( v
void main(void)
2 k. i- k7 M# d i; C! S3 V0 K
{; ?( c. v+ }! q! e* c6 }
void *hFor; //表达式句柄: @ F8 K. c- j( I\\" c\\" @
luINT nPara; //存放表达式的自变量个数+ d: D) [! y; [1 S
LuData *pPara; //存放输入自变量的数组指针
1 ]: d( z3 f4 B+ M; P3 F3 b, `
luINT ErrBegin,ErrEnd; //表达式编译出错的初始位置和结束位置
# g8 F, M. K8 g+ S
int ErrCode; //错误代码
* a( q: n4 ^8 d* F
void *v;! ^/ G) t. p i. p! M
wchar_t ForStr[]=L"o{new[matrix,2,3,data: 0.,1.,2.;3.,4.,5.]*new[matrix,3,2,data: 1.,2.;3.,4.;5.,6.]}";//字符串表达式，矩阵乘
2 k+ P, p+ W3 C
//wchar_t ForStr[]=L"o{new[matrix,2,3,data: 0.,1.,2.;3.,4.,5.].*new[matrix,2,3,data: 1.,2.,3.;4.,5.,6.]}";//字符串表达式，矩阵点乘
# }- x/ l' J\\" ]7 M
LuData Val;
& v! k4 P, R9 X
if(!InitLu()) return; //初始化Lu
; v# C\\" Q& i9 h
while(LockKey(Matrix,DelMatrix,OpMatrix)){Matrix++;} //锁定一个键，用于存储矩阵扩展类型. I: W8 D7 k; X1 W# \
) D( D( c, c4 `% M+ M
Val.BType=luStaData_int64; Val.VType=luStaData_int64; Val.x=Matrix; //定义整数常量/ i( V% l |( z3 \
SetConst(L"matrix",&Val); //设置整数常量
, V D6 w% t8 C0 \+ E/ @, c
InsertKey("\0\0\0\0",4,luPubKey_User,LuMessage,NULL,NULL,1,v); //使Lu运行时可输出函数信息
' h0 ^3 I* ?9 n0 I
wcout.imbue(locale("chs")); //设置输出的locale为中文
8 l- j8 T; S( a
& x: z( F! z. Z7 P: S' K
ErrCode=LuCom(ForStr,0,0,0,hFor,nPara,pPara,ErrBegin,ErrEnd); //编译表达式
' _( J- @9 G/ D8 i6 u; a/ d' T
if(ErrCode)
* a3 f0 M4 n! P/ G6 a9 R
{* A. Y9 x8 b C6 c\\" r
wcout<<L"表达式有错误！错误代码："<<ErrCode<<endl;
) @- } v6 Q- R, |5 G2 N
}
# C% P5 N$ p\\" X2 v
else\\" ]2 p5 ~6 d1 X* Y1 D [# w
{) e3 g. B6 X/ ^2 Q a5 F) n8 w. B, a
LuCal(hFor,pPara); //计算表达式的值
- K7 T( q1 ]1 l' v( t
}
7 @6 q' A, J: n& [- O0 d5 z
LockKey(Matrix,NULL,OpMatrix);//解锁键Matrix，本例中，该函数可以不用+ O1 P2 l7 N m& W8 W, I% V% Y! E
FreeLu(); //释放Lu% r5 |' L1 H; q6 x% O# l
}

#include <windows.h>6 a- R1 g( ^4 h$ G/ ^

#include <iostream>1 O% L- ~; G% V. [

#include <math.h> 
! w. J6 _% Q# k2 G) l0 r. v3 c
#include "lu32.h" 
- ]; y7 y3 w' U* u9 d
$ V; M1 p4 k# \* m6 U' g$ ?3 S

#pragma comment( lib, "lu32.lib" ) 
' r# i1 ~* L% A' L
: [0 I0 h9 {6 {* q4 g4 P

using namespace std;! t8 J/ w5 W7 }

$ G3 v/ E5 J: Q# L0 i

luKEY Matrix=-1000;        //标识矩阵类型，最终的Matrix由LockKey决定7 M' `4 r6 u& H- [! Q/ [

! w/ ^4 \' ~  i; s) H2 Z, k

void _stdcall LuMessage(wchar_t *pch)//输出动态库信息，该函数注册到Lu，由Lu二级函数调用 
\\" ]- q6 _! E2 o3 P# K
{ 
% ]\\" U' w0 c- M
        wcout<<pch;3 l) q) }; B* b& k4 _

} 
  u* V\\" T+ `: k4 G, O0 o% ?6 `+ g  T
void _stdcall DelMatrix(void *me)        //用于LockKey函数，因为是基于系统内置实数数组创建矩阵，故该函数什么也不做 
9 S6 C9 L% V! r8 R, G
{3 c! N, m\\" R( x( n4 W: m1 n5 ^& K

} 
9 q; n5 E+ r9 M\\" g! w
LuData _stdcall OpMatrix(luINT mm,LuData *xx,void *hFor,int theOperator)        //运算符重载函数，用于LockKey函数0 H* W3 M3 I& b' l4 J

{ 
, A# w% H4 b7 P\\" s- v/ M
        LuData a; 
  z8 f- n: T2 m6 N# X\\" Q4 Z$ S
        luRealArray *pRealArray1,*pRealArray2,*pRealArray3; 
9 R5 x8 G- C% B6 Z1 R' S, n9 `
        luVOID i,j,k,m,n,u,v; 
\\" I' ^3 X\\" `: S4 c- [4 ?
        double *pa,*pb,*pc;5 s% L9 f\\" J( j: u9 H9 C  u) L7 G

luMessage pMessage;1 M. `! F6 V# b4 v

wchar_t wchNum[32]; 
- w7 T; d/ q, t
        char chNum[32]; 
: s& |' Q6 [' O$ p0 v
        a.BType=luStaData_nil; a.VType=luStaData_nil; a.x=0; 
! c# N  \* R( M! I+ Z) O4 ^9 ~
        switch(theOperator)- N/ m5 Z5 f: x. y! @; z+ f8 \. @

{ 
  I+ f4 [4 V: \' U\\" m
        case 2:        //重载运算符*5 Z( r2 D/ G# I

pRealArray1=(luRealArray *)SearchKey((char *)&(xx->x),sizeof(luVOID),luDynData_realarray);1 m( n2 A: n' v4 r9 s3 Y

pRealArray2=(luRealArray *)SearchKey((char *)&((xx+1)->x),sizeof(luVOID),luDynData_realarray);/ y) f7 z\\" Q. x

if(!pRealArray1 || !pRealArray2) break;        //对象句柄无效，不是实数数组* E; j\\" `1 W% }* J+ c6 e% e

if(pRealArray1->DimLen!=2 || pRealArray2->DimLen!=2) break;        //不是二维实数数组（矩阵） 
! |6 ]+ A- b! G\\" z) o( t
                if(pRealArray1->Dim[1]!=pRealArray2->Dim[0]) break;        //维数不匹配8 `* M/ Z( A2 h. r% j; e- _

pRealArray3=(luRealArray *)NewSysObj(luDynData_realarray,pRealArray1->Dim[0]*pRealArray2->Dim[1],2);        //创建矩阵对象 
( z5 Y% m8 w' h* K3 D
                if(!pRealArray3) break; 
) U+ s9 f) `1 T: m9 ?8 W
                pRealArray3->Dim[0]=pRealArray1->Dim[0]; pRealArray3->Dim[1]=pRealArray2->Dim[1];        //设置矩阵维数大小 
' |) N+ Q* D0 A# j
                pa=pRealArray1->Array; pb=pRealArray2->Array; pc=pRealArray3->Array;0 \+ S; M6 L, u  |

m=pRealArray1->Dim[0]; n=pRealArray1->Dim[1]; k=pRealArray2->Dim[1]; 
1 o  A$ t4 n: @4 b, y/ F
                for(i=0; i<m; i++)        //矩阵乘# B7 j- Z5 u+ `5 q- r/ o5 q+ W3 E

{& ]8 k; {6 _1 B) G! d( f

for(j=0; j<k; j++) 
9 B2 A( O# u* \$ T/ c% L
                        {2 w' }7 u$ X\\" C: K3 J$ Q7 h8 f( ~

u=i*k+j; pc[u]=0.0; 
; O! B/ ]+ h: b0 J
                                for (v=0; v<n; v++)& V5 r9 u3 N$ I9 L9 e+ w, b* z# |6 g

{ 
* k8 J/ Z6 L+ J! z
                                        pc[u]=pc[u]+pa[i*n+v]*pb[v*k+j];. U5 k+ P+ v4 v

}9 ^5 z. Q( ^. w7 \8 w

} 
4 ^: Y# ?) k. G+ O6 x+ h0 h
                }, o# t  s5 g0 O\\" j+ ^0 P, _# o

FunReObj(hFor);        //告诉Lu，返回一个动态对象2 L. `. Y1 U4 u5 i\\" Z

a.BType=luDynData_realarray; a.VType=Matrix; a.x=0; *(luVOID *)&(a.x)=(luVOID)pRealArray3; 
& Q  z5 f: j5 k, V% I! Y
                break;) S* F* O# \5 ~1 `# o

case 25:        //重载运算符.*: @  c6 E0 k0 e! C

pRealArray1=(luRealArray *)SearchKey((char *)&(xx->x),sizeof(luVOID),luDynData_realarray);; Q9 f1 P( Y/ w# ^) ]

pRealArray2=(luRealArray *)SearchKey((char *)&((xx+1)->x),sizeof(luVOID),luDynData_realarray);% O2 G) a; {7 V* |4 C

if(!pRealArray1 || !pRealArray2) break;        //对象句柄无效，不是实数数组 
) X$ w6 g& E\\" {, `
                if(pRealArray1->DimLen!=2 || pRealArray2->DimLen!=2) break;        //不是二维实数数组（矩阵） 
8 A- A( {  X8 g  B7 \4 S
                if(pRealArray1->Dim[0]!=pRealArray2->Dim[0] || pRealArray1->Dim[1]!=pRealArray2->Dim[1]) break;        //维数不相同 
$ P; a$ F! }. C# P. e7 y9 G
                pRealArray3=(luRealArray *)NewSysObj(luDynData_realarray,pRealArray1->ArrayLen,2);        //创建矩阵对象% b4 y% w* Y% b\\" r

if(!pRealArray3) break;\\" i  m/ w) a! j

pRealArray3->Dim[0]=pRealArray1->Dim[0]; pRealArray3->Dim[1]=pRealArray1->Dim[1];        //设置矩阵维数大小7 L9 [2 ~% b( d9 R- {5 }( k+ w

for(i=0;i<pRealArray1->ArrayLen;i++) pRealArray3->Array[i]=pRealArray1->Array[i]*pRealArray2->Array[i];//矩阵点乘 
5 S, m: I2 b\\" P\\" ^1 ?/ B
                FunReObj(hFor);        //告诉Lu，返回一个动态对象 
  x. O! B7 z3 G0 k% y' c6 x
                a.BType=luDynData_realarray; a.VType=Matrix; a.x=0; *(luVOID *)&(a.x)=(luVOID)pRealArray3;* _+ v9 P. x5 y+ `/ H8 t

break; 
' k\\" Y. B9 [; C3 C
        case 46:        //重载函数new 
6 @; z' j( }4 F
                a=ExeOperator(mm,xx,hFor,theOperator,luDynData_realarray);        //直接调用基本类型luDynData_realarray的new函数. c5 g  |8 C% y! q3 y

if(a.VType==luDynData_realarray) a.VType=Matrix;        //设置扩展类型为自定义的Matrix类型- |3 z& \6 m' k6 T: z1 x/ {. {) L

break;, P' t) `( \- G) B

case 49:        //重载函数o! D  G- `6 b3 p$ y. l/ [& X+ O

pMessage=(luMessage)SearchKey("\0\0\0\0",sizeof(luVOID),luPubKey_User); 
2 l. Z8 s# ^2 K* A  I) |. j! p
                if(!pMessage) break; 
. Z- H1 `5 P& L  v! z) V' ~. ~
                pRealArray1=(luRealArray *)SearchKey((char *)&(xx->x),sizeof(luVOID),luDynData_realarray); 
* Q' P% b- L3 X& n2 Q) Y
                if(!pRealArray1) break;        //对象句柄无效，不是实数数组2 G4 b$ `9 l: A

if(pRealArray1->DimLen!=2) break;        //不是二维实数数组（矩阵） 
3 `) m5 z& ]& \& C8 p
                pa=pRealArray1->Array;2 k' C2 S- h5 R. p  n2 L

m=pRealArray1->Dim[0]; n=pRealArray1->Dim[1]; k=0;* ?% s' S% m, F\\" ^) A' f% o

for(i=0; i<m; i++)        //输出矩阵8 U2 I! W# r: w! J2 @

{ 
3 D0 U0 \- v( l
                        pMessage(L"\r\n"); k+=2;. S- _4 ?9 w1 A, n! v' c! _

for(j=0; j<n; j++)7 d3 ?) C& p' z% i' c) L* c

{* Q# h! M, U' h; c% u: L

_gcvt_s(chNum,pa[i*n+j],16); 
8 K8 I; |\\" O2 f6 ~% N$ ~9 B6 _
                                for(u=0;chNum[u];u++) {wchNum[u]=chNum[u]; k++;} 
$ D1 u  [9 |0 r& E3 {
                                wchNum[u]='\0';5 \; c, H6 _4 l/ Q. I3 x# M/ e% ~7 S$ l- Q

pMessage(wchNum); pMessage(L"  "); k+=2; 
% h- W/ [7 G7 ~8 p( D
                        } 
+ x6 p1 n- s; s; W& c6 c
                }8 I$ u6 n+ h! z2 s$ Y* V: s

pMessage(L"\r\n"); k+=2; 
% X$ j% G0 Y8 w% W& C2 F
                a.BType=luStaData_int64; a.VType=luStaData_int64; a.x=k;        //按函数o的要求，返回输出的字符总数1 J2 f% g+ S  t/ A

break;9 H& S4 N0 q) [% `

default:# G6 ^) b% Z1 _5 _$ A) z

break;3 k, W* k\\" P1 p8 L2 _/ }) K' O1 m

} 
) n$ o# N& _4 c% \9 f9 o% i
        return a; 
% Z  {; _0 k4 z/ z
}/ }2 T) J8 G) o7 k( v

void main(void) 
2 k. i- k7 M# d  i; C! S3 V0 K
{; ?( c. v+ }! q! e* c6 }

void *hFor;                //表达式句柄: @  F8 K. c- j( I\\" c\\" @

luINT nPara;                //存放表达式的自变量个数+ d: D) [! y; [1 S

LuData *pPara;                //存放输入自变量的数组指针 
1 ]: d( z3 f4 B+ M; P3 F3 b, `
        luINT ErrBegin,ErrEnd;        //表达式编译出错的初始位置和结束位置 
# g8 F, M. K8 g+ S
        int ErrCode;                //错误代码 
* a( q: n4 ^8 d* F
        void *v;! ^/ G) t. p  i. p! M

wchar_t ForStr[]=L"o{new[matrix,2,3,data: 0.,1.,2.;3.,4.,5.]*new[matrix,3,2,data: 1.,2.;3.,4.;5.,6.]}";//字符串表达式，矩阵乘 
2 k+ P, p+ W3 C
        //wchar_t ForStr[]=L"o{new[matrix,2,3,data: 0.,1.,2.;3.,4.,5.].*new[matrix,2,3,data: 1.,2.,3.;4.,5.,6.]}";//字符串表达式，矩阵点乘 
# }- x/ l' J\\" ]7 M
        LuData Val; 
& v! k4 P, R9 X
        if(!InitLu()) return;        //初始化Lu 
; v# C\\" Q& i9 h
        while(LockKey(Matrix,DelMatrix,OpMatrix)){Matrix++;}        //锁定一个键，用于存储矩阵扩展类型. I: W8 D7 k; X1 W# \

) D( D( c, c4 `% M+ M
        Val.BType=luStaData_int64; Val.VType=luStaData_int64; Val.x=Matrix;        //定义整数常量/ i( V% l  |( z3 \

SetConst(L"matrix",&Val);        //设置整数常量 
, V  D6 w% t8 C0 \+ E/ @, c
        InsertKey("\0\0\0\0",4,luPubKey_User,LuMessage,NULL,NULL,1,v); //使Lu运行时可输出函数信息 
' h0 ^3 I* ?9 n0 I
        wcout.imbue(locale("chs"));        //设置输出的locale为中文 
8 l- j8 T; S( a
   
& x: z( F! z. Z7 P: S' K
        ErrCode=LuCom(ForStr,0,0,0,hFor,nPara,pPara,ErrBegin,ErrEnd); //编译表达式 
' _( J- @9 G/ D8 i6 u; a/ d' T
        if(ErrCode) 
* a3 f0 M4 n! P/ G6 a9 R
        {* A. Y9 x8 b  C6 c\\" r

wcout<<L"表达式有错误！错误代码："<<ErrCode<<endl; 
) @- }  v6 Q- R, |5 G2 N
        } 
# C% P5 N$ p\\" X2 v
        else\\" ]2 p5 ~6 d1 X* Y1 D  [# w

{) e3 g. B6 X/ ^2 Q  a5 F) n8 w. B, a

LuCal(hFor,pPara);        //计算表达式的值 
- K7 T( q1 ]1 l' v( t
        } 
7 @6 q' A, J: n& [- O0 d5 z
        LockKey(Matrix,NULL,OpMatrix);//解锁键Matrix，本例中，该函数可以不用+ O1 P2 l7 N  m& W8 W, I% V% Y! E

FreeLu();                        //释放Lu% r5 |' L1 H; q6 x% O# l

}

习题：

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

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

main(:a,b,c,d,t,i)=
8 U& l% L/ H+ B) p0 @
a=new[matrix,2,2,data:1.,2.,2.,1.],
* ~+ w* l- Z9 i$ D; a
b=new[matrix,2,2,data:2.,1.,1.,2.],
4 M\" l6 V& j' w1 e+ j( y
c=new[matrix,2,2,data:2/3.,-1/3.,-1/3.,2/3.],+ G# h/ ?7 W- r, `
t=clock(),! \1 d) z\" ` _\" o
d=a*b, i=0, while{i<1000000, d=d*c*b, i++},+ V\" R% P) A _* 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,data:1.1,2.,2.,1.], b=new[matrix,2,2,data:2.,1.,1.,2.], c=new[matrix,2,2,data: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\"}";//字符串表达式

复制代码

结果：