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

查看: 8685|回复: 2

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>
/ @/ [# y% W- z* N1 e0 n0 g
#include <iostream>
1 }/ e9 g7 l; R2 D/ h3 r8 _6 E
#include <math.h>
: t1 L! c5 H4 f) j, H# O
#include "lu32.h"0 b k2 v! } ^4 `; }) }
9 \. C. d8 ~$ `- x& x
#pragma comment( lib, "lu32.lib" )' R' c6 H% J; i6 Z7 f
% P7 t8 j9 i3 E
using namespace std;
0 o5 `% H9 o* M- s; \, J4 E
: X4 w2 O3 N- M
luKEY Matrix=-1000; //标识矩阵类型，最终的Matrix由LockKey决定
; R: z- g6 c& f
0 l+ A1 J, O4 @/ j\\" ] d& z M9 F, Q
void _stdcall LuMessage(wchar_t *pch)//输出动态库信息，该函数注册到Lu，由Lu二级函数调用 & s J& M7 B6 n3 v/ ~& f
{* w0 o' ?7 q3 N( o; n) z4 \ N' ]
wcout<<pch;5 ?. T# U. |, F' ]! {
} e! C; V+ R, e0 A/ C; J t
void _stdcall DelMatrix(void *me) //用于LockKey函数，因为是基于系统内置实数数组创建矩阵，故该函数什么也不做
, O( p% Q* p* | p4 j# X/ D
{6 E: }* T0 G+ R0 C
}
: H! x( d! U& J% l; r) c
LuData _stdcall OpMatrix(luINT mm,LuData *xx,void *hFor,int theOperator) //运算符重载函数，用于LockKey函数
{' u! S4 M! ^# Q( q0 P- T
LuData a;& m z8 R x- m5 \\\" l& Y
luRealArray *pRealArray1,*pRealArray2,*pRealArray3;
# Y. l1 j+ ~' _. ~ o- h
luVOID i,j,k,m,n,u,v;
0 {6 K\\" j; F; M: }\\" y6 _( `1 H
double *pa,*pb,*pc;
' I, }1 G5 q- \: _# W' q
luMessage pMessage;
# H\\" p% a# W, z2 f* ?5 i$ V2 {
wchar_t wchNum[32];
' o$ r. ^\\" _, W# J2 |# O
char chNum[32];
) v$ B7 p5 S4 C! k: h; k
a.BType=luStaData_nil; a.VType=luStaData_nil; a.x=0;
& k6 o+ H- a4 m% |( _( U5 ?
switch(theOperator)
! j# `/ j+ k- H& h. E
{1 u5 z5 F( t8 m# |
case 2: //重载运算符*5 U& Y' J+ c/ r. x9 v+ N
pRealArray1=(luRealArray *)SearchKey((char *)&(xx->x),sizeof(luVOID),luDynData_realarray);5 Z; b/ q0 {\\" ]3 p\\" c6 |$ l
pRealArray2=(luRealArray *)SearchKey((char *)&((xx+1)->x),sizeof(luVOID),luDynData_realarray);
1 L2 {8 w9 V\\" ]7 T; F
if(!pRealArray1 || !pRealArray2) break; //对象句柄无效，不是实数数组) }( K( X/ t8 D e' e/ I
if(pRealArray1->DimLen!=2 || pRealArray2->DimLen!=2) break; //不是二维实数数组（矩阵）/ [ \$ l- y! U5 U2 _$ N/ ^7 m
if(pRealArray1->Dim[1]!=pRealArray2->Dim[0]) break; //维数不匹配
. L! |3 r. i% R/ b' b7 E
pRealArray3=(luRealArray *)NewSysObj(luDynData_realarray,pRealArray1->Dim[0]*pRealArray2->Dim[1],2); //创建矩阵对象
. F9 [, i; p8 g
if(!pRealArray3) break;7 E }\\" D) h- Y
pRealArray3->Dim[0]=pRealArray1->Dim[0]; pRealArray3->Dim[1]=pRealArray2->Dim[1]; //设置矩阵维数大小
# s0 f! A7 L2 E& Y( P% ?+ r+ {
pa=pRealArray1->Array; pb=pRealArray2->Array; pc=pRealArray3->Array;- a* v: o( A2 j ^4 @/ x\\" f
m=pRealArray1->Dim[0]; n=pRealArray1->Dim[1]; k=pRealArray2->Dim[1];8 t- _5 r9 e: h
for(i=0; i<m; i++) //矩阵乘\\" S; }& l' H1 Z/ i K* p\\" P0 l
{
; q/ C; c- D. v* c- l7 g2 B/ u) B
for(j=0; j<k; j++)& r, |1 o# f4 u7 D# r4 E
{
+ x9 F/ o% W) f\\" d* O2 A \
u=i*k+j; pc[u]=0.0;
; C* N0 n9 ~8 r
for (v=0; v<n; v++): H3 }( H\\" R9 z6 w/ {0 j6 U2 S
{
% M3 z. h\\" j8 c9 x% d! r
pc[u]=pc[u]+pa[i*n+v]*pb[v*k+j];
X+ v, \2 U/ g! ]8 |
}
$ x& i' {# H: @- E; L
}
6 Z5 f; W* e# X3 H\\" P
}
; q5 i- K% W9 |7 p% M
FunReObj(hFor); //告诉Lu，返回一个动态对象7 u) b6 [6 v1 v, |$ P\\" `: D/ ?- E
a.BType=luDynData_realarray; a.VType=Matrix; a.x=0; *(luVOID *)&(a.x)=(luVOID)pRealArray3;
3 `; j5 p( S8 x5 w8 F/ V+ s
break;& Q7 v% \: U6 O
case 25: //重载运算符.*, f$ Q g$ V$ @3 t* C9 u
pRealArray1=(luRealArray *)SearchKey((char *)&(xx->x),sizeof(luVOID),luDynData_realarray);6 O. Y) P/ Q1 K( S
pRealArray2=(luRealArray *)SearchKey((char *)&((xx+1)->x),sizeof(luVOID),luDynData_realarray);' d* j1 l, z0 \
if(!pRealArray1 || !pRealArray2) break; //对象句柄无效，不是实数数组
7 N+ O* M7 P! a0 W
if(pRealArray1->DimLen!=2 || pRealArray2->DimLen!=2) break; //不是二维实数数组（矩阵）
6 G4 R- x\\" `3 o8 } _% M
if(pRealArray1->Dim[0]!=pRealArray2->Dim[0] || pRealArray1->Dim[1]!=pRealArray2->Dim[1]) break; //维数不相同
$ Z. t\\" g7 V5 Y& U\\" P
pRealArray3=(luRealArray *)NewSysObj(luDynData_realarray,pRealArray1->ArrayLen,2); //创建矩阵对象
* ^/ O6 m+ g2 f$ f$ K
if(!pRealArray3) break;/ |' \3 k3 b0 I$ P8 u
pRealArray3->Dim[0]=pRealArray1->Dim[0]; pRealArray3->Dim[1]=pRealArray1->Dim[1]; //设置矩阵维数大小: y3 b1 m+ E8 U6 Z
for(i=0;i<pRealArray1->ArrayLen;i++) pRealArray3->Array[i]=pRealArray1->Array[i]*pRealArray2->Array[i];//矩阵点乘3 v3 D. H2 g5 e. z* J0 ^
FunReObj(hFor); //告诉Lu，返回一个动态对象! V0 n. e1 b7 g( [5 W
a.BType=luDynData_realarray; a.VType=Matrix; a.x=0; *(luVOID *)&(a.x)=(luVOID)pRealArray3;# r3 R3 `& ]: O5 o; w5 q9 y
break;4 \1 ^6 T# i3 v0 L! G
case 46: //重载函数new; a$ o* x+ R7 ^ @( P
a=ExeOperator(mm,xx,hFor,theOperator,luDynData_realarray); //直接调用基本类型luDynData_realarray的new函数
9 d4 A, z5 F4 ?2 w
if(a.VType==luDynData_realarray) a.VType=Matrix; //设置扩展类型为自定义的Matrix类型) d' M! Z2 y1 F! U( l ?
break;% T* t U* {+ u\\" Y b5 E# F# Q: `
case 49: //重载函数o0 [! s; ?9 a+ O\\" W
pMessage=(luMessage)SearchKey("\0\0\0\0",sizeof(luVOID),luPubKey_User);+ M2 a9 I; o! A/ f7 O( t
if(!pMessage) break;, [( q( T1 Q* O
pRealArray1=(luRealArray *)SearchKey((char *)&(xx->x),sizeof(luVOID),luDynData_realarray);. ^1 R$ o: h6 b& ^: M
if(!pRealArray1) break; //对象句柄无效，不是实数数组
& e4 G ]. M- x m( y
if(pRealArray1->DimLen!=2) break; //不是二维实数数组（矩阵）
1 _: \6 i8 N; P# ]
pa=pRealArray1->Array;
\\" u! N' m* h; P$ `
m=pRealArray1->Dim[0]; n=pRealArray1->Dim[1]; k=0;
7 g% I2 o+ X( N3 @$ [) s5 D
for(i=0; i<m; i++) //输出矩阵
0 H7 S) [3 y2 c$ u7 r% u
{\\" j# h8 u( I! o- ~4 b$ ]
pMessage(L"\r\n"); k+=2;& Y# W! o( w1 Y1 h# B8 O4 z
for(j=0; j<n; j++)2 V/ ^* a8 b; c/ p! s; z% @! L
{
0 s( i: x+ _6 K, d8 \
_gcvt_s(chNum,pa[i*n+j],16);& R6 e3 t2 _ u# r
for(u=0;chNum[u];u++) {wchNum[u]=chNum[u]; k++;}
]& W* e0 }- m3 l$ V) }
wchNum[u]='\0';
* Q y/ A8 i1 ~& e
pMessage(wchNum); pMessage(L" "); k+=2;$ o& t$ C' m+ U' c! m# _( S
}& D ~; t, i0 a4 O. P0 |& G0 o( W/ W
}3 m' a& U6 d& V( `6 ~8 M
pMessage(L"\r\n"); k+=2;% @$ _- M+ `; e
a.BType=luStaData_int64; a.VType=luStaData_int64; a.x=k; //按函数o的要求，返回输出的字符总数; W7 n\\" o$ Q+ R1 m3 p
break;& v3 O4 [' y$ w* b1 H# W
default:
9 G. }( v\\" S! B. n
break;( [; q/ |! m( t$ h% N
}
2 X3 y; E+ R0 F) y
return a;
& F0 v0 ^ F5 g9 e# t
}
# @\\" x+ L! R) x% K) c ^
void main(void)) U. G9 M8 s9 B# J) n4 f* G! u
{
, ~! i' q9 Z' t\\" J
void *hFor; //表达式句柄
5 g @' N9 |7 e# N u1 r. B* {
luINT nPara; //存放表达式的自变量个数
( A! {+ @. R4 {4 b. Q9 g7 L4 D
LuData *pPara; //存放输入自变量的数组指针* b1 l! ~% j- r
luINT ErrBegin,ErrEnd; //表达式编译出错的初始位置和结束位置0 d3 C6 e) w. @6 n v. v
int ErrCode; //错误代码, s7 u( H2 f1 u6 p( g) G, E7 Y* K
void *v;
* s4 J- C; a$ D. h( u2 y
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.]}";//字符串表达式，矩阵乘
* Z\\" ~7 |6 A3 w5 S; t
//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.]}";//字符串表达式，矩阵点乘
% z' R\\" ^% z) O# x# l) o
LuData Val;
/ z, _: m' P% N6 f; Q
if(!InitLu()) return; //初始化Lu
7 T. f- D) v7 N, e6 X- Y
while(LockKey(Matrix,DelMatrix,OpMatrix)){Matrix++;} //锁定一个键，用于存储矩阵扩展类型
8 a# }( \7 ^6 X/ [5 g' q
9 x7 K1 t, Y& ^7 y) J& |0 W2 m& l
Val.BType=luStaData_int64; Val.VType=luStaData_int64; Val.x=Matrix; //定义整数常量; O& {' o3 b% u* k% |- N\\" \6 {+ X
SetConst(L"matrix",&Val); //设置整数常量& D' o/ M1 R* x( Y$ Y
InsertKey("\0\0\0\0",4,luPubKey_User,LuMessage,NULL,NULL,1,v); //使Lu运行时可输出函数信息
4 E$ } C# Y1 C1 m$ ~ C5 H1 D
wcout.imbue(locale("chs")); //设置输出的locale为中文0 m9 R: ?! e v& g a. s) d6 w
, I2 o; |& o+ A+ J# o
ErrCode=LuCom(ForStr,0,0,0,hFor,nPara,pPara,ErrBegin,ErrEnd); //编译表达式9 h3 l: ^$ x\\" N
if(ErrCode)# L, ]0 X4 F( p) j. D! N* t8 \
{% P& J/ g\\" @8 l! t7 x
wcout<<L"表达式有错误！错误代码："<<ErrCode<<endl;
: k6 [- g5 R, f5 q, \' x/ Z+ S
}
8 h# `% u) O7 t8 t\\" c9 d
else! `% v' j& J& N( j# m
{/ ]4 u7 ~7 z/ r9 k- {
LuCal(hFor,pPara); //计算表达式的值
6 a1 \8 x5 r0 q* G0 I! c2 ~
}5 y- N# m- W. @ X% g3 L6 S
LockKey(Matrix,NULL,OpMatrix);//解锁键Matrix，本例中，该函数可以不用
; r4 S) o, ]9 I
FreeLu(); //释放Lu- k7 g h0 b. w) `) a! M/ u& d* o
}

#include <windows.h> 
/ @/ [# y% W- z* N1 e0 n0 g
#include <iostream> 
1 }/ e9 g7 l; R2 D/ h3 r8 _6 E
#include <math.h> 
: t1 L! c5 H4 f) j, H# O
#include "lu32.h"0 b  k2 v! }  ^4 `; }) }

9 \. C. d8 ~$ `- x& x

#pragma comment( lib, "lu32.lib" )' R' c6 H% J; i6 Z7 f

% P7 t8 j9 i3 E
using namespace std; 
0 o5 `% H9 o* M- s; \, J4 E
: X4 w2 O3 N- M

luKEY Matrix=-1000;        //标识矩阵类型，最终的Matrix由LockKey决定 
; R: z- g6 c& f
0 l+ A1 J, O4 @/ j\\" ]  d& z  M9 F, Q

void _stdcall LuMessage(wchar_t *pch)//输出动态库信息，该函数注册到Lu，由Lu二级函数调用 & s  J& M7 B6 n3 v/ ~& f

{* w0 o' ?7 q3 N( o; n) z4 \  N' ]

wcout<<pch;5 ?. T# U. |, F' ]! {

}  e! C; V+ R, e0 A/ C; J  t

void _stdcall DelMatrix(void *me)        //用于LockKey函数，因为是基于系统内置实数数组创建矩阵，故该函数什么也不做 
, O( p% Q* p* |  p4 j# X/ D
{6 E: }* T0 G+ R0 C

} 
: H! x( d! U& J% l; r) c
LuData _stdcall OpMatrix(luINT mm,LuData *xx,void *hFor,int theOperator)        //运算符重载函数，用于LockKey函数 
. M9 O\\" y, g& }3 |9 K5 p\\" d/ H4 M! K
{' u! S4 M! ^# Q( q0 P- T

LuData a;& m  z8 R  x- m5 \\\" l& Y

luRealArray *pRealArray1,*pRealArray2,*pRealArray3; 
# Y. l1 j+ ~' _. ~  o- h
        luVOID i,j,k,m,n,u,v; 
0 {6 K\\" j; F; M: }\\" y6 _( `1 H
        double *pa,*pb,*pc; 
' I, }1 G5 q- \: _# W' q
        luMessage pMessage; 
# H\\" p% a# W, z2 f* ?5 i$ V2 {
        wchar_t wchNum[32]; 
' o$ r. ^\\" _, W# J2 |# O
        char chNum[32]; 
) v$ B7 p5 S4 C! k: h; k
        a.BType=luStaData_nil; a.VType=luStaData_nil; a.x=0; 
& k6 o+ H- a4 m% |( _( U5 ?
        switch(theOperator) 
! j# `/ j+ k- H& h. E
        {1 u5 z5 F( t8 m# |

case 2:        //重载运算符*5 U& Y' J+ c/ r. x9 v+ N

pRealArray1=(luRealArray *)SearchKey((char *)&(xx->x),sizeof(luVOID),luDynData_realarray);5 Z; b/ q0 {\\" ]3 p\\" c6 |$ l

pRealArray2=(luRealArray *)SearchKey((char *)&((xx+1)->x),sizeof(luVOID),luDynData_realarray); 
1 L2 {8 w9 V\\" ]7 T; F
                if(!pRealArray1 || !pRealArray2) break;        //对象句柄无效，不是实数数组) }( K( X/ t8 D  e' e/ I

if(pRealArray1->DimLen!=2 || pRealArray2->DimLen!=2) break;        //不是二维实数数组（矩阵）/ [  \$ l- y! U5 U2 _$ N/ ^7 m

if(pRealArray1->Dim[1]!=pRealArray2->Dim[0]) break;        //维数不匹配 
. L! |3 r. i% R/ b' b7 E
                pRealArray3=(luRealArray *)NewSysObj(luDynData_realarray,pRealArray1->Dim[0]*pRealArray2->Dim[1],2);        //创建矩阵对象 
. F9 [, i; p8 g
                if(!pRealArray3) break;7 E  }\\" D) h- Y

pRealArray3->Dim[0]=pRealArray1->Dim[0]; pRealArray3->Dim[1]=pRealArray2->Dim[1];        //设置矩阵维数大小 
# s0 f! A7 L2 E& Y( P% ?+ r+ {
                pa=pRealArray1->Array; pb=pRealArray2->Array; pc=pRealArray3->Array;- a* v: o( A2 j  ^4 @/ x\\" f

m=pRealArray1->Dim[0]; n=pRealArray1->Dim[1]; k=pRealArray2->Dim[1];8 t- _5 r9 e: h

for(i=0; i<m; i++)        //矩阵乘\\" S; }& l' H1 Z/ i  K* p\\" P0 l

{ 
; q/ C; c- D. v* c- l7 g2 B/ u) B
                        for(j=0; j<k; j++)& r, |1 o# f4 u7 D# r4 E

{ 
+ x9 F/ o% W) f\\" d* O2 A  \
                                u=i*k+j; pc[u]=0.0; 
; C* N0 n9 ~8 r
                                for (v=0; v<n; v++): H3 }( H\\" R9 z6 w/ {0 j6 U2 S

{ 
% M3 z. h\\" j8 c9 x% d! r
                                        pc[u]=pc[u]+pa[i*n+v]*pb[v*k+j]; 
  X+ v, \2 U/ g! ]8 |
                                } 
$ x& i' {# H: @- E; L
                        } 
6 Z5 f; W* e# X3 H\\" P
                } 
; q5 i- K% W9 |7 p% M
                FunReObj(hFor);        //告诉Lu，返回一个动态对象7 u) b6 [6 v1 v, |$ P\\" `: D/ ?- E

a.BType=luDynData_realarray; a.VType=Matrix; a.x=0; *(luVOID *)&(a.x)=(luVOID)pRealArray3; 
3 `; j5 p( S8 x5 w8 F/ V+ s
                break;& Q7 v% \: U6 O

case 25:        //重载运算符.*, f$ Q  g$ V$ @3 t* C9 u

pRealArray1=(luRealArray *)SearchKey((char *)&(xx->x),sizeof(luVOID),luDynData_realarray);6 O. Y) P/ Q1 K( S

pRealArray2=(luRealArray *)SearchKey((char *)&((xx+1)->x),sizeof(luVOID),luDynData_realarray);' d* j1 l, z0 \

if(!pRealArray1 || !pRealArray2) break;        //对象句柄无效，不是实数数组 
7 N+ O* M7 P! a0 W
                if(pRealArray1->DimLen!=2 || pRealArray2->DimLen!=2) break;        //不是二维实数数组（矩阵） 
6 G4 R- x\\" `3 o8 }  _% M
                if(pRealArray1->Dim[0]!=pRealArray2->Dim[0] || pRealArray1->Dim[1]!=pRealArray2->Dim[1]) break;        //维数不相同 
$ Z. t\\" g7 V5 Y& U\\" P
                pRealArray3=(luRealArray *)NewSysObj(luDynData_realarray,pRealArray1->ArrayLen,2);        //创建矩阵对象 
* ^/ O6 m+ g2 f$ f$ K
                if(!pRealArray3) break;/ |' \3 k3 b0 I$ P8 u

pRealArray3->Dim[0]=pRealArray1->Dim[0]; pRealArray3->Dim[1]=pRealArray1->Dim[1];        //设置矩阵维数大小: y3 b1 m+ E8 U6 Z

for(i=0;i<pRealArray1->ArrayLen;i++) pRealArray3->Array[i]=pRealArray1->Array[i]*pRealArray2->Array[i];//矩阵点乘3 v3 D. H2 g5 e. z* J0 ^

FunReObj(hFor);        //告诉Lu，返回一个动态对象! V0 n. e1 b7 g( [5 W

a.BType=luDynData_realarray; a.VType=Matrix; a.x=0; *(luVOID *)&(a.x)=(luVOID)pRealArray3;# r3 R3 `& ]: O5 o; w5 q9 y

break;4 \1 ^6 T# i3 v0 L! G

case 46:        //重载函数new; a$ o* x+ R7 ^  @( P

a=ExeOperator(mm,xx,hFor,theOperator,luDynData_realarray);        //直接调用基本类型luDynData_realarray的new函数 
9 d4 A, z5 F4 ?2 w
                if(a.VType==luDynData_realarray) a.VType=Matrix;        //设置扩展类型为自定义的Matrix类型) d' M! Z2 y1 F! U( l  ?

break;% T* t  U* {+ u\\" Y  b5 E# F# Q: `

case 49:        //重载函数o0 [! s; ?9 a+ O\\" W

pMessage=(luMessage)SearchKey("\0\0\0\0",sizeof(luVOID),luPubKey_User);+ M2 a9 I; o! A/ f7 O( t

if(!pMessage) break;, [( q( T1 Q* O

pRealArray1=(luRealArray *)SearchKey((char *)&(xx->x),sizeof(luVOID),luDynData_realarray);. ^1 R$ o: h6 b& ^: M

if(!pRealArray1) break;        //对象句柄无效，不是实数数组 
& e4 G  ]. M- x  m( y
                if(pRealArray1->DimLen!=2) break;        //不是二维实数数组（矩阵） 
1 _: \6 i8 N; P# ]
                pa=pRealArray1->Array; 
\\" u! N' m* h; P$ `
                m=pRealArray1->Dim[0]; n=pRealArray1->Dim[1]; k=0; 
7 g% I2 o+ X( N3 @$ [) s5 D
                for(i=0; i<m; i++)        //输出矩阵 
0 H7 S) [3 y2 c$ u7 r% u
                {\\" j# h8 u( I! o- ~4 b$ ]

pMessage(L"\r\n"); k+=2;& Y# W! o( w1 Y1 h# B8 O4 z

for(j=0; j<n; j++)2 V/ ^* a8 b; c/ p! s; z% @! L

{ 
0 s( i: x+ _6 K, d8 \
                                _gcvt_s(chNum,pa[i*n+j],16);& R6 e3 t2 _  u# r

for(u=0;chNum[u];u++) {wchNum[u]=chNum[u]; k++;} 
  ]& W* e0 }- m3 l$ V) }
                                wchNum[u]='\0'; 
* Q  y/ A8 i1 ~& e
                                pMessage(wchNum); pMessage(L"  "); k+=2;$ o& t$ C' m+ U' c! m# _( S

}& D  ~; t, i0 a4 O. P0 |& G0 o( W/ W

}3 m' a& U6 d& V( `6 ~8 M

pMessage(L"\r\n"); k+=2;% @$ _- M+ `; e

a.BType=luStaData_int64; a.VType=luStaData_int64; a.x=k;        //按函数o的要求，返回输出的字符总数; W7 n\\" o$ Q+ R1 m3 p

break;& v3 O4 [' y$ w* b1 H# W

default: 
9 G. }( v\\" S! B. n
                break;( [; q/ |! m( t$ h% N

} 
2 X3 y; E+ R0 F) y
        return a; 
& F0 v0 ^  F5 g9 e# t
} 
# @\\" x+ L! R) x% K) c  ^
void main(void)) U. G9 M8 s9 B# J) n4 f* G! u

{ 
, ~! i' q9 Z' t\\" J
        void *hFor;                //表达式句柄 
5 g  @' N9 |7 e# N  u1 r. B* {
        luINT nPara;                //存放表达式的自变量个数 
( A! {+ @. R4 {4 b. Q9 g7 L4 D
        LuData *pPara;                //存放输入自变量的数组指针* b1 l! ~% j- r

luINT ErrBegin,ErrEnd;        //表达式编译出错的初始位置和结束位置0 d3 C6 e) w. @6 n  v. v

int ErrCode;                //错误代码, s7 u( H2 f1 u6 p( g) G, E7 Y* K

void *v; 
* s4 J- C; a$ D. h( u2 y
        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.]}";//字符串表达式，矩阵乘 
* Z\\" ~7 |6 A3 w5 S; t
        //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.]}";//字符串表达式，矩阵点乘 
% z' R\\" ^% z) O# x# l) o
        LuData Val; 
/ z, _: m' P% N6 f; Q
        if(!InitLu()) return;        //初始化Lu 
7 T. f- D) v7 N, e6 X- Y
        while(LockKey(Matrix,DelMatrix,OpMatrix)){Matrix++;}        //锁定一个键，用于存储矩阵扩展类型 
8 a# }( \7 ^6 X/ [5 g' q
 
9 x7 K1 t, Y& ^7 y) J& |0 W2 m& l
        Val.BType=luStaData_int64; Val.VType=luStaData_int64; Val.x=Matrix;        //定义整数常量; O& {' o3 b% u* k% |- N\\" \6 {+ X

SetConst(L"matrix",&Val);        //设置整数常量& D' o/ M1 R* x( Y$ Y

InsertKey("\0\0\0\0",4,luPubKey_User,LuMessage,NULL,NULL,1,v); //使Lu运行时可输出函数信息 
4 E$ }  C# Y1 C1 m$ ~  C5 H1 D
        wcout.imbue(locale("chs"));        //设置输出的locale为中文0 m9 R: ?! e  v& g  a. s) d6 w

, I2 o; |& o+ A+ J# o
        ErrCode=LuCom(ForStr,0,0,0,hFor,nPara,pPara,ErrBegin,ErrEnd); //编译表达式9 h3 l: ^$ x\\" N

if(ErrCode)# L, ]0 X4 F( p) j. D! N* t8 \

{% P& J/ g\\" @8 l! t7 x

wcout<<L"表达式有错误！错误代码："<<ErrCode<<endl; 
: k6 [- g5 R, f5 q, \' x/ Z+ S
        } 
8 h# `% u) O7 t8 t\\" c9 d
        else! `% v' j& J& N( j# m

{/ ]4 u7 ~7 z/ r9 k- {

LuCal(hFor,pPara);        //计算表达式的值 
6 a1 \8 x5 r0 q* G0 I! c2 ~
        }5 y- N# m- W. @  X% g3 L6 S

LockKey(Matrix,NULL,OpMatrix);//解锁键Matrix，本例中，该函数可以不用 
; r4 S) o, ]9 I
        FreeLu();                        //释放Lu- k7 g  h0 b. w) `) a! M/ u& d* o

}

习题：

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

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

main(:a,b,c,d,t,i)=
) j; m8 p; i- I4 M
a=new[matrix,2,2,data:1.,2.,2.,1.],3 N! Y# K\" E' [6 o1 q! Z
b=new[matrix,2,2,data:2.,1.,1.,2.],
- K* k2 l\" {. j2 K5 n
c=new[matrix,2,2,data:2/3.,-1/3.,-1/3.,2/3.],
# |4 B5 b2 N/ U! {3 h8 |
t=clock(),
, Z+ f U( ~) v6 o\" ?5 l
d=a*b, i=0, while{i<1000000, d=d*c*b, i++},. y* Z* `7 H, a& x; U
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\"}";//字符串表达式

复制代码

结果：