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

查看: 8905|回复: 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>. |8 N5 M+ H% f! N+ T) a
#include <iostream>
6 }) z4 I: d. J7 [\\" T
#include <math.h>
0 f+ P2 l7 a: \- F2 I
#include "lu32.h"8 F! I: e9 P+ u) Z# Q B2 z
2 ?1 Q* P6 S/ m b6 Y7 H
#pragma comment( lib, "lu32.lib" )
$ H4 O\\" b# N! s7 T- S\\" m9 e: a
5 h. c, N0 _* @' W& V# T) B
using namespace std;6 ^+ h( s) o7 C; j& a
' y M7 f. O2 x- W\\" D
luKEY Matrix=-1000; //标识矩阵类型，最终的Matrix由LockKey决定; G% G$ V/ g/ j* J: ?0 l
& m2 B, m\\" o\\" f& Z, b9 ]9 f' X0 J
void _stdcall LuMessage(wchar_t *pch)//输出动态库信息，该函数注册到Lu，由Lu二级函数调用
% n+ }: {6 b6 e& p* c
{+ Q. v) [' x/ ^, s# y\\" }
wcout<<pch;# f/ [! E: H/ o$ u
}2 U7 W7 {9 ]8 O2 }
void _stdcall DelMatrix(void *me) //用于LockKey函数，因为是基于系统内置实数数组创建矩阵，故该函数什么也不做
, h+ y4 o$ O6 W, E' z9 u
{
5 u! L8 \* p6 ^# i
}
4 [% P& e/ a\\" F! O7 P
LuData _stdcall OpMatrix(luINT mm,LuData *xx,void *hFor,int theOperator) //运算符重载函数，用于LockKey函数2 X3 ]0 X% t$ P; K
{3 k+ C6 p\\" S8 r& i4 }
LuData a;# {- F+ D1 a5 \, R8 [8 H5 g3 t8 {
luRealArray *pRealArray1,*pRealArray2,*pRealArray3;
+ U; V! p& {. ]! X% g
luVOID i,j,k,m,n,u,v;
5 M# ~* r6 b( s/ Q) _
double *pa,*pb,*pc;5 o. _& w$ B$ q\\" p) u3 Z) Y/ ~
luMessage pMessage;
2 O# m: `4 i0 ^
wchar_t wchNum[32];
+ @7 Y( L1 j h# `6 J
char chNum[32];6 N( \, P0 i; B' T
a.BType=luStaData_nil; a.VType=luStaData_nil; a.x=0;8 v5 `9 D+ W3 y, H\\" y2 A- W
switch(theOperator)7 N: V. X3 _- o/ j) s
{
3 _& C+ r) y* j: w\\" @
case 2: //重载运算符*% A% w3 X3 e1 p' Z6 _
pRealArray1=(luRealArray *)SearchKey((char *)&(xx->x),sizeof(luVOID),luDynData_realarray);\\" F* {' ?( V3 z n
pRealArray2=(luRealArray *)SearchKey((char *)&((xx+1)->x),sizeof(luVOID),luDynData_realarray);
2 {. }# H8 N8 B8 P/ t7 J, z& A D
if(!pRealArray1 || !pRealArray2) break; //对象句柄无效，不是实数数组9 f. c' `\\" D) B\\" v
if(pRealArray1->DimLen!=2 || pRealArray2->DimLen!=2) break; //不是二维实数数组（矩阵）
|/ j: `, h0 x
if(pRealArray1->Dim[1]!=pRealArray2->Dim[0]) break; //维数不匹配
; `* ?4 p% L! N
pRealArray3=(luRealArray *)NewSysObj(luDynData_realarray,pRealArray1->Dim[0]*pRealArray2->Dim[1],2); //创建矩阵对象
$ [, c; x! q d& M
if(!pRealArray3) break;# D7 P. ~6 M- Y' p! b5 D
pRealArray3->Dim[0]=pRealArray1->Dim[0]; pRealArray3->Dim[1]=pRealArray2->Dim[1]; //设置矩阵维数大小
h3 @5 w\\" c- X' C& t' a7 H0 p0 n
pa=pRealArray1->Array; pb=pRealArray2->Array; pc=pRealArray3->Array;
( V1 _+ c; T& ^! d, V( h
m=pRealArray1->Dim[0]; n=pRealArray1->Dim[1]; k=pRealArray2->Dim[1];
& R' N, S K( [4 G1 m: O' c9 W' B
for(i=0; i<m; i++) //矩阵乘. x. d& h1 Q8 R- M
{8 e% v( |, e) j- Z2 ?$ Q
for(j=0; j<k; j++)3 M# L6 w1 J' n( I) w1 M- L. u
{
5 ~1 ^1 l2 U, v
u=i*k+j; pc[u]=0.0;
0 h5 E, h( R: W8 |& g5 a: Y7 b
for (v=0; v<n; v++)
/ e& y4 O- R$ w3 q0 H& ]7 S
{
7 x, |+ |' d3 n3 s
pc[u]=pc[u]+pa[i*n+v]*pb[v*k+j];
$ g6 Q* y\\" B! U- z
}
9 ?! g2 V\\" e& C
}
0 @, {& |$ K/ k: G z8 M
}1 Y( R/ I; R- A% D+ p5 z! y4 N
FunReObj(hFor); //告诉Lu，返回一个动态对象
z' `/ \2 V9 c6 P8 z/ @( i- S
a.BType=luDynData_realarray; a.VType=Matrix; a.x=0; *(luVOID *)&(a.x)=(luVOID)pRealArray3;9 V\\" V- r\\" B7 k7 \8 u. P
break;* C R0 m! C2 I
case 25: //重载运算符.*: t5 n+ p3 t2 [) e
pRealArray1=(luRealArray *)SearchKey((char *)&(xx->x),sizeof(luVOID),luDynData_realarray);
; D9 l* v1 O% \* i8 l
pRealArray2=(luRealArray *)SearchKey((char *)&((xx+1)->x),sizeof(luVOID),luDynData_realarray);
, J& x6 a5 B5 Q/ e j
if(!pRealArray1 || !pRealArray2) break; //对象句柄无效，不是实数数组* f7 B1 [\\" Y' D! d8 p% o( j
if(pRealArray1->DimLen!=2 || pRealArray2->DimLen!=2) break; //不是二维实数数组（矩阵）
, `# f* ~\\" p* a' @: s
if(pRealArray1->Dim[0]!=pRealArray2->Dim[0] || pRealArray1->Dim[1]!=pRealArray2->Dim[1]) break; //维数不相同
2 V: Q8 U1 T6 Q/ M6 g& F* k
pRealArray3=(luRealArray *)NewSysObj(luDynData_realarray,pRealArray1->ArrayLen,2); //创建矩阵对象( {4 i7 h! e' ?; t$ w' b. r
if(!pRealArray3) break;0 p4 E& Z, c, W: a( b; r7 C+ k
pRealArray3->Dim[0]=pRealArray1->Dim[0]; pRealArray3->Dim[1]=pRealArray1->Dim[1]; //设置矩阵维数大小% p3 C- o& n) b N
for(i=0;i<pRealArray1->ArrayLen;i++) pRealArray3->Array[i]=pRealArray1->Array[i]*pRealArray2->Array[i];//矩阵点乘3 ^2 \& A/ w$ C! d& w0 @
FunReObj(hFor); //告诉Lu，返回一个动态对象; K( ?4 x( Z0 a
a.BType=luDynData_realarray; a.VType=Matrix; a.x=0; *(luVOID *)&(a.x)=(luVOID)pRealArray3;, j, f7 }# n9 A
break;
9 O0 S1 n, \) i. N, c) F
case 46: //重载函数new\\" P\\" k0 ` Z5 r! F: O$ n% L
a=ExeOperator(mm,xx,hFor,theOperator,luDynData_realarray); //直接调用基本类型luDynData_realarray的new函数- x\\" q/ Q2 B- D. N
if(a.VType==luDynData_realarray) a.VType=Matrix; //设置扩展类型为自定义的Matrix类型1 F8 B0 m, p0 F
break;
a9 u) c, k/ u3 D: E+ c k
case 49: //重载函数o
0 z) S E3 L7 {5 r# Y
pMessage=(luMessage)SearchKey("\0\0\0\0",sizeof(luVOID),luPubKey_User);
9 P0 U. m: k9 Z' U
if(!pMessage) break;& A' S4 c- d* o/ J; E! Q
pRealArray1=(luRealArray *)SearchKey((char *)&(xx->x),sizeof(luVOID),luDynData_realarray);
4 H1 k* N- w+ e& t7 c
if(!pRealArray1) break; //对象句柄无效，不是实数数组) P5 b& e: s3 q, V
if(pRealArray1->DimLen!=2) break; //不是二维实数数组（矩阵）
; ~7 {2 C% s3 w$ U1 r+ n\\" E: Q
pa=pRealArray1->Array;! Q0 `4 ^\\" I- g+ Z
m=pRealArray1->Dim[0]; n=pRealArray1->Dim[1]; k=0;; K: U$ B2 Y2 |
for(i=0; i<m; i++) //输出矩阵
6 \0 A* \: u- d5 B
{
\\" ]: Q\\" A w' z6 u# Z
pMessage(L"\r\n"); k+=2;, j( L) _1 a } X4 z% C\\" E, x+ I
for(j=0; j<n; j++)
5 `8 ^/ i* T0 F6 P8 I, s3 v( r
{- `) {) H7 _* H1 W& Z( O+ V9 b
_gcvt_s(chNum,pa[i*n+j],16);
, ?. @7 j+ H: ~1 |' I
for(u=0;chNum[u];u++) {wchNum[u]=chNum[u]; k++;}0 }1 {+ W4 E+ ?8 o2 h! H
wchNum[u]='\0';) K7 P( P; e! I, m! ?
pMessage(wchNum); pMessage(L" "); k+=2;
' l X& m\\" W7 A; I# K. O) @
}
% Q3 m+ Z+ @; U% S3 p) b
}
2 C/ ?0 P; I7 h) _5 o0 ?. T
pMessage(L"\r\n"); k+=2;5 |* c8 Q+ f5 d3 F# c
a.BType=luStaData_int64; a.VType=luStaData_int64; a.x=k; //按函数o的要求，返回输出的字符总数
# W4 B* a# |\\" R# I9 @
break;
- t: k; u* z0 f+ D% m/ D) X
default:5 p; W8 E& r$ I1 F3 V
break;1 u% f8 N( j, {% ]$ `5 M/ Q
}
2 [) M3 P2 W0 c( R+ P
return a;) o8 }9 d. j/ ?7 p& R7 |( r2 s
}
/ @2 w- D) I, x o9 j4 m, {
void main(void)+ |8 Z5 z0 s# f M0 |' g6 D* V
{
7 z. c. X$ K& o: _# t% F
void *hFor; //表达式句柄 r0 U1 {3 E/ {% F _) v
luINT nPara; //存放表达式的自变量个数# k# s\\" [4 W8 Q, M' H Y2 o; c0 O
LuData *pPara; //存放输入自变量的数组指针
1 w, y& J/ @5 o7 ]# g; I
luINT ErrBegin,ErrEnd; //表达式编译出错的初始位置和结束位置
' T% `) R) A/ [; f& i4 ^4 X
int ErrCode; //错误代码
. g$ @1 `: F }+ n. @) c& R6 F
void *v;
1 }6 p9 D6 G3 C
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.]}";//字符串表达式，矩阵乘
v r1 p1 m& h! M2 ~7 n
//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.]}";//字符串表达式，矩阵点乘. u; n k/ i9 Z6 U a! j% i4 U
LuData Val;
1 ^% R# _% t) w' [- T8 W6 q: v
if(!InitLu()) return; //初始化Lu& C A L' M- t2 F1 M5 }
while(LockKey(Matrix,DelMatrix,OpMatrix)){Matrix++;} //锁定一个键，用于存储矩阵扩展类型9 o; Q# S& ^& l+ e# u6 }
) E) I. n: ?' b
Val.BType=luStaData_int64; Val.VType=luStaData_int64; Val.x=Matrix; //定义整数常量
% k! s, c, e, k( ?
SetConst(L"matrix",&Val); //设置整数常量
- g8 A. |* Y- E2 X, j! O, O* f
InsertKey("\0\0\0\0",4,luPubKey_User,LuMessage,NULL,NULL,1,v); //使Lu运行时可输出函数信息
% n6 P\\" q7 j, v
wcout.imbue(locale("chs")); //设置输出的locale为中文' A/ _! }, U; c0 _- I\\" | t
& O5 B' U! }5 H9 T9 {7 Z7 o
ErrCode=LuCom(ForStr,0,0,0,hFor,nPara,pPara,ErrBegin,ErrEnd); //编译表达式5 [4 e& h3 G' w; Z, A8 K5 ~
if(ErrCode): v' n5 i+ e# b0 {! e5 y, m0 d
{3 J) Z8 ~$ W5 `: x
wcout<<L"表达式有错误！错误代码："<<ErrCode<<endl;
; x6 X0 Z1 k$ S& H% g
}& q8 l$ k+ A6 y! U4 u. H3 u7 b
else; P' }; v; L$ U* x; U
{ Z* P) n9 X+ f/ D$ o
LuCal(hFor,pPara); //计算表达式的值1 t' S3 M1 Y$ a
}( _' q6 I6 t% a3 M
LockKey(Matrix,NULL,OpMatrix);//解锁键Matrix，本例中，该函数可以不用
/ S- E$ z+ X! d/ t; C3 b
FreeLu(); //释放Lu$ C W: O5 }& X4 i% \
}

#include <windows.h>. |8 N5 M+ H% f! N+ T) a

#include <iostream> 
6 }) z4 I: d. J7 [\\" T
#include <math.h> 
0 f+ P2 l7 a: \- F2 I
#include "lu32.h"8 F! I: e9 P+ u) Z# Q  B2 z

2 ?1 Q* P6 S/ m  b6 Y7 H
#pragma comment( lib, "lu32.lib" ) 
$ H4 O\\" b# N! s7 T- S\\" m9 e: a
 
5 h. c, N0 _* @' W& V# T) B
using namespace std;6 ^+ h( s) o7 C; j& a

' y  M7 f. O2 x- W\\" D
luKEY Matrix=-1000;        //标识矩阵类型，最终的Matrix由LockKey决定; G% G$ V/ g/ j* J: ?0 l

& m2 B, m\\" o\\" f& Z, b9 ]9 f' X0 J

void _stdcall LuMessage(wchar_t *pch)//输出动态库信息，该函数注册到Lu，由Lu二级函数调用 
% n+ }: {6 b6 e& p* c
{+ Q. v) [' x/ ^, s# y\\" }

wcout<<pch;# f/ [! E: H/ o$ u

}2 U7 W7 {9 ]8 O2 }

void _stdcall DelMatrix(void *me)        //用于LockKey函数，因为是基于系统内置实数数组创建矩阵，故该函数什么也不做 
, h+ y4 o$ O6 W, E' z9 u
{ 
5 u! L8 \* p6 ^# i
} 
4 [% P& e/ a\\" F! O7 P
LuData _stdcall OpMatrix(luINT mm,LuData *xx,void *hFor,int theOperator)        //运算符重载函数，用于LockKey函数2 X3 ]0 X% t$ P; K

{3 k+ C6 p\\" S8 r& i4 }

LuData a;# {- F+ D1 a5 \, R8 [8 H5 g3 t8 {

luRealArray *pRealArray1,*pRealArray2,*pRealArray3; 
+ U; V! p& {. ]! X% g
        luVOID i,j,k,m,n,u,v; 
5 M# ~* r6 b( s/ Q) _
        double *pa,*pb,*pc;5 o. _& w$ B$ q\\" p) u3 Z) Y/ ~

luMessage pMessage; 
2 O# m: `4 i0 ^
        wchar_t wchNum[32]; 
+ @7 Y( L1 j  h# `6 J
        char chNum[32];6 N( \, P0 i; B' T

a.BType=luStaData_nil; a.VType=luStaData_nil; a.x=0;8 v5 `9 D+ W3 y, H\\" y2 A- W

switch(theOperator)7 N: V. X3 _- o/ j) s

{ 
3 _& C+ r) y* j: w\\" @
        case 2:        //重载运算符*% A% w3 X3 e1 p' Z6 _

pRealArray1=(luRealArray *)SearchKey((char *)&(xx->x),sizeof(luVOID),luDynData_realarray);\\" F* {' ?( V3 z  n

pRealArray2=(luRealArray *)SearchKey((char *)&((xx+1)->x),sizeof(luVOID),luDynData_realarray); 
2 {. }# H8 N8 B8 P/ t7 J, z& A  D
                if(!pRealArray1 || !pRealArray2) break;        //对象句柄无效，不是实数数组9 f. c' `\\" D) B\\" v

if(pRealArray1->DimLen!=2 || pRealArray2->DimLen!=2) break;        //不是二维实数数组（矩阵） 
  |/ j: `, h0 x
                if(pRealArray1->Dim[1]!=pRealArray2->Dim[0]) break;        //维数不匹配 
; `* ?4 p% L! N
                pRealArray3=(luRealArray *)NewSysObj(luDynData_realarray,pRealArray1->Dim[0]*pRealArray2->Dim[1],2);        //创建矩阵对象 
$ [, c; x! q  d& M
                if(!pRealArray3) break;# D7 P. ~6 M- Y' p! b5 D

pRealArray3->Dim[0]=pRealArray1->Dim[0]; pRealArray3->Dim[1]=pRealArray2->Dim[1];        //设置矩阵维数大小 
  h3 @5 w\\" c- X' C& t' a7 H0 p0 n
                pa=pRealArray1->Array; pb=pRealArray2->Array; pc=pRealArray3->Array; 
( V1 _+ c; T& ^! d, V( h
                m=pRealArray1->Dim[0]; n=pRealArray1->Dim[1]; k=pRealArray2->Dim[1]; 
& R' N, S  K( [4 G1 m: O' c9 W' B
                for(i=0; i<m; i++)        //矩阵乘. x. d& h1 Q8 R- M

{8 e% v( |, e) j- Z2 ?$ Q

for(j=0; j<k; j++)3 M# L6 w1 J' n( I) w1 M- L. u

{ 
5 ~1 ^1 l2 U, v
                                u=i*k+j; pc[u]=0.0; 
0 h5 E, h( R: W8 |& g5 a: Y7 b
                                for (v=0; v<n; v++) 
/ e& y4 O- R$ w3 q0 H& ]7 S
                                { 
7 x, |+ |' d3 n3 s
                                        pc[u]=pc[u]+pa[i*n+v]*pb[v*k+j]; 
$ g6 Q* y\\" B! U- z
                                } 
9 ?! g2 V\\" e& C
                        } 
0 @, {& |$ K/ k: G  z8 M
                }1 Y( R/ I; R- A% D+ p5 z! y4 N

FunReObj(hFor);        //告诉Lu，返回一个动态对象 
  z' `/ \2 V9 c6 P8 z/ @( i- S
                a.BType=luDynData_realarray; a.VType=Matrix; a.x=0; *(luVOID *)&(a.x)=(luVOID)pRealArray3;9 V\\" V- r\\" B7 k7 \8 u. P

break;* C  R0 m! C2 I

case 25:        //重载运算符.*: t5 n+ p3 t2 [) e

pRealArray1=(luRealArray *)SearchKey((char *)&(xx->x),sizeof(luVOID),luDynData_realarray); 
; D9 l* v1 O% \* i8 l
                pRealArray2=(luRealArray *)SearchKey((char *)&((xx+1)->x),sizeof(luVOID),luDynData_realarray); 
, J& x6 a5 B5 Q/ e  j
                if(!pRealArray1 || !pRealArray2) break;        //对象句柄无效，不是实数数组* f7 B1 [\\" Y' D! d8 p% o( j

if(pRealArray1->DimLen!=2 || pRealArray2->DimLen!=2) break;        //不是二维实数数组（矩阵） 
, `# f* ~\\" p* a' @: s
                if(pRealArray1->Dim[0]!=pRealArray2->Dim[0] || pRealArray1->Dim[1]!=pRealArray2->Dim[1]) break;        //维数不相同 
2 V: Q8 U1 T6 Q/ M6 g& F* k
                pRealArray3=(luRealArray *)NewSysObj(luDynData_realarray,pRealArray1->ArrayLen,2);        //创建矩阵对象( {4 i7 h! e' ?; t$ w' b. r

if(!pRealArray3) break;0 p4 E& Z, c, W: a( b; r7 C+ k

pRealArray3->Dim[0]=pRealArray1->Dim[0]; pRealArray3->Dim[1]=pRealArray1->Dim[1];        //设置矩阵维数大小% p3 C- o& n) b  N

for(i=0;i<pRealArray1->ArrayLen;i++) pRealArray3->Array[i]=pRealArray1->Array[i]*pRealArray2->Array[i];//矩阵点乘3 ^2 \& A/ w$ C! d& w0 @

FunReObj(hFor);        //告诉Lu，返回一个动态对象; K( ?4 x( Z0 a

a.BType=luDynData_realarray; a.VType=Matrix; a.x=0; *(luVOID *)&(a.x)=(luVOID)pRealArray3;, j, f7 }# n9 A

break; 
9 O0 S1 n, \) i. N, c) F
        case 46:        //重载函数new\\" P\\" k0 `  Z5 r! F: O$ n% L

a=ExeOperator(mm,xx,hFor,theOperator,luDynData_realarray);        //直接调用基本类型luDynData_realarray的new函数- x\\" q/ Q2 B- D. N

if(a.VType==luDynData_realarray) a.VType=Matrix;        //设置扩展类型为自定义的Matrix类型1 F8 B0 m, p0 F

break; 
  a9 u) c, k/ u3 D: E+ c  k
        case 49:        //重载函数o 
0 z) S  E3 L7 {5 r# Y
                pMessage=(luMessage)SearchKey("\0\0\0\0",sizeof(luVOID),luPubKey_User); 
9 P0 U. m: k9 Z' U
                if(!pMessage) break;& A' S4 c- d* o/ J; E! Q

pRealArray1=(luRealArray *)SearchKey((char *)&(xx->x),sizeof(luVOID),luDynData_realarray); 
4 H1 k* N- w+ e& t7 c
                if(!pRealArray1) break;        //对象句柄无效，不是实数数组) P5 b& e: s3 q, V

if(pRealArray1->DimLen!=2) break;        //不是二维实数数组（矩阵） 
; ~7 {2 C% s3 w$ U1 r+ n\\" E: Q
                pa=pRealArray1->Array;! Q0 `4 ^\\" I- g+ Z

m=pRealArray1->Dim[0]; n=pRealArray1->Dim[1]; k=0;; K: U$ B2 Y2 |

for(i=0; i<m; i++)        //输出矩阵 
6 \0 A* \: u- d5 B
                { 
\\" ]: Q\\" A  w' z6 u# Z
                        pMessage(L"\r\n"); k+=2;, j( L) _1 a  }  X4 z% C\\" E, x+ I

for(j=0; j<n; j++) 
5 `8 ^/ i* T0 F6 P8 I, s3 v( r
                        {- `) {) H7 _* H1 W& Z( O+ V9 b

_gcvt_s(chNum,pa[i*n+j],16); 
, ?. @7 j+ H: ~1 |' I
                                for(u=0;chNum[u];u++) {wchNum[u]=chNum[u]; k++;}0 }1 {+ W4 E+ ?8 o2 h! H

wchNum[u]='\0';) K7 P( P; e! I, m! ?

pMessage(wchNum); pMessage(L"  "); k+=2; 
' l  X& m\\" W7 A; I# K. O) @
                        } 
% Q3 m+ Z+ @; U% S3 p) b
                } 
2 C/ ?0 P; I7 h) _5 o0 ?. T
                pMessage(L"\r\n"); k+=2;5 |* c8 Q+ f5 d3 F# c

a.BType=luStaData_int64; a.VType=luStaData_int64; a.x=k;        //按函数o的要求，返回输出的字符总数 
# W4 B* a# |\\" R# I9 @
                break; 
- t: k; u* z0 f+ D% m/ D) X
        default:5 p; W8 E& r$ I1 F3 V

break;1 u% f8 N( j, {% ]$ `5 M/ Q

} 
2 [) M3 P2 W0 c( R+ P
        return a;) o8 }9 d. j/ ?7 p& R7 |( r2 s

} 
/ @2 w- D) I, x  o9 j4 m, {
void main(void)+ |8 Z5 z0 s# f  M0 |' g6 D* V

{ 
7 z. c. X$ K& o: _# t% F
        void *hFor;                //表达式句柄  r0 U1 {3 E/ {% F  _) v

luINT nPara;                //存放表达式的自变量个数# k# s\\" [4 W8 Q, M' H  Y2 o; c0 O

LuData *pPara;                //存放输入自变量的数组指针 
1 w, y& J/ @5 o7 ]# g; I
        luINT ErrBegin,ErrEnd;        //表达式编译出错的初始位置和结束位置 
' T% `) R) A/ [; f& i4 ^4 X
        int ErrCode;                //错误代码 
. g$ @1 `: F  }+ n. @) c& R6 F
        void *v; 
1 }6 p9 D6 G3 C
        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.]}";//字符串表达式，矩阵乘 
  v  r1 p1 m& h! M2 ~7 n
        //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.]}";//字符串表达式，矩阵点乘. u; n  k/ i9 Z6 U  a! j% i4 U

LuData Val; 
1 ^% R# _% t) w' [- T8 W6 q: v
        if(!InitLu()) return;        //初始化Lu& C  A  L' M- t2 F1 M5 }

while(LockKey(Matrix,DelMatrix,OpMatrix)){Matrix++;}        //锁定一个键，用于存储矩阵扩展类型9 o; Q# S& ^& l+ e# u6 }

) E) I. n: ?' b
        Val.BType=luStaData_int64; Val.VType=luStaData_int64; Val.x=Matrix;        //定义整数常量 
% k! s, c, e, k( ?
        SetConst(L"matrix",&Val);        //设置整数常量 
- g8 A. |* Y- E2 X, j! O, O* f
        InsertKey("\0\0\0\0",4,luPubKey_User,LuMessage,NULL,NULL,1,v); //使Lu运行时可输出函数信息 
% n6 P\\" q7 j, v
        wcout.imbue(locale("chs"));        //设置输出的locale为中文' A/ _! }, U; c0 _- I\\" |  t

& O5 B' U! }5 H9 T9 {7 Z7 o
        ErrCode=LuCom(ForStr,0,0,0,hFor,nPara,pPara,ErrBegin,ErrEnd); //编译表达式5 [4 e& h3 G' w; Z, A8 K5 ~

if(ErrCode): v' n5 i+ e# b0 {! e5 y, m0 d

{3 J) Z8 ~$ W5 `: x

wcout<<L"表达式有错误！错误代码："<<ErrCode<<endl; 
; x6 X0 Z1 k$ S& H% g
        }& q8 l$ k+ A6 y! U4 u. H3 u7 b

else; P' }; v; L$ U* x; U

{  Z* P) n9 X+ f/ D$ o

LuCal(hFor,pPara);        //计算表达式的值1 t' S3 M1 Y$ a

}( _' q6 I6 t% a3 M

LockKey(Matrix,NULL,OpMatrix);//解锁键Matrix，本例中，该函数可以不用 
/ S- E$ z+ X! d/ t; C3 b
        FreeLu();                        //释放Lu$ C  W: O5 }& X4 i% \

}

习题：

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

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

main(:a,b,c,d,t,i)=
\" {0 W- k# ]* c
a=new[matrix,2,2,data:1.,2.,2.,1.],3 l. T- e' g$ l) o/ F' Z' j
b=new[matrix,2,2,data:2.,1.,1.,2.],8 _1 c5 D; Q. L4 g
c=new[matrix,2,2,data:2/3.,-1/3.,-1/3.,2/3.],: u; a% A; C; J' o5 Z( M# S4 A
t=clock(),0 @; ~6 |/ s$ w# G
d=a*b, i=0, while{i<1000000, d=d*c*b, i++},
1 W1 B$ B4 {- \, X' Q& h
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\"}";//字符串表达式

复制代码

结果：