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

查看: 8511|回复: 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>/ Y# u* F1 b1 B3 Z9 {
#include <iostream>
4 E ^- f, I! X' B A, D3 ~
#include <math.h>' m- I1 G2 j9 r
#include "lu32.h"
K- @2 o. A/ J
' C& J9 A9 p& C' {- G: S
#pragma comment( lib, "lu32.lib" )9 z# L3 s- F$ Z. T\\" [( u; G [\\" [9 F
- `% n7 y; }; i/ E
using namespace std;- n; |( T- D/ _8 `3 W ?4 s# S
* ]( x/ ~) [+ E+ M9 K0 O$ Y
luKEY Matrix=-1000; //标识矩阵类型，最终的Matrix由LockKey决定: x7 J) d0 C, y2 Q: h4 X& i
: L# g6 b! j F4 z u
void _stdcall LuMessage(wchar_t *pch)//输出动态库信息，该函数注册到Lu，由Lu二级函数调用 : p x7 m4 Z# B# S1 C
{5 J) Z' B1 t: b
wcout<<pch;& Z B' M3 b# [! Y7 T; N$ C! `: Q
}
' p- L; ?4 \6 j8 H* _2 s* k4 j
void _stdcall DelMatrix(void *me) //用于LockKey函数，因为是基于系统内置实数数组创建矩阵，故该函数什么也不做
* e# u1 ?\\" O6 n& N
{
) a6 g# N- O [. q5 R& f% q1 S; h
}. b0 ~4 B: ^# A5 J- e7 Q
LuData _stdcall OpMatrix(luINT mm,LuData *xx,void *hFor,int theOperator) //运算符重载函数，用于LockKey函数+ p& o! K( C/ d( U4 q& e
{
) D; d2 }: Z9 w( z3 Z5 D
LuData a;
luRealArray *pRealArray1,*pRealArray2,*pRealArray3;
, _& n, p) W8 p: o
luVOID i,j,k,m,n,u,v;\\" X$ F9 u8 H8 e5 ]
double *pa,*pb,*pc;
7 k; C\\" Q8 o7 ~3 a
luMessage pMessage; [) ?1 W0 O+ E' `. F H5 q
wchar_t wchNum[32];
) t; G9 m; W4 j
char chNum[32];. ?+ C9 _7 I+ E/ A$ d4 R
a.BType=luStaData_nil; a.VType=luStaData_nil; a.x=0;
6 K* _) R3 `: F2 _/ Y
switch(theOperator)
$ q8 m: ?8 I9 ?. a2 N7 ^$ X' M7 w
{$ V0 t6 _, o/ ?: ^
case 2: //重载运算符*
9 Q, d, a\\" n8 m* v! I
pRealArray1=(luRealArray *)SearchKey((char *)&(xx->x),sizeof(luVOID),luDynData_realarray);
\\" p/ U( W( E) U. L) V2 D% J1 K
pRealArray2=(luRealArray *)SearchKey((char *)&((xx+1)->x),sizeof(luVOID),luDynData_realarray);
$ X+ G; f) a- v3 |: q
if(!pRealArray1 || !pRealArray2) break; //对象句柄无效，不是实数数组
) n8 L9 S/ _1 J* Y0 P
if(pRealArray1->DimLen!=2 || pRealArray2->DimLen!=2) break; //不是二维实数数组（矩阵）
! Q, b2 S% L, }# y: z
if(pRealArray1->Dim[1]!=pRealArray2->Dim[0]) break; //维数不匹配
$ a7 {, h: r# b) [* u
pRealArray3=(luRealArray *)NewSysObj(luDynData_realarray,pRealArray1->Dim[0]*pRealArray2->Dim[1],2); //创建矩阵对象
# }1 K G0 t: {' p, ~. E
if(!pRealArray3) break;
3 h# P# X\\" [- R, R
pRealArray3->Dim[0]=pRealArray1->Dim[0]; pRealArray3->Dim[1]=pRealArray2->Dim[1]; //设置矩阵维数大小4 Y5 b, ?) G ]) J
pa=pRealArray1->Array; pb=pRealArray2->Array; pc=pRealArray3->Array;2 G) c: H; H$ K* v3 y
m=pRealArray1->Dim[0]; n=pRealArray1->Dim[1]; k=pRealArray2->Dim[1];$ Y. r N; D4 c; k
for(i=0; i<m; i++) //矩阵乘8 s* u4 u0 d$ ?$ U# C) y( b
{% X# |* }# c4 l
for(j=0; j<k; j++). Y+ Z+ C& ?, s& V1 `
{) D. g2 i8 o, N/ y9 U
u=i*k+j; pc[u]=0.0;3 |' M* ?5 i1 w n7 O, q% r( |
for (v=0; v<n; v++)
! U# F1 _ b8 q' [! [$ h, u' }
{
1 a0 r+ K5 d; c
pc[u]=pc[u]+pa[i*n+v]*pb[v*k+j];, B/ L# l7 {2 i4 Y* G) m
}9 b9 B\\" l% n* F& I6 F9 y
}
) P, D/ J' ~+ Z/ D- E
}
- n% \: h- [; d) O
FunReObj(hFor); //告诉Lu，返回一个动态对象9 a& C* D. R l
a.BType=luDynData_realarray; a.VType=Matrix; a.x=0; *(luVOID *)&(a.x)=(luVOID)pRealArray3;
$ _ k4 K% A8 h/ \! g/ v
break;, Q\\" L! r: c, i1 E# h$ l+ }
case 25: //重载运算符.*! v1 e! a6 T9 H( s; A0 a
pRealArray1=(luRealArray *)SearchKey((char *)&(xx->x),sizeof(luVOID),luDynData_realarray);
: D( h8 M: y# z+ g* N
pRealArray2=(luRealArray *)SearchKey((char *)&((xx+1)->x),sizeof(luVOID),luDynData_realarray);* ~2 T9 z& \/ r: S8 [* b9 H) M2 U
if(!pRealArray1 || !pRealArray2) break; //对象句柄无效，不是实数数组
& D3 Q: n8 c: X, _) i1 N$ d
if(pRealArray1->DimLen!=2 || pRealArray2->DimLen!=2) break; //不是二维实数数组（矩阵）- s9 u: y4 ]+ d6 r9 _* D3 c( C
if(pRealArray1->Dim[0]!=pRealArray2->Dim[0] || pRealArray1->Dim[1]!=pRealArray2->Dim[1]) break; //维数不相同5 W5 y\\" c) k1 g6 g. w
pRealArray3=(luRealArray *)NewSysObj(luDynData_realarray,pRealArray1->ArrayLen,2); //创建矩阵对象 g8 w/ }' W* a1 r# i/ X: I
if(!pRealArray3) break;
3 M2 h1 f( O- I
pRealArray3->Dim[0]=pRealArray1->Dim[0]; pRealArray3->Dim[1]=pRealArray1->Dim[1]; //设置矩阵维数大小
: T2 {7 L' F! R4 k) l6 U
for(i=0;i<pRealArray1->ArrayLen;i++) pRealArray3->Array[i]=pRealArray1->Array[i]*pRealArray2->Array[i];//矩阵点乘1 p; d1 V) P! f: n. [
FunReObj(hFor); //告诉Lu，返回一个动态对象' Q+ z3 G% }# ?1 `
a.BType=luDynData_realarray; a.VType=Matrix; a.x=0; *(luVOID *)&(a.x)=(luVOID)pRealArray3;
[6 f/ T6 I L7 [1 o
break;
\\" n1 L \! C' F' ^- u T
case 46: //重载函数new
6 Y( b$ j, p- d
a=ExeOperator(mm,xx,hFor,theOperator,luDynData_realarray); //直接调用基本类型luDynData_realarray的new函数
% c# U7 x8 }& b& H- K
if(a.VType==luDynData_realarray) a.VType=Matrix; //设置扩展类型为自定义的Matrix类型5 N U\\" O! }! ^, f. P' A6 R
break;
/ ^% a. f. F+ y
case 49: //重载函数o( g! B$ Y8 f0 K# b3 {7 C) a
pMessage=(luMessage)SearchKey("\0\0\0\0",sizeof(luVOID),luPubKey_User);% H! u& q\\" E4 h/ s% ~9 |: W+ @
if(!pMessage) break;
) S' m; I: t& h. K; Q\\" n. E0 a' _
pRealArray1=(luRealArray *)SearchKey((char *)&(xx->x),sizeof(luVOID),luDynData_realarray);
7 [/ I& `5 ]5 i\\" J5 z
if(!pRealArray1) break; //对象句柄无效，不是实数数组
& D7 @\\" S0 x6 l; {2 Y
if(pRealArray1->DimLen!=2) break; //不是二维实数数组（矩阵）( E+ C7 a0 E% X9 N$ P2 f7 K2 Z* Y
pa=pRealArray1->Array;8 l7 g) ]$ W! @& o
m=pRealArray1->Dim[0]; n=pRealArray1->Dim[1]; k=0; C+ Y s; s5 _4 C1 F3 f
for(i=0; i<m; i++) //输出矩阵
9 M3 l' ?: ]& g4 H X\\" f
{
9 E6 n* x' Y* I# N4 v
pMessage(L"\r\n"); k+=2;
) u7 J. G3 ]* N\\" y+ C
for(j=0; j<n; j++)$ P- |\\" Z$ b+ [: J9 V\\" @) T
{
0 @+ n8 n2 p- t3 C1 ~\\" Q. m
_gcvt_s(chNum,pa[i*n+j],16);
* x0 G/ O& h$ A+ ]* g, \# I; @) _
for(u=0;chNum[u];u++) {wchNum[u]=chNum[u]; k++;}* ]2 b1 i @5 F2 Z
wchNum[u]='\0';0 ~( p% r( ~, |+ k2 J5 o
pMessage(wchNum); pMessage(L" "); k+=2;
( h S7 p* z\\" B+ K
}' Y! N8 w5 [1 K
}) p7 M4 r6 X( `/ U0 y
pMessage(L"\r\n"); k+=2;$ H4 |\\" y, U l; c' D' H5 t
a.BType=luStaData_int64; a.VType=luStaData_int64; a.x=k; //按函数o的要求，返回输出的字符总数8 r. x8 f3 v# ?\\" W$ [! V+ u8 V5 i
break;
6 M% \+ j- D8 y
default:
1 m3 `( R' ^0 j2 L& T
break;
\\" W8 y\\" f4 ~- \
}3 R H) p' l4 t+ R/ @) N
return a;, t) l) H# r K; ?
}
% r' J& {4 L# @. H
void main(void)3 o, H+ `5 b3 e$ ?/ s$ ~
{. e1 r+ x2 P5 j
void *hFor; //表达式句柄
' V. k) |2 ]- h0 H/ _
luINT nPara; //存放表达式的自变量个数( w' \; C& \0 ^) e( M
LuData *pPara; //存放输入自变量的数组指针
% K# e- s) R+ o\\" _* }# a( @
luINT ErrBegin,ErrEnd; //表达式编译出错的初始位置和结束位置 y$ i! i: r2 C
int ErrCode; //错误代码
$ J1 N8 @7 m z1 U5 x+ D\\" H7 K
void *v;
3 r, d% d2 I( u! r/ M7 c4 t
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.]}";//字符串表达式，矩阵乘
& i$ ~% w/ `5 K( c+ u1 Q
//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.]}";//字符串表达式，矩阵点乘
5 b3 ~, h8 \5 d2 z1 f
LuData Val;* ~\\" `, o9 y: r! C- ~
if(!InitLu()) return; //初始化Lu
% x9 |# V) H8 ] @
while(LockKey(Matrix,DelMatrix,OpMatrix)){Matrix++;} //锁定一个键，用于存储矩阵扩展类型
z2 E% T: N9 E7 V% A0 s
* U2 ]% H. h: h b. A
Val.BType=luStaData_int64; Val.VType=luStaData_int64; Val.x=Matrix; //定义整数常量& x6 W2 e8 U7 {% F, q
SetConst(L"matrix",&Val); //设置整数常量
. f( ~( d0 Z& \% q5 H
InsertKey("\0\0\0\0",4,luPubKey_User,LuMessage,NULL,NULL,1,v); //使Lu运行时可输出函数信息9 _\\" Z% m2 S. E3 d, X4 Y0 K
wcout.imbue(locale("chs")); //设置输出的locale为中文( o6 C\\" I# l9 K5 R! d6 J
5 ]* i4 t% u( k2 e' z x/ N\\" N
ErrCode=LuCom(ForStr,0,0,0,hFor,nPara,pPara,ErrBegin,ErrEnd); //编译表达式
$ a1 T$ d\\" t5 G+ a/ F2 V\\" {+ s
if(ErrCode)) B) u! R; C% a! M+ m% m
{! p2 t, Z7 s% }& v; Q' @+ q9 q
wcout<<L"表达式有错误！错误代码："<<ErrCode<<endl;
! g3 A' T8 W& k+ b M+ o, J
}
& Q$ u- n* I9 _4 @; c Z @
else
2 B7 T2 N1 k, w% y
{5 L8 Y% |; H8 `) f\\" J+ N' f
LuCal(hFor,pPara); //计算表达式的值
- ]2 | U) F5 f: d+ z
}+ v- O7 s5 X6 [2 i
LockKey(Matrix,NULL,OpMatrix);//解锁键Matrix，本例中，该函数可以不用
7 {* X Z$ Y% {! x+ D
FreeLu(); //释放Lu
. f\\" C: Y! O/ J/ _$ r7 Z
}

#include <windows.h>/ Y# u* F1 b1 B3 Z9 {

#include <iostream> 
4 E  ^- f, I! X' B  A, D3 ~
#include <math.h>' m- I1 G2 j9 r

#include "lu32.h" 
  K- @2 o. A/ J
 
' C& J9 A9 p& C' {- G: S
#pragma comment( lib, "lu32.lib" )9 z# L3 s- F$ Z. T\\" [( u; G  [\\" [9 F

- `% n7 y; }; i/ E
using namespace std;- n; |( T- D/ _8 `3 W  ?4 s# S

* ]( x/ ~) [+ E+ M9 K0 O$ Y
luKEY Matrix=-1000;        //标识矩阵类型，最终的Matrix由LockKey决定: x7 J) d0 C, y2 Q: h4 X& i

: L# g6 b! j  F4 z  u

void _stdcall LuMessage(wchar_t *pch)//输出动态库信息，该函数注册到Lu，由Lu二级函数调用 : p  x7 m4 Z# B# S1 C

{5 J) Z' B1 t: b

wcout<<pch;& Z  B' M3 b# [! Y7 T; N$ C! `: Q

} 
' p- L; ?4 \6 j8 H* _2 s* k4 j
void _stdcall DelMatrix(void *me)        //用于LockKey函数，因为是基于系统内置实数数组创建矩阵，故该函数什么也不做 
* e# u1 ?\\" O6 n& N
{ 
) a6 g# N- O  [. q5 R& f% q1 S; h
}. b0 ~4 B: ^# A5 J- e7 Q

LuData _stdcall OpMatrix(luINT mm,LuData *xx,void *hFor,int theOperator)        //运算符重载函数，用于LockKey函数+ p& o! K( C/ d( U4 q& e

{ 
) D; d2 }: Z9 w( z3 Z5 D
        LuData a; 
' T  y* j# v- h& n# s\\" y* _5 `' t) R
        luRealArray *pRealArray1,*pRealArray2,*pRealArray3; 
, _& n, p) W8 p: o
        luVOID i,j,k,m,n,u,v;\\" X$ F9 u8 H8 e5 ]

double *pa,*pb,*pc; 
7 k; C\\" Q8 o7 ~3 a
        luMessage pMessage;  [) ?1 W0 O+ E' `. F  H5 q

wchar_t wchNum[32]; 
) t; G9 m; W4 j
        char chNum[32];. ?+ C9 _7 I+ E/ A$ d4 R

a.BType=luStaData_nil; a.VType=luStaData_nil; a.x=0; 
6 K* _) R3 `: F2 _/ Y
        switch(theOperator) 
$ q8 m: ?8 I9 ?. a2 N7 ^$ X' M7 w
        {$ V0 t6 _, o/ ?: ^

case 2:        //重载运算符* 
9 Q, d, a\\" n8 m* v! I
                pRealArray1=(luRealArray *)SearchKey((char *)&(xx->x),sizeof(luVOID),luDynData_realarray); 
\\" p/ U( W( E) U. L) V2 D% J1 K
                pRealArray2=(luRealArray *)SearchKey((char *)&((xx+1)->x),sizeof(luVOID),luDynData_realarray); 
$ X+ G; f) a- v3 |: q
                if(!pRealArray1 || !pRealArray2) break;        //对象句柄无效，不是实数数组 
) n8 L9 S/ _1 J* Y0 P
                if(pRealArray1->DimLen!=2 || pRealArray2->DimLen!=2) break;        //不是二维实数数组（矩阵） 
! Q, b2 S% L, }# y: z
                if(pRealArray1->Dim[1]!=pRealArray2->Dim[0]) break;        //维数不匹配 
$ a7 {, h: r# b) [* u
                pRealArray3=(luRealArray *)NewSysObj(luDynData_realarray,pRealArray1->Dim[0]*pRealArray2->Dim[1],2);        //创建矩阵对象 
# }1 K  G0 t: {' p, ~. E
                if(!pRealArray3) break; 
3 h# P# X\\" [- R, R
                pRealArray3->Dim[0]=pRealArray1->Dim[0]; pRealArray3->Dim[1]=pRealArray2->Dim[1];        //设置矩阵维数大小4 Y5 b, ?) G  ]) J

pa=pRealArray1->Array; pb=pRealArray2->Array; pc=pRealArray3->Array;2 G) c: H; H$ K* v3 y

m=pRealArray1->Dim[0]; n=pRealArray1->Dim[1]; k=pRealArray2->Dim[1];$ Y. r  N; D4 c; k

for(i=0; i<m; i++)        //矩阵乘8 s* u4 u0 d$ ?$ U# C) y( b

{% X# |* }# c4 l

for(j=0; j<k; j++). Y+ Z+ C& ?, s& V1 `

{) D. g2 i8 o, N/ y9 U

u=i*k+j; pc[u]=0.0;3 |' M* ?5 i1 w  n7 O, q% r( |

for (v=0; v<n; v++) 
! U# F1 _  b8 q' [! [$ h, u' }
                                { 
1 a0 r+ K5 d; c
                                        pc[u]=pc[u]+pa[i*n+v]*pb[v*k+j];, B/ L# l7 {2 i4 Y* G) m

}9 b9 B\\" l% n* F& I6 F9 y

} 
) P, D/ J' ~+ Z/ D- E
                } 
- n% \: h- [; d) O
                FunReObj(hFor);        //告诉Lu，返回一个动态对象9 a& C* D. R  l

a.BType=luDynData_realarray; a.VType=Matrix; a.x=0; *(luVOID *)&(a.x)=(luVOID)pRealArray3; 
$ _  k4 K% A8 h/ \! g/ v
                break;, Q\\" L! r: c, i1 E# h$ l+ }

case 25:        //重载运算符.*! v1 e! a6 T9 H( s; A0 a

pRealArray1=(luRealArray *)SearchKey((char *)&(xx->x),sizeof(luVOID),luDynData_realarray); 
: D( h8 M: y# z+ g* N
                pRealArray2=(luRealArray *)SearchKey((char *)&((xx+1)->x),sizeof(luVOID),luDynData_realarray);* ~2 T9 z& \/ r: S8 [* b9 H) M2 U

if(!pRealArray1 || !pRealArray2) break;        //对象句柄无效，不是实数数组 
& D3 Q: n8 c: X, _) i1 N$ d
                if(pRealArray1->DimLen!=2 || pRealArray2->DimLen!=2) break;        //不是二维实数数组（矩阵）- s9 u: y4 ]+ d6 r9 _* D3 c( C

if(pRealArray1->Dim[0]!=pRealArray2->Dim[0] || pRealArray1->Dim[1]!=pRealArray2->Dim[1]) break;        //维数不相同5 W5 y\\" c) k1 g6 g. w

pRealArray3=(luRealArray *)NewSysObj(luDynData_realarray,pRealArray1->ArrayLen,2);        //创建矩阵对象  g8 w/ }' W* a1 r# i/ X: I

if(!pRealArray3) break; 
3 M2 h1 f( O- I
                pRealArray3->Dim[0]=pRealArray1->Dim[0]; pRealArray3->Dim[1]=pRealArray1->Dim[1];        //设置矩阵维数大小 
: T2 {7 L' F! R4 k) l6 U
                for(i=0;i<pRealArray1->ArrayLen;i++) pRealArray3->Array[i]=pRealArray1->Array[i]*pRealArray2->Array[i];//矩阵点乘1 p; d1 V) P! f: n. [

FunReObj(hFor);        //告诉Lu，返回一个动态对象' Q+ z3 G% }# ?1 `

a.BType=luDynData_realarray; a.VType=Matrix; a.x=0; *(luVOID *)&(a.x)=(luVOID)pRealArray3; 
  [6 f/ T6 I  L7 [1 o
                break; 
\\" n1 L  \! C' F' ^- u  T
        case 46:        //重载函数new 
6 Y( b$ j, p- d
                a=ExeOperator(mm,xx,hFor,theOperator,luDynData_realarray);        //直接调用基本类型luDynData_realarray的new函数 
% c# U7 x8 }& b& H- K
                if(a.VType==luDynData_realarray) a.VType=Matrix;        //设置扩展类型为自定义的Matrix类型5 N  U\\" O! }! ^, f. P' A6 R

break; 
/ ^% a. f. F+ y
        case 49:        //重载函数o( g! B$ Y8 f0 K# b3 {7 C) a

pMessage=(luMessage)SearchKey("\0\0\0\0",sizeof(luVOID),luPubKey_User);% H! u& q\\" E4 h/ s% ~9 |: W+ @

if(!pMessage) break; 
) S' m; I: t& h. K; Q\\" n. E0 a' _
                pRealArray1=(luRealArray *)SearchKey((char *)&(xx->x),sizeof(luVOID),luDynData_realarray); 
7 [/ I& `5 ]5 i\\" J5 z
                if(!pRealArray1) break;        //对象句柄无效，不是实数数组 
& D7 @\\" S0 x6 l; {2 Y
                if(pRealArray1->DimLen!=2) break;        //不是二维实数数组（矩阵）( E+ C7 a0 E% X9 N$ P2 f7 K2 Z* Y

pa=pRealArray1->Array;8 l7 g) ]$ W! @& o

m=pRealArray1->Dim[0]; n=pRealArray1->Dim[1]; k=0;  C+ Y  s; s5 _4 C1 F3 f

for(i=0; i<m; i++)        //输出矩阵 
9 M3 l' ?: ]& g4 H  X\\" f
                { 
9 E6 n* x' Y* I# N4 v
                        pMessage(L"\r\n"); k+=2; 
) u7 J. G3 ]* N\\" y+ C
                        for(j=0; j<n; j++)$ P- |\\" Z$ b+ [: J9 V\\" @) T

{ 
0 @+ n8 n2 p- t3 C1 ~\\" Q. m
                                _gcvt_s(chNum,pa[i*n+j],16); 
* x0 G/ O& h$ A+ ]* g, \# I; @) _
                                for(u=0;chNum[u];u++) {wchNum[u]=chNum[u]; k++;}* ]2 b1 i  @5 F2 Z

wchNum[u]='\0';0 ~( p% r( ~, |+ k2 J5 o

pMessage(wchNum); pMessage(L"  "); k+=2; 
( h  S7 p* z\\" B+ K
                        }' Y! N8 w5 [1 K

}) p7 M4 r6 X( `/ U0 y

pMessage(L"\r\n"); k+=2;$ H4 |\\" y, U  l; c' D' H5 t

a.BType=luStaData_int64; a.VType=luStaData_int64; a.x=k;        //按函数o的要求，返回输出的字符总数8 r. x8 f3 v# ?\\" W$ [! V+ u8 V5 i

break; 
6 M% \+ j- D8 y
        default: 
1 m3 `( R' ^0 j2 L& T
                break; 
\\" W8 y\\" f4 ~- \
        }3 R  H) p' l4 t+ R/ @) N

return a;, t) l) H# r  K; ?

} 
% r' J& {4 L# @. H
void main(void)3 o, H+ `5 b3 e$ ?/ s$ ~

{. e1 r+ x2 P5 j

void *hFor;                //表达式句柄 
' V. k) |2 ]- h0 H/ _
        luINT nPara;                //存放表达式的自变量个数( w' \; C& \0 ^) e( M

LuData *pPara;                //存放输入自变量的数组指针 
% K# e- s) R+ o\\" _* }# a( @
        luINT ErrBegin,ErrEnd;        //表达式编译出错的初始位置和结束位置  y$ i! i: r2 C

int ErrCode;                //错误代码 
$ J1 N8 @7 m  z1 U5 x+ D\\" H7 K
        void *v; 
3 r, d% d2 I( u! r/ M7 c4 t
        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.]}";//字符串表达式，矩阵乘 
& i$ ~% w/ `5 K( c+ u1 Q
        //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.]}";//字符串表达式，矩阵点乘 
5 b3 ~, h8 \5 d2 z1 f
        LuData Val;* ~\\" `, o9 y: r! C- ~

if(!InitLu()) return;        //初始化Lu 
% x9 |# V) H8 ]  @
        while(LockKey(Matrix,DelMatrix,OpMatrix)){Matrix++;}        //锁定一个键，用于存储矩阵扩展类型 
  z2 E% T: N9 E7 V% A0 s
* U2 ]% H. h: h  b. A

Val.BType=luStaData_int64; Val.VType=luStaData_int64; Val.x=Matrix;        //定义整数常量& x6 W2 e8 U7 {% F, q

SetConst(L"matrix",&Val);        //设置整数常量 
. f( ~( d0 Z& \% q5 H
        InsertKey("\0\0\0\0",4,luPubKey_User,LuMessage,NULL,NULL,1,v); //使Lu运行时可输出函数信息9 _\\" Z% m2 S. E3 d, X4 Y0 K

wcout.imbue(locale("chs"));        //设置输出的locale为中文( o6 C\\" I# l9 K5 R! d6 J

5 ]* i4 t% u( k2 e' z  x/ N\\" N

ErrCode=LuCom(ForStr,0,0,0,hFor,nPara,pPara,ErrBegin,ErrEnd); //编译表达式 
$ a1 T$ d\\" t5 G+ a/ F2 V\\" {+ s
        if(ErrCode)) B) u! R; C% a! M+ m% m

{! p2 t, Z7 s% }& v; Q' @+ q9 q

wcout<<L"表达式有错误！错误代码："<<ErrCode<<endl; 
! g3 A' T8 W& k+ b  M+ o, J
        } 
& Q$ u- n* I9 _4 @; c  Z  @
        else 
2 B7 T2 N1 k, w% y
        {5 L8 Y% |; H8 `) f\\" J+ N' f

LuCal(hFor,pPara);        //计算表达式的值 
- ]2 |  U) F5 f: d+ z
        }+ v- O7 s5 X6 [2 i

LockKey(Matrix,NULL,OpMatrix);//解锁键Matrix，本例中，该函数可以不用 
7 {* X  Z$ Y% {! x+ D
        FreeLu();                        //释放Lu 
. f\\" C: Y! O/ J/ _$ r7 Z
}

习题：

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

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

main(:a,b,c,d,t,i)=
3 ?5 l1 g, x) j# y) H$ b& i& v
a=new[matrix,2,2,data:1.,2.,2.,1.],
$ Y: a0 Q4 f3 p- H6 E& A\" p8 q# K
b=new[matrix,2,2,data:2.,1.,1.,2.],
6 P; M( c$ ?/ y' {
c=new[matrix,2,2,data:2/3.,-1/3.,-1/3.,2/3.],
! p\" G% a, ?$ {& j) J
t=clock(),
2 v t% q- s0 C
d=a*b, i=0, while{i<1000000, d=d*c*b, i++},
\" x' H Z. u7 _3 E+ B& u6 O4 ~
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\"}";//字符串表达式

复制代码

结果：