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

查看: 8512|回复: 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>
4 u. [, W, \$ J
#include <iostream>\\" r5 S# ^2 T' D* n
#include <math.h>& q- t\\" T# h+ s' k
#include "lu32.h"2 p5 Y0 |! A; s\\" N& n2 Y; A
3 B- p# R5 C0 O: ? k& {* S9 h
#pragma comment( lib, "lu32.lib" )4 F: ^# V$ I- e8 V9 J$ w8 N( F
! I% _& W( y- ]' L V
using namespace std;
( @- K( s8 Q& R; M f! _5 n
/ U\\" A0 o. h* p# ^
luKEY Matrix=-1000; //标识矩阵类型，最终的Matrix由LockKey决定
( B( l9 G C/ O T' q8 }% ]
/ r! W* q: G* G- ?& a\\" _8 j
void _stdcall LuMessage(wchar_t *pch)//输出动态库信息，该函数注册到Lu，由Lu二级函数调用 5 J3 o\\" H# e5 _% J) E
{
. ^ i0 ?+ C7 W8 ?
wcout<<pch;5 @* e2 J U\\" R2 g. }
}
' i% D2 U- N* \6 [# o\\" p8 p
void _stdcall DelMatrix(void *me) //用于LockKey函数，因为是基于系统内置实数数组创建矩阵，故该函数什么也不做
! w4 l+ Q\\" Q6 T& G6 X6 W. j
{
9 j3 y2 q7 }! ? L1 M7 S
}
$ ^3 v( O0 s/ L% p. L
LuData _stdcall OpMatrix(luINT mm,LuData *xx,void *hFor,int theOperator) //运算符重载函数，用于LockKey函数
8 V3 A; L7 x4 D. v7 @+ P\\" T
{
( a& Y6 E6 U& h; ]+ `5 W4 T9 W
LuData a;
- c7 {) ~; U( `8 T: H) C* B q
luRealArray *pRealArray1,*pRealArray2,*pRealArray3;
9 g. C+ [; k\\" m
luVOID i,j,k,m,n,u,v;
* L/ t9 J1 X% U5 m7 V6 z$ X
double *pa,*pb,*pc;
- B3 E8 M* P\\" F& B- {& K
luMessage pMessage;! G' q\\" ]& j- @8 ]+ T
wchar_t wchNum[32];
# e8 m1 `' q0 B\\" D1 l5 g( r6 k8 g
char chNum[32];
0 u, H1 U\\" [9 I9 B' h: J* ]9 V, Q' i
a.BType=luStaData_nil; a.VType=luStaData_nil; a.x=0; ~\\" i; X [; r\\" p' J t4 V
switch(theOperator) K8 y! g6 e2 R/ ]0 j
{
D8 e3 [% S+ E% i& ]- k7 W
case 2: //重载运算符*
- R7 }' B1 N9 Y+ V\\" x
pRealArray1=(luRealArray *)SearchKey((char *)&(xx->x),sizeof(luVOID),luDynData_realarray);
3 r9 I; X- ~ Q+ k! G# b) W
pRealArray2=(luRealArray *)SearchKey((char *)&((xx+1)->x),sizeof(luVOID),luDynData_realarray);
: n) o' L\\" w# l/ o
if(!pRealArray1 || !pRealArray2) break; //对象句柄无效，不是实数数组
: ~- H6 @% u5 K7 k# f3 f; u9 A
if(pRealArray1->DimLen!=2 || pRealArray2->DimLen!=2) break; //不是二维实数数组（矩阵）( t; B) L$ F( p% G* |+ t; h$ k
if(pRealArray1->Dim[1]!=pRealArray2->Dim[0]) break; //维数不匹配5 U2 h1 L, x7 w
pRealArray3=(luRealArray *)NewSysObj(luDynData_realarray,pRealArray1->Dim[0]*pRealArray2->Dim[1],2); //创建矩阵对象0 ^$ _2 `% X\\" v: f
if(!pRealArray3) break;6 _4 W4 Q9 l2 O I, s7 Z; l
pRealArray3->Dim[0]=pRealArray1->Dim[0]; pRealArray3->Dim[1]=pRealArray2->Dim[1]; //设置矩阵维数大小 m) M3 _* |5 @; ?0 c5 F. _
pa=pRealArray1->Array; pb=pRealArray2->Array; pc=pRealArray3->Array;/ k2 P; }! f# r- d
m=pRealArray1->Dim[0]; n=pRealArray1->Dim[1]; k=pRealArray2->Dim[1];8 m: {4 R8 o) l. V
for(i=0; i<m; i++) //矩阵乘 S& b$ l. f# N2 Z' Q
{3 x2 G4 `0 g5 B
for(j=0; j<k; j++)
# d/ V) U\\" n# E0 s' A
{6 q4 H4 t/ z( p( G
u=i*k+j; pc[u]=0.0;
/ C9 o' ]/ T, a: v
for (v=0; v<n; v++)! B- ~+ y- A! A; j' ?' E, f
{( R; \$ U1 W\\" m9 z _
pc[u]=pc[u]+pa[i*n+v]*pb[v*k+j];
, `, Y# a5 ]4 X% k; B
}
; E% V1 b' o\\" d/ J: }
}' m* h; V( Y% u
}) p* F2 }% R; h/ m9 L
FunReObj(hFor); //告诉Lu，返回一个动态对象
( a+ u9 m6 k% y& Q
a.BType=luDynData_realarray; a.VType=Matrix; a.x=0; *(luVOID *)&(a.x)=(luVOID)pRealArray3;* S6 n# `: A, ~( E7 f3 i
break;3 I0 O+ ]+ h: v9 M
case 25: //重载运算符.*( q\\" C: I7 r3 J
pRealArray1=(luRealArray *)SearchKey((char *)&(xx->x),sizeof(luVOID),luDynData_realarray);( G8 E- I8 y' ]3 F! j: D6 P1 W
pRealArray2=(luRealArray *)SearchKey((char *)&((xx+1)->x),sizeof(luVOID),luDynData_realarray);' h& r7 l$ n9 J. U! H; r* r
if(!pRealArray1 || !pRealArray2) break; //对象句柄无效，不是实数数组
! P: _4 T\\" {# B! T4 x& C
if(pRealArray1->DimLen!=2 || pRealArray2->DimLen!=2) break; //不是二维实数数组（矩阵）( k `0 J& n\\" @% D2 P$ \& W
if(pRealArray1->Dim[0]!=pRealArray2->Dim[0] || pRealArray1->Dim[1]!=pRealArray2->Dim[1]) break; //维数不相同
5 k4 w6 ], I2 t
pRealArray3=(luRealArray *)NewSysObj(luDynData_realarray,pRealArray1->ArrayLen,2); //创建矩阵对象
# x; W. }, X8 R! v: o; ?
if(!pRealArray3) break;
~0 W) w1 D- T w
pRealArray3->Dim[0]=pRealArray1->Dim[0]; pRealArray3->Dim[1]=pRealArray1->Dim[1]; //设置矩阵维数大小* l' O M! \0 H9 _: y. P2 k+ W
for(i=0;i<pRealArray1->ArrayLen;i++) pRealArray3->Array[i]=pRealArray1->Array[i]*pRealArray2->Array[i];//矩阵点乘
7 {* U6 O\\" G6 j, g! q
FunReObj(hFor); //告诉Lu，返回一个动态对象
( e: Y: E& t0 ]5 f
a.BType=luDynData_realarray; a.VType=Matrix; a.x=0; *(luVOID *)&(a.x)=(luVOID)pRealArray3;
3 c5 S3 g& {. F, e' {
break;
( U* r/ B* p6 V5 ^
case 46: //重载函数new9 B. e) A l# a$ E1 _
a=ExeOperator(mm,xx,hFor,theOperator,luDynData_realarray); //直接调用基本类型luDynData_realarray的new函数. b4 s9 u, h, o$ B8 `\\" Z
if(a.VType==luDynData_realarray) a.VType=Matrix; //设置扩展类型为自定义的Matrix类型' A# n/ \! I# c+ B% \$ d9 h5 y
break; G% H0 k& D2 l- {7 \& s( s
case 49: //重载函数o
, z% G5 E: ]$ H& \\\" e; {% [
pMessage=(luMessage)SearchKey("\0\0\0\0",sizeof(luVOID),luPubKey_User);
. k0 ?- H8 C\\" O: E) e. C3 S% z# Q
if(!pMessage) break;
) i/ F0 t* q. |: C y2 L8 v
pRealArray1=(luRealArray *)SearchKey((char *)&(xx->x),sizeof(luVOID),luDynData_realarray);0 P& H+ O9 q* L& i! E/ u
if(!pRealArray1) break; //对象句柄无效，不是实数数组
6 r! A0 ?8 S2 q# z4 d5 z' k
if(pRealArray1->DimLen!=2) break; //不是二维实数数组（矩阵）
9 v0 w0 u% P2 L0 M: q* C
pa=pRealArray1->Array;
m=pRealArray1->Dim[0]; n=pRealArray1->Dim[1]; k=0;4 ?1 v9 V* q- Q: J/ K. R
for(i=0; i<m; i++) //输出矩阵
' I4 t* h- u+ _5 x
{2 c. k6 f' y7 `1 i
pMessage(L"\r\n"); k+=2;! ]# ]- V( a7 C7 F
for(j=0; j<n; j++)' G/ Q9 i1 l5 E. ?2 c
{
5 i& j# f8 n/ O9 D6 k( x
_gcvt_s(chNum,pa[i*n+j],16);
i d: |; S; S) D' }
for(u=0;chNum[u];u++) {wchNum[u]=chNum[u]; k++;}9 x9 g& o* z( S. u/ x/ A& j, o) f+ y5 Y
wchNum[u]='\0';4 A+ |8 j g0 [/ H\\" E, w
pMessage(wchNum); pMessage(L" "); k+=2;+ b+ \) z( i+ @ \
}2 B ^$ O# O7 E8 a\\" d: O9 {
}: J# _; h* N; E; S1 u
pMessage(L"\r\n"); k+=2; V# q: o# o5 C& I9 n: s H* H# }8 j
a.BType=luStaData_int64; a.VType=luStaData_int64; a.x=k; //按函数o的要求，返回输出的字符总数
% l! V' N% _5 R( s9 r
break;2 l4 r% ~4 m\\" o- {
default: q4 w* U4 a5 M7 L: f# [. l
break;% e8 b( y& G# ]! y
}
% s7 y\\" s: @# u$ m4 w
return a;
1 y+ ^8 @/ K4 X* O% E, r
}
4 X2 d2 z9 W( L+ T
void main(void)
# k; X# f' S# G! s, G, a
{/ v: r2 C# p- Z2 d
void *hFor; //表达式句柄9 ~# a c8 }2 j. R& J: I c
luINT nPara; //存放表达式的自变量个数0 v- R) q. I3 p4 c# O5 k5 O
LuData *pPara; //存放输入自变量的数组指针4 g, S5 m' W: i\\" n. o
luINT ErrBegin,ErrEnd; //表达式编译出错的初始位置和结束位置
- H, |% e; _) e- e! I
int ErrCode; //错误代码
2 E! o( J1 f# E) x/ w, z
void *v;( V: H5 w9 ]6 Y0 Q
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.]}";//字符串表达式，矩阵乘
' Q# N* t% f% m5 b2 N+ r
//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.]}";//字符串表达式，矩阵点乘
9 o- N2 F0 _9 R$ b( N O4 V! }
LuData Val;2 z) _$ h: V\\" M+ {: ]7 S
if(!InitLu()) return; //初始化Lu
. d1 J: g: z7 v- H, l1 h
while(LockKey(Matrix,DelMatrix,OpMatrix)){Matrix++;} //锁定一个键，用于存储矩阵扩展类型
+ g4 B( J( k1 N
9 B/ C4 v- m `
Val.BType=luStaData_int64; Val.VType=luStaData_int64; Val.x=Matrix; //定义整数常量\\" f4 s$ \2 a6 H5 d
SetConst(L"matrix",&Val); //设置整数常量. c! S% K& F/ d }2 H& T, _- t& d7 C* u
InsertKey("\0\0\0\0",4,luPubKey_User,LuMessage,NULL,NULL,1,v); //使Lu运行时可输出函数信息. F& ]: e) `9 |. M$ U: j. ?\\" r\\" E
wcout.imbue(locale("chs")); //设置输出的locale为中文2 |6 n3 F3 _: W/ I% @; ]
5 b0 Y6 i1 o' D
ErrCode=LuCom(ForStr,0,0,0,hFor,nPara,pPara,ErrBegin,ErrEnd); //编译表达式
0 K( Q T\\" c6 d
if(ErrCode)
' y3 H; }* E2 i& P* N
{
& W Z! w( S( e3 {1 g
wcout<<L"表达式有错误！错误代码："<<ErrCode<<endl;- c7 _9 J& O8 z/ ], ?/ e
}\\" L0 o t# }! w X
else9 B: w2 G; S- Q: C2 M/ U1 X
{
' i T$ {1 S1 T# }7 X2 } ^: y+ V
LuCal(hFor,pPara); //计算表达式的值# |2 w# A( m* x) V
}3 Q: f6 e# u1 i: O' @# A+ C) ^
LockKey(Matrix,NULL,OpMatrix);//解锁键Matrix，本例中，该函数可以不用
6 u+ B6 Y$ n# t/ R0 Y/ W
FreeLu(); //释放Lu! B2 e3 q, c\\" o; P$ A+ H8 D
}

#include <windows.h> 
4 u. [, W, \$ J
#include <iostream>\\" r5 S# ^2 T' D* n

#include <math.h>& q- t\\" T# h+ s' k

#include "lu32.h"2 p5 Y0 |! A; s\\" N& n2 Y; A

3 B- p# R5 C0 O: ?  k& {* S9 h

#pragma comment( lib, "lu32.lib" )4 F: ^# V$ I- e8 V9 J$ w8 N( F

! I% _& W( y- ]' L  V

using namespace std; 
( @- K( s8 Q& R; M  f! _5 n
/ U\\" A0 o. h* p# ^

luKEY Matrix=-1000;        //标识矩阵类型，最终的Matrix由LockKey决定 
( B( l9 G  C/ O  T' q8 }% ]
 
/ r! W* q: G* G- ?& a\\" _8 j
void _stdcall LuMessage(wchar_t *pch)//输出动态库信息，该函数注册到Lu，由Lu二级函数调用 5 J3 o\\" H# e5 _% J) E

{ 
. ^  i0 ?+ C7 W8 ?
        wcout<<pch;5 @* e2 J  U\\" R2 g. }

} 
' i% D2 U- N* \6 [# o\\" p8 p
void _stdcall DelMatrix(void *me)        //用于LockKey函数，因为是基于系统内置实数数组创建矩阵，故该函数什么也不做 
! w4 l+ Q\\" Q6 T& G6 X6 W. j
{ 
9 j3 y2 q7 }! ?  L1 M7 S
} 
$ ^3 v( O0 s/ L% p. L
LuData _stdcall OpMatrix(luINT mm,LuData *xx,void *hFor,int theOperator)        //运算符重载函数，用于LockKey函数 
8 V3 A; L7 x4 D. v7 @+ P\\" T
{ 
( a& Y6 E6 U& h; ]+ `5 W4 T9 W
        LuData a; 
- c7 {) ~; U( `8 T: H) C* B  q
        luRealArray *pRealArray1,*pRealArray2,*pRealArray3; 
9 g. C+ [; k\\" m
        luVOID i,j,k,m,n,u,v; 
* L/ t9 J1 X% U5 m7 V6 z$ X
        double *pa,*pb,*pc; 
- B3 E8 M* P\\" F& B- {& K
        luMessage pMessage;! G' q\\" ]& j- @8 ]+ T

wchar_t wchNum[32]; 
# e8 m1 `' q0 B\\" D1 l5 g( r6 k8 g
        char chNum[32]; 
0 u, H1 U\\" [9 I9 B' h: J* ]9 V, Q' i
        a.BType=luStaData_nil; a.VType=luStaData_nil; a.x=0;  ~\\" i; X  [; r\\" p' J  t4 V

switch(theOperator)  K8 y! g6 e2 R/ ]0 j

{ 
  D8 e3 [% S+ E% i& ]- k7 W
        case 2:        //重载运算符* 
- R7 }' B1 N9 Y+ V\\" x
                pRealArray1=(luRealArray *)SearchKey((char *)&(xx->x),sizeof(luVOID),luDynData_realarray); 
3 r9 I; X- ~  Q+ k! G# b) W
                pRealArray2=(luRealArray *)SearchKey((char *)&((xx+1)->x),sizeof(luVOID),luDynData_realarray); 
: n) o' L\\" w# l/ o
                if(!pRealArray1 || !pRealArray2) break;        //对象句柄无效，不是实数数组 
: ~- H6 @% u5 K7 k# f3 f; u9 A
                if(pRealArray1->DimLen!=2 || pRealArray2->DimLen!=2) break;        //不是二维实数数组（矩阵）( t; B) L$ F( p% G* |+ t; h$ k

if(pRealArray1->Dim[1]!=pRealArray2->Dim[0]) break;        //维数不匹配5 U2 h1 L, x7 w

pRealArray3=(luRealArray *)NewSysObj(luDynData_realarray,pRealArray1->Dim[0]*pRealArray2->Dim[1],2);        //创建矩阵对象0 ^$ _2 `% X\\" v: f

if(!pRealArray3) break;6 _4 W4 Q9 l2 O  I, s7 Z; l

pRealArray3->Dim[0]=pRealArray1->Dim[0]; pRealArray3->Dim[1]=pRealArray2->Dim[1];        //设置矩阵维数大小  m) M3 _* |5 @; ?0 c5 F. _

pa=pRealArray1->Array; pb=pRealArray2->Array; pc=pRealArray3->Array;/ k2 P; }! f# r- d

m=pRealArray1->Dim[0]; n=pRealArray1->Dim[1]; k=pRealArray2->Dim[1];8 m: {4 R8 o) l. V

for(i=0; i<m; i++)        //矩阵乘  S& b$ l. f# N2 Z' Q

{3 x2 G4 `0 g5 B

for(j=0; j<k; j++) 
# d/ V) U\\" n# E0 s' A
                        {6 q4 H4 t/ z( p( G

u=i*k+j; pc[u]=0.0; 
/ C9 o' ]/ T, a: v
                                for (v=0; v<n; v++)! B- ~+ y- A! A; j' ?' E, f

{( R; \$ U1 W\\" m9 z  _

pc[u]=pc[u]+pa[i*n+v]*pb[v*k+j]; 
, `, Y# a5 ]4 X% k; B
                                } 
; E% V1 b' o\\" d/ J: }
                        }' m* h; V( Y% u

}) p* F2 }% R; h/ m9 L

FunReObj(hFor);        //告诉Lu，返回一个动态对象 
( a+ u9 m6 k% y& Q
                a.BType=luDynData_realarray; a.VType=Matrix; a.x=0; *(luVOID *)&(a.x)=(luVOID)pRealArray3;* S6 n# `: A, ~( E7 f3 i

break;3 I0 O+ ]+ h: v9 M

case 25:        //重载运算符.*( q\\" C: I7 r3 J

pRealArray1=(luRealArray *)SearchKey((char *)&(xx->x),sizeof(luVOID),luDynData_realarray);( G8 E- I8 y' ]3 F! j: D6 P1 W

pRealArray2=(luRealArray *)SearchKey((char *)&((xx+1)->x),sizeof(luVOID),luDynData_realarray);' h& r7 l$ n9 J. U! H; r* r

if(!pRealArray1 || !pRealArray2) break;        //对象句柄无效，不是实数数组 
! P: _4 T\\" {# B! T4 x& C
                if(pRealArray1->DimLen!=2 || pRealArray2->DimLen!=2) break;        //不是二维实数数组（矩阵）( k  `0 J& n\\" @% D2 P$ \& W

if(pRealArray1->Dim[0]!=pRealArray2->Dim[0] || pRealArray1->Dim[1]!=pRealArray2->Dim[1]) break;        //维数不相同 
5 k4 w6 ], I2 t
                pRealArray3=(luRealArray *)NewSysObj(luDynData_realarray,pRealArray1->ArrayLen,2);        //创建矩阵对象 
# x; W. }, X8 R! v: o; ?
                if(!pRealArray3) break; 
  ~0 W) w1 D- T  w
                pRealArray3->Dim[0]=pRealArray1->Dim[0]; pRealArray3->Dim[1]=pRealArray1->Dim[1];        //设置矩阵维数大小* l' O  M! \0 H9 _: y. P2 k+ W

for(i=0;i<pRealArray1->ArrayLen;i++) pRealArray3->Array[i]=pRealArray1->Array[i]*pRealArray2->Array[i];//矩阵点乘 
7 {* U6 O\\" G6 j, g! q
                FunReObj(hFor);        //告诉Lu，返回一个动态对象 
( e: Y: E& t0 ]5 f
                a.BType=luDynData_realarray; a.VType=Matrix; a.x=0; *(luVOID *)&(a.x)=(luVOID)pRealArray3; 
3 c5 S3 g& {. F, e' {
                break; 
( U* r/ B* p6 V5 ^
        case 46:        //重载函数new9 B. e) A  l# a$ E1 _

a=ExeOperator(mm,xx,hFor,theOperator,luDynData_realarray);        //直接调用基本类型luDynData_realarray的new函数. b4 s9 u, h, o$ B8 `\\" Z

if(a.VType==luDynData_realarray) a.VType=Matrix;        //设置扩展类型为自定义的Matrix类型' A# n/ \! I# c+ B% \$ d9 h5 y

break;  G% H0 k& D2 l- {7 \& s( s

case 49:        //重载函数o 
, z% G5 E: ]$ H& \\\" e; {% [
                pMessage=(luMessage)SearchKey("\0\0\0\0",sizeof(luVOID),luPubKey_User); 
. k0 ?- H8 C\\" O: E) e. C3 S% z# Q
                if(!pMessage) break; 
) i/ F0 t* q. |: C  y2 L8 v
                pRealArray1=(luRealArray *)SearchKey((char *)&(xx->x),sizeof(luVOID),luDynData_realarray);0 P& H+ O9 q* L& i! E/ u

if(!pRealArray1) break;        //对象句柄无效，不是实数数组 
6 r! A0 ?8 S2 q# z4 d5 z' k
                if(pRealArray1->DimLen!=2) break;        //不是二维实数数组（矩阵） 
9 v0 w0 u% P2 L0 M: q* C
                pa=pRealArray1->Array; 
6 R  i$ E$ }; c3 l* ~  D0 N$ l  G) l
                m=pRealArray1->Dim[0]; n=pRealArray1->Dim[1]; k=0;4 ?1 v9 V* q- Q: J/ K. R

for(i=0; i<m; i++)        //输出矩阵 
' I4 t* h- u+ _5 x
                {2 c. k6 f' y7 `1 i

pMessage(L"\r\n"); k+=2;! ]# ]- V( a7 C7 F

for(j=0; j<n; j++)' G/ Q9 i1 l5 E. ?2 c

{ 
5 i& j# f8 n/ O9 D6 k( x
                                _gcvt_s(chNum,pa[i*n+j],16); 
  i  d: |; S; S) D' }
                                for(u=0;chNum[u];u++) {wchNum[u]=chNum[u]; k++;}9 x9 g& o* z( S. u/ x/ A& j, o) f+ y5 Y

wchNum[u]='\0';4 A+ |8 j  g0 [/ H\\" E, w

pMessage(wchNum); pMessage(L"  "); k+=2;+ b+ \) z( i+ @  \

}2 B  ^$ O# O7 E8 a\\" d: O9 {

}: J# _; h* N; E; S1 u

pMessage(L"\r\n"); k+=2;  V# q: o# o5 C& I9 n: s  H* H# }8 j

a.BType=luStaData_int64; a.VType=luStaData_int64; a.x=k;        //按函数o的要求，返回输出的字符总数 
% l! V' N% _5 R( s9 r
                break;2 l4 r% ~4 m\\" o- {

default:  q4 w* U4 a5 M7 L: f# [. l

break;% e8 b( y& G# ]! y

} 
% s7 y\\" s: @# u$ m4 w
        return a; 
1 y+ ^8 @/ K4 X* O% E, r
} 
4 X2 d2 z9 W( L+ T
void main(void) 
# k; X# f' S# G! s, G, a
{/ v: r2 C# p- Z2 d

void *hFor;                //表达式句柄9 ~# a  c8 }2 j. R& J: I  c

luINT nPara;                //存放表达式的自变量个数0 v- R) q. I3 p4 c# O5 k5 O

LuData *pPara;                //存放输入自变量的数组指针4 g, S5 m' W: i\\" n. o

luINT ErrBegin,ErrEnd;        //表达式编译出错的初始位置和结束位置 
- H, |% e; _) e- e! I
        int ErrCode;                //错误代码 
2 E! o( J1 f# E) x/ w, z
        void *v;( V: H5 w9 ]6 Y0 Q

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.]}";//字符串表达式，矩阵乘 
' Q# N* t% f% m5 b2 N+ r
        //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.]}";//字符串表达式，矩阵点乘 
9 o- N2 F0 _9 R$ b( N  O4 V! }
        LuData Val;2 z) _$ h: V\\" M+ {: ]7 S

if(!InitLu()) return;        //初始化Lu 
. d1 J: g: z7 v- H, l1 h
        while(LockKey(Matrix,DelMatrix,OpMatrix)){Matrix++;}        //锁定一个键，用于存储矩阵扩展类型 
+ g4 B( J( k1 N
 
9 B/ C4 v- m  `
        Val.BType=luStaData_int64; Val.VType=luStaData_int64; Val.x=Matrix;        //定义整数常量\\" f4 s$ \2 a6 H5 d

SetConst(L"matrix",&Val);        //设置整数常量. c! S% K& F/ d  }2 H& T, _- t& d7 C* u

InsertKey("\0\0\0\0",4,luPubKey_User,LuMessage,NULL,NULL,1,v); //使Lu运行时可输出函数信息. F& ]: e) `9 |. M$ U: j. ?\\" r\\" E

wcout.imbue(locale("chs"));        //设置输出的locale为中文2 |6 n3 F3 _: W/ I% @; ]

5 b0 Y6 i1 o' D

ErrCode=LuCom(ForStr,0,0,0,hFor,nPara,pPara,ErrBegin,ErrEnd); //编译表达式 
0 K( Q  T\\" c6 d
        if(ErrCode) 
' y3 H; }* E2 i& P* N
        { 
& W  Z! w( S( e3 {1 g
                wcout<<L"表达式有错误！错误代码："<<ErrCode<<endl;- c7 _9 J& O8 z/ ], ?/ e

}\\" L0 o  t# }! w  X

else9 B: w2 G; S- Q: C2 M/ U1 X

{ 
' i  T$ {1 S1 T# }7 X2 }  ^: y+ V
                LuCal(hFor,pPara);        //计算表达式的值# |2 w# A( m* x) V

}3 Q: f6 e# u1 i: O' @# A+ C) ^

LockKey(Matrix,NULL,OpMatrix);//解锁键Matrix，本例中，该函数可以不用 
6 u+ B6 Y$ n# t/ R0 Y/ W
        FreeLu();                        //释放Lu! B2 e3 q, c\\" o; P$ A+ H8 D

}

习题：

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

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

main(:a,b,c,d,t,i)=0 Z! P: ]5 ?9 k# v' r
a=new[matrix,2,2,data:1.,2.,2.,1.],0 B3 [, C8 c- p. _2 k
b=new[matrix,2,2,data:2.,1.,1.,2.],
& c3 r, i# l- g a5 ~7 }
c=new[matrix,2,2,data:2/3.,-1/3.,-1/3.,2/3.],6 b\" T, M2 p2 a4 N Y. m
t=clock(),
' v; W4 A3 l; L# ]: k) I
d=a*b, i=0, while{i<1000000, d=d*c*b, i++},- k7 Y. M! y \0 z0 w6 }5 ~$ r, @
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\"}";//字符串表达式

复制代码

结果：