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

查看: 8752|回复: 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>
2 f6 L: u6 Q+ y0 h
#include <iostream>
, Q& H6 N) V3 Q- f* P5 {
#include <math.h>
, q1 s! b1 l7 X. B, j\\" |. u
#include "lu32.h"
0 ?/ r, R7 f7 M q8 E4 M# A
D0 R, }( j) P( F2 | b
#pragma comment( lib, "lu32.lib" )
% }! s) D9 B\\" x/ R$ {
; ]& u/ u5 B* H# o3 h* m+ {) T
using namespace std;
: z. J\\" i* p+ a9 h7 e W) @ A
' v& b6 ]; C$ ^* D8 N. b5 P9 a% I
luKEY Matrix=-1000; //标识矩阵类型，最终的Matrix由LockKey决定
4 ?* {% H. m- A0 J
! a( V; Q2 a% V
void _stdcall LuMessage(wchar_t *pch)//输出动态库信息，该函数注册到Lu，由Lu二级函数调用 7 E/ {/ w( U3 D' c9 d. s
{6 B$ J$ B+ f+ s7 ^$ l3 |2 F) Q
wcout<<pch;3 k: o# X: ~# t2 N\\" [( K# V
}
! Z( k# ~5 Q; ?) J+ A% Z2 f: Q
void _stdcall DelMatrix(void *me) //用于LockKey函数，因为是基于系统内置实数数组创建矩阵，故该函数什么也不做- P$ d7 r4 ^4 M- m& y# r- n
{& W( G( {8 n, c\\" I. } Y
}9 D, d3 D. H8 _% R- e# e1 L* O- i
LuData _stdcall OpMatrix(luINT mm,LuData *xx,void *hFor,int theOperator) //运算符重载函数，用于LockKey函数5 c' A1 ?0 Q+ ]+ V; q
{
- f4 j) J6 q* E9 j
LuData a;5 u/ a2 u& M( e
luRealArray *pRealArray1,*pRealArray2,*pRealArray3;
0 Y7 E3 r! Q/ K/ ]7 [\\" s
luVOID i,j,k,m,n,u,v;
( o! I( z/ O. s- n3 d! m% V
double *pa,*pb,*pc;' Y: J' c* [, H7 p# O) ~# w
luMessage pMessage;* \4 s9 ^+ n' \' r5 a
wchar_t wchNum[32];% U# `\\" S$ U# T# A5 b E
char chNum[32];
% ^ g- X\\" A. A
a.BType=luStaData_nil; a.VType=luStaData_nil; a.x=0;5 P' P/ Y: c0 b6 k [1 G
switch(theOperator)6 K% [, V9 Z6 G\\" E9 u) B1 r3 F
{
. c, I0 n% R; ]6 r! W
case 2: //重载运算符*
p( r# Z- x% g) w' q( n6 E5 M% c
pRealArray1=(luRealArray *)SearchKey((char *)&(xx->x),sizeof(luVOID),luDynData_realarray);2 M- u' e5 `3 U# Q+ d6 h! j; q) u
pRealArray2=(luRealArray *)SearchKey((char *)&((xx+1)->x),sizeof(luVOID),luDynData_realarray);
4 M0 _4 P2 z1 e+ E7 a% u
if(!pRealArray1 || !pRealArray2) break; //对象句柄无效，不是实数数组7 S. d7 G( ~+ T9 x1 }
if(pRealArray1->DimLen!=2 || pRealArray2->DimLen!=2) break; //不是二维实数数组（矩阵）( ~7 H: \% ]2 z\\" @2 Y
if(pRealArray1->Dim[1]!=pRealArray2->Dim[0]) break; //维数不匹配- @6 ]9 ^7 f0 _9 T3 T# g4 s' F/ ~. z* x$ P+ o
pRealArray3=(luRealArray *)NewSysObj(luDynData_realarray,pRealArray1->Dim[0]*pRealArray2->Dim[1],2); //创建矩阵对象
]( O. P) [# h; i. u O3 h K
if(!pRealArray3) break;
) h. t: ]8 J\\" X/ {( j
pRealArray3->Dim[0]=pRealArray1->Dim[0]; pRealArray3->Dim[1]=pRealArray2->Dim[1]; //设置矩阵维数大小6 G, q7 o/ M# Q$ ]8 c
pa=pRealArray1->Array; pb=pRealArray2->Array; pc=pRealArray3->Array;
3 G+ T\\" s( r c0 P0 K: L; Z- b; \
m=pRealArray1->Dim[0]; n=pRealArray1->Dim[1]; k=pRealArray2->Dim[1];# v& K& N1 S* p8 s
for(i=0; i<m; i++) //矩阵乘, @1 L\\" u3 E C9 y' B+ Z
{6 t2 q! I3 O/ S. N Z/ [9 z/ g
for(j=0; j<k; j++)7 K2 R3 T I0 q% Z* Q
{
: _7 D# i7 R- j F
u=i*k+j; pc[u]=0.0;! {, P6 V5 Q3 s1 T
for (v=0; v<n; v++)- D6 |0 i, B3 W$ u
{
7 o0 C+ ]- k/ w; n
pc[u]=pc[u]+pa[i*n+v]*pb[v*k+j];
\\" H5 f8 E. K7 A. B3 w: K
}9 A9 y Y/ B9 Q; Y
}
! y; ]7 r7 z) @7 i/ G9 }/ Q7 v, k
}
$ v/ Q; @: o+ M
FunReObj(hFor); //告诉Lu，返回一个动态对象
\\" w* a- N n0 ^\\" B) v
a.BType=luDynData_realarray; a.VType=Matrix; a.x=0; *(luVOID *)&(a.x)=(luVOID)pRealArray3;
& r) m1 ?. a* B' T* Q3 h
break;\\" W5 q0 @* ]8 M& Z% F2 Q( J! [' i
case 25: //重载运算符.*$ O/ _; [5 h% ]4 c6 v; [' p
pRealArray1=(luRealArray *)SearchKey((char *)&(xx->x),sizeof(luVOID),luDynData_realarray);( Q\\" |# N$ C, Q' i; y
pRealArray2=(luRealArray *)SearchKey((char *)&((xx+1)->x),sizeof(luVOID),luDynData_realarray);
\\" J8 N3 T8 W& k6 v5 S6 z
if(!pRealArray1 || !pRealArray2) break; //对象句柄无效，不是实数数组
9 ^0 z Z/ j- T1 o4 D- Q
if(pRealArray1->DimLen!=2 || pRealArray2->DimLen!=2) break; //不是二维实数数组（矩阵）
\\" a2 ~! y7 h5 s3 s# C
if(pRealArray1->Dim[0]!=pRealArray2->Dim[0] || pRealArray1->Dim[1]!=pRealArray2->Dim[1]) break; //维数不相同
/ l/ _4 f6 O9 P& w* M( e
pRealArray3=(luRealArray *)NewSysObj(luDynData_realarray,pRealArray1->ArrayLen,2); //创建矩阵对象
+ j# \0 E. G2 M6 ~! D9 w
if(!pRealArray3) break;
7 [+ c, @7 x( Z- d! F z
pRealArray3->Dim[0]=pRealArray1->Dim[0]; pRealArray3->Dim[1]=pRealArray1->Dim[1]; //设置矩阵维数大小2 y/ y6 k4 G8 t, V: x; K# Z( `5 z
for(i=0;i<pRealArray1->ArrayLen;i++) pRealArray3->Array[i]=pRealArray1->Array[i]*pRealArray2->Array[i];//矩阵点乘# S$ A. w# H; ?' C& E
FunReObj(hFor); //告诉Lu，返回一个动态对象\\" G. Z4 L6 } U X0 t
a.BType=luDynData_realarray; a.VType=Matrix; a.x=0; *(luVOID *)&(a.x)=(luVOID)pRealArray3;7 Q1 m6 p. g; O' Q
break;
6 j) l8 a6 B5 X0 ^4 o$ N
case 46: //重载函数new( l( I# x9 Q$ p& \& ^
a=ExeOperator(mm,xx,hFor,theOperator,luDynData_realarray); //直接调用基本类型luDynData_realarray的new函数
3 P' r4 Q' Z( b$ C
if(a.VType==luDynData_realarray) a.VType=Matrix; //设置扩展类型为自定义的Matrix类型% J' E# n% }2 U1 M+ c\\" N
break;! F\\" ^+ z+ P2 o3 [' n# Y
case 49: //重载函数o
1 H8 _- E8 G( a) j
pMessage=(luMessage)SearchKey("\0\0\0\0",sizeof(luVOID),luPubKey_User);7 P2 N; v7 u$ i, r
if(!pMessage) break;
7 ~; k: L! d0 c4 n
pRealArray1=(luRealArray *)SearchKey((char *)&(xx->x),sizeof(luVOID),luDynData_realarray);) G. `3 z' A$ g- i9 _
if(!pRealArray1) break; //对象句柄无效，不是实数数组
0 b) z ~ E6 s4 ], [. [
if(pRealArray1->DimLen!=2) break; //不是二维实数数组（矩阵）7 \( k; @; ~, S& M' g$ I
pa=pRealArray1->Array;
6 R, A2 E) q: S: ^4 g# d5 ?& Z
m=pRealArray1->Dim[0]; n=pRealArray1->Dim[1]; k=0;
9 v& a* C% K; @4 ? q
for(i=0; i<m; i++) //输出矩阵0 o: ^7 i0 p7 X7 m# s\\" j9 c1 F# `
{5 x- A4 k+ E& R
pMessage(L"\r\n"); k+=2;
: g- v! G\\" z; I r4 x- J2 b
for(j=0; j<n; j++)2 @4 X6 H\\" y) Y4 S. v- o
{
) p& I1 X7 v+ ~
_gcvt_s(chNum,pa[i*n+j],16);
0 P$ z9 v( M* C
for(u=0;chNum[u];u++) {wchNum[u]=chNum[u]; k++;}/ a7 u( h' Y4 l- Q( G5 I
wchNum[u]='\0';3 D5 a0 `\\" O( d& W1 K ~
pMessage(wchNum); pMessage(L" "); k+=2;
% k4 X( U7 R$ o% D
}- p/ [: @: ^* v
}
\\" @* }+ p+ O+ b8 T: ]9 b
pMessage(L"\r\n"); k+=2;4 `8 E3 L) i O6 [\\" {+ D9 Q
a.BType=luStaData_int64; a.VType=luStaData_int64; a.x=k; //按函数o的要求，返回输出的字符总数
; B$ h: U\\" X/ K! k' s& M8 c
break;3 W6 O% A2 B! d; d# G0 h+ E
default:
0 T' P/ j! M4 j# X
break; Z6 _) S2 q: c. u5 Q& @* k- e
}5 ?3 u( P2 u2 w* Q: J
return a;
) o+ M) a\\" u( g6 z5 c. t: _: q
}9 R0 ^3 k2 J9 H, c6 }
void main(void)
! F9 j' {- {0 `) m; x5 g: [' m
{2 [; `/ p j+ m+ _6 l! P
void *hFor; //表达式句柄% C' S* S) _5 p
luINT nPara; //存放表达式的自变量个数$ P5 L' }: z7 E/ ]/ k# X
LuData *pPara; //存放输入自变量的数组指针) \+ N& W: @4 u! Q- |
luINT ErrBegin,ErrEnd; //表达式编译出错的初始位置和结束位置/ b6 y- \1 |$ J
int ErrCode; //错误代码
, Z\\" P9 `. ~* b% Z6 n. ?! |
void *v;8 L! \, n& ?7 N4 a# J
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$ W/ B& L a: S
//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.]}";//字符串表达式，矩阵点乘
O% c9 t; |' ]4 _; z! T+ J7 f
LuData Val;
, [6 L8 ?1 D6 M' Q
if(!InitLu()) return; //初始化Lu5 f: U- p0 G! X
while(LockKey(Matrix,DelMatrix,OpMatrix)){Matrix++;} //锁定一个键，用于存储矩阵扩展类型/ Y; I$ D1 h P9 V
4 G\\" E0 x: r* K
Val.BType=luStaData_int64; Val.VType=luStaData_int64; Val.x=Matrix; //定义整数常量: E; K8 P) o\\" ?% Y$ T* ~) f. N\\" q* P
SetConst(L"matrix",&Val); //设置整数常量* f. H' l/ j9 O: F. H' g
InsertKey("\0\0\0\0",4,luPubKey_User,LuMessage,NULL,NULL,1,v); //使Lu运行时可输出函数信息
3 z d& j* v( q# q8 C
wcout.imbue(locale("chs")); //设置输出的locale为中文
# L, r0 {% W: {0 Z# r- `! a
' Y8 f& _\\" D' `7 j! D. j\\" i
ErrCode=LuCom(ForStr,0,0,0,hFor,nPara,pPara,ErrBegin,ErrEnd); //编译表达式
; g( S; ~$ V5 a2 _; M
if(ErrCode)- a/ x& k% z0 a7 Q# j( k
{
7 j7 {\\" w# @& c
wcout<<L"表达式有错误！错误代码："<<ErrCode<<endl;% u' K/ ~0 P) G2 R6 G, J
}& e+ o- J9 ]6 q
else X# f6 D/ i( u3 }, T\\" n
{# t1 @5 k\\" ^& _1 n- |; _' [. B; E# A
LuCal(hFor,pPara); //计算表达式的值6 A j8 \- @& F- I4 ]
}
+ t. n; P) c; b' u4 ^8 p4 s! l
LockKey(Matrix,NULL,OpMatrix);//解锁键Matrix，本例中，该函数可以不用
1 W2 _1 Z6 Y* u
FreeLu(); //释放Lu
\\" A( u0 Q2 U! X0 }
}

#include <windows.h> 
2 f6 L: u6 Q+ y0 h
#include <iostream> 
, Q& H6 N) V3 Q- f* P5 {
#include <math.h> 
, q1 s! b1 l7 X. B, j\\" |. u
#include "lu32.h" 
0 ?/ r, R7 f7 M  q8 E4 M# A
 
  D0 R, }( j) P( F2 |  b
#pragma comment( lib, "lu32.lib" ) 
% }! s) D9 B\\" x/ R$ {
 
; ]& u/ u5 B* H# o3 h* m+ {) T
using namespace std; 
: z. J\\" i* p+ a9 h7 e  W) @  A
' v& b6 ]; C$ ^* D8 N. b5 P9 a% I

luKEY Matrix=-1000;        //标识矩阵类型，最终的Matrix由LockKey决定 
4 ?* {% H. m- A0 J
 
! a( V; Q2 a% V
void _stdcall LuMessage(wchar_t *pch)//输出动态库信息，该函数注册到Lu，由Lu二级函数调用 7 E/ {/ w( U3 D' c9 d. s

{6 B$ J$ B+ f+ s7 ^$ l3 |2 F) Q

wcout<<pch;3 k: o# X: ~# t2 N\\" [( K# V

} 
! Z( k# ~5 Q; ?) J+ A% Z2 f: Q
void _stdcall DelMatrix(void *me)        //用于LockKey函数，因为是基于系统内置实数数组创建矩阵，故该函数什么也不做- P$ d7 r4 ^4 M- m& y# r- n

{& W( G( {8 n, c\\" I. }  Y

}9 D, d3 D. H8 _% R- e# e1 L* O- i

LuData _stdcall OpMatrix(luINT mm,LuData *xx,void *hFor,int theOperator)        //运算符重载函数，用于LockKey函数5 c' A1 ?0 Q+ ]+ V; q

{ 
- f4 j) J6 q* E9 j
        LuData a;5 u/ a2 u& M( e

luRealArray *pRealArray1,*pRealArray2,*pRealArray3; 
0 Y7 E3 r! Q/ K/ ]7 [\\" s
        luVOID i,j,k,m,n,u,v; 
( o! I( z/ O. s- n3 d! m% V
        double *pa,*pb,*pc;' Y: J' c* [, H7 p# O) ~# w

luMessage pMessage;* \4 s9 ^+ n' \' r5 a

wchar_t wchNum[32];% U# `\\" S$ U# T# A5 b  E

char chNum[32]; 
% ^  g- X\\" A. A
        a.BType=luStaData_nil; a.VType=luStaData_nil; a.x=0;5 P' P/ Y: c0 b6 k  [1 G

switch(theOperator)6 K% [, V9 Z6 G\\" E9 u) B1 r3 F

{ 
. c, I0 n% R; ]6 r! W
        case 2:        //重载运算符* 
  p( r# Z- x% g) w' q( n6 E5 M% c
                pRealArray1=(luRealArray *)SearchKey((char *)&(xx->x),sizeof(luVOID),luDynData_realarray);2 M- u' e5 `3 U# Q+ d6 h! j; q) u

pRealArray2=(luRealArray *)SearchKey((char *)&((xx+1)->x),sizeof(luVOID),luDynData_realarray); 
4 M0 _4 P2 z1 e+ E7 a% u
                if(!pRealArray1 || !pRealArray2) break;        //对象句柄无效，不是实数数组7 S. d7 G( ~+ T9 x1 }

if(pRealArray1->DimLen!=2 || pRealArray2->DimLen!=2) break;        //不是二维实数数组（矩阵）( ~7 H: \% ]2 z\\" @2 Y

if(pRealArray1->Dim[1]!=pRealArray2->Dim[0]) break;        //维数不匹配- @6 ]9 ^7 f0 _9 T3 T# g4 s' F/ ~. z* x$ P+ o

pRealArray3=(luRealArray *)NewSysObj(luDynData_realarray,pRealArray1->Dim[0]*pRealArray2->Dim[1],2);        //创建矩阵对象 
  ]( O. P) [# h; i. u  O3 h  K
                if(!pRealArray3) break; 
) h. t: ]8 J\\" X/ {( j
                pRealArray3->Dim[0]=pRealArray1->Dim[0]; pRealArray3->Dim[1]=pRealArray2->Dim[1];        //设置矩阵维数大小6 G, q7 o/ M# Q$ ]8 c

pa=pRealArray1->Array; pb=pRealArray2->Array; pc=pRealArray3->Array; 
3 G+ T\\" s( r  c0 P0 K: L; Z- b; \
                m=pRealArray1->Dim[0]; n=pRealArray1->Dim[1]; k=pRealArray2->Dim[1];# v& K& N1 S* p8 s

for(i=0; i<m; i++)        //矩阵乘, @1 L\\" u3 E  C9 y' B+ Z

{6 t2 q! I3 O/ S. N  Z/ [9 z/ g

for(j=0; j<k; j++)7 K2 R3 T  I0 q% Z* Q

{ 
: _7 D# i7 R- j  F
                                u=i*k+j; pc[u]=0.0;! {, P6 V5 Q3 s1 T

for (v=0; v<n; v++)- D6 |0 i, B3 W$ u

{ 
7 o0 C+ ]- k/ w; n
                                        pc[u]=pc[u]+pa[i*n+v]*pb[v*k+j]; 
\\" H5 f8 E. K7 A. B3 w: K
                                }9 A9 y  Y/ B9 Q; Y

} 
! y; ]7 r7 z) @7 i/ G9 }/ Q7 v, k
                } 
$ v/ Q; @: o+ M
                FunReObj(hFor);        //告诉Lu，返回一个动态对象 
\\" w* a- N  n0 ^\\" B) v
                a.BType=luDynData_realarray; a.VType=Matrix; a.x=0; *(luVOID *)&(a.x)=(luVOID)pRealArray3; 
& r) m1 ?. a* B' T* Q3 h
                break;\\" W5 q0 @* ]8 M& Z% F2 Q( J! [' i

case 25:        //重载运算符.*$ O/ _; [5 h% ]4 c6 v; [' p

pRealArray1=(luRealArray *)SearchKey((char *)&(xx->x),sizeof(luVOID),luDynData_realarray);( Q\\" |# N$ C, Q' i; y

pRealArray2=(luRealArray *)SearchKey((char *)&((xx+1)->x),sizeof(luVOID),luDynData_realarray); 
\\" J8 N3 T8 W& k6 v5 S6 z
                if(!pRealArray1 || !pRealArray2) break;        //对象句柄无效，不是实数数组 
9 ^0 z  Z/ j- T1 o4 D- Q
                if(pRealArray1->DimLen!=2 || pRealArray2->DimLen!=2) break;        //不是二维实数数组（矩阵） 
\\" a2 ~! y7 h5 s3 s# C
                if(pRealArray1->Dim[0]!=pRealArray2->Dim[0] || pRealArray1->Dim[1]!=pRealArray2->Dim[1]) break;        //维数不相同 
/ l/ _4 f6 O9 P& w* M( e
                pRealArray3=(luRealArray *)NewSysObj(luDynData_realarray,pRealArray1->ArrayLen,2);        //创建矩阵对象 
+ j# \0 E. G2 M6 ~! D9 w
                if(!pRealArray3) break; 
7 [+ c, @7 x( Z- d! F  z
                pRealArray3->Dim[0]=pRealArray1->Dim[0]; pRealArray3->Dim[1]=pRealArray1->Dim[1];        //设置矩阵维数大小2 y/ y6 k4 G8 t, V: x; K# Z( `5 z

for(i=0;i<pRealArray1->ArrayLen;i++) pRealArray3->Array[i]=pRealArray1->Array[i]*pRealArray2->Array[i];//矩阵点乘# S$ A. w# H; ?' C& E

FunReObj(hFor);        //告诉Lu，返回一个动态对象\\" G. Z4 L6 }  U  X0 t

a.BType=luDynData_realarray; a.VType=Matrix; a.x=0; *(luVOID *)&(a.x)=(luVOID)pRealArray3;7 Q1 m6 p. g; O' Q

break; 
6 j) l8 a6 B5 X0 ^4 o$ N
        case 46:        //重载函数new( l( I# x9 Q$ p& \& ^

a=ExeOperator(mm,xx,hFor,theOperator,luDynData_realarray);        //直接调用基本类型luDynData_realarray的new函数 
3 P' r4 Q' Z( b$ C
                if(a.VType==luDynData_realarray) a.VType=Matrix;        //设置扩展类型为自定义的Matrix类型% J' E# n% }2 U1 M+ c\\" N

break;! F\\" ^+ z+ P2 o3 [' n# Y

case 49:        //重载函数o 
1 H8 _- E8 G( a) j
                pMessage=(luMessage)SearchKey("\0\0\0\0",sizeof(luVOID),luPubKey_User);7 P2 N; v7 u$ i, r

if(!pMessage) break; 
7 ~; k: L! d0 c4 n
                pRealArray1=(luRealArray *)SearchKey((char *)&(xx->x),sizeof(luVOID),luDynData_realarray);) G. `3 z' A$ g- i9 _

if(!pRealArray1) break;        //对象句柄无效，不是实数数组 
0 b) z  ~  E6 s4 ], [. [
                if(pRealArray1->DimLen!=2) break;        //不是二维实数数组（矩阵）7 \( k; @; ~, S& M' g$ I

pa=pRealArray1->Array; 
6 R, A2 E) q: S: ^4 g# d5 ?& Z
                m=pRealArray1->Dim[0]; n=pRealArray1->Dim[1]; k=0; 
9 v& a* C% K; @4 ?  q
                for(i=0; i<m; i++)        //输出矩阵0 o: ^7 i0 p7 X7 m# s\\" j9 c1 F# `

{5 x- A4 k+ E& R

pMessage(L"\r\n"); k+=2; 
: g- v! G\\" z; I  r4 x- J2 b
                        for(j=0; j<n; j++)2 @4 X6 H\\" y) Y4 S. v- o

{ 
) p& I1 X7 v+ ~
                                _gcvt_s(chNum,pa[i*n+j],16); 
0 P$ z9 v( M* C
                                for(u=0;chNum[u];u++) {wchNum[u]=chNum[u]; k++;}/ a7 u( h' Y4 l- Q( G5 I

wchNum[u]='\0';3 D5 a0 `\\" O( d& W1 K  ~

pMessage(wchNum); pMessage(L"  "); k+=2; 
% k4 X( U7 R$ o% D
                        }- p/ [: @: ^* v

} 
\\" @* }+ p+ O+ b8 T: ]9 b
                pMessage(L"\r\n"); k+=2;4 `8 E3 L) i  O6 [\\" {+ D9 Q

a.BType=luStaData_int64; a.VType=luStaData_int64; a.x=k;        //按函数o的要求，返回输出的字符总数 
; B$ h: U\\" X/ K! k' s& M8 c
                break;3 W6 O% A2 B! d; d# G0 h+ E

default: 
0 T' P/ j! M4 j# X
                break;  Z6 _) S2 q: c. u5 Q& @* k- e

}5 ?3 u( P2 u2 w* Q: J

return a; 
) o+ M) a\\" u( g6 z5 c. t: _: q
}9 R0 ^3 k2 J9 H, c6 }

void main(void) 
! F9 j' {- {0 `) m; x5 g: [' m
{2 [; `/ p  j+ m+ _6 l! P

void *hFor;                //表达式句柄% C' S* S) _5 p

luINT nPara;                //存放表达式的自变量个数$ P5 L' }: z7 E/ ]/ k# X

LuData *pPara;                //存放输入自变量的数组指针) \+ N& W: @4 u! Q- |

luINT ErrBegin,ErrEnd;        //表达式编译出错的初始位置和结束位置/ b6 y- \1 |$ J

int ErrCode;                //错误代码 
, Z\\" P9 `. ~* b% Z6 n. ?! |
        void *v;8 L! \, n& ?7 N4 a# J

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$ W/ B& L  a: S

//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.]}";//字符串表达式，矩阵点乘 
  O% c9 t; |' ]4 _; z! T+ J7 f
        LuData Val; 
, [6 L8 ?1 D6 M' Q
        if(!InitLu()) return;        //初始化Lu5 f: U- p0 G! X

while(LockKey(Matrix,DelMatrix,OpMatrix)){Matrix++;}        //锁定一个键，用于存储矩阵扩展类型/ Y; I$ D1 h  P9 V

4 G\\" E0 x: r* K
        Val.BType=luStaData_int64; Val.VType=luStaData_int64; Val.x=Matrix;        //定义整数常量: E; K8 P) o\\" ?% Y$ T* ~) f. N\\" q* P

SetConst(L"matrix",&Val);        //设置整数常量* f. H' l/ j9 O: F. H' g

InsertKey("\0\0\0\0",4,luPubKey_User,LuMessage,NULL,NULL,1,v); //使Lu运行时可输出函数信息 
3 z  d& j* v( q# q8 C
        wcout.imbue(locale("chs"));        //设置输出的locale为中文 
# L, r0 {% W: {0 Z# r- `! a
   
' Y8 f& _\\" D' `7 j! D. j\\" i
        ErrCode=LuCom(ForStr,0,0,0,hFor,nPara,pPara,ErrBegin,ErrEnd); //编译表达式 
; g( S; ~$ V5 a2 _; M
        if(ErrCode)- a/ x& k% z0 a7 Q# j( k

{ 
7 j7 {\\" w# @& c
                wcout<<L"表达式有错误！错误代码："<<ErrCode<<endl;% u' K/ ~0 P) G2 R6 G, J

}& e+ o- J9 ]6 q

else  X# f6 D/ i( u3 }, T\\" n

{# t1 @5 k\\" ^& _1 n- |; _' [. B; E# A

LuCal(hFor,pPara);        //计算表达式的值6 A  j8 \- @& F- I4 ]

} 
+ t. n; P) c; b' u4 ^8 p4 s! l
        LockKey(Matrix,NULL,OpMatrix);//解锁键Matrix，本例中，该函数可以不用 
1 W2 _1 Z6 Y* u
        FreeLu();                        //释放Lu 
\\" A( u0 Q2 U! X0 }
}

习题：

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

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

main(:a,b,c,d,t,i)=
% z/ R1 t! r: w2 f
a=new[matrix,2,2,data:1.,2.,2.,1.],
: B/ s p' D1 r# j+ l6 S8 Y
b=new[matrix,2,2,data:2.,1.,1.,2.],, m( @5 e8 t, E* H3 }
c=new[matrix,2,2,data:2/3.,-1/3.,-1/3.,2/3.],+ |5 p/ p1 k0 {% \9 o# Y8 ^
t=clock(),6 K/ I6 T* i; f5 u& u8 _+ `/ R
d=a*b, i=0, while{i<1000000, d=d*c*b, i++},
' P* ]- v' ?+ \: l0 B/ J
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\"}";//字符串表达式

复制代码

结果：