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

查看: 8670|回复: 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>' t+ ]% h\\" P) \; x( t. H h# M2 c4 Z
#include <iostream>! X! O+ N, {0 M) Q- T
#include <math.h># R9 G) q! s( h% f, o
#include "lu32.h"9 @, A0 e' M) G/ W1 Q
' k3 F\\" ^4 R\\" P6 Y' y4 ]' e
#pragma comment( lib, "lu32.lib" )
& h1 f- x _# i$ ^- h: s7 v
- u, n# [; H9 p9 f; b+ _
using namespace std;* @) {* [8 G/ [& D
8 z( g3 q. j; @4 O5 B. Q
luKEY Matrix=-1000; //标识矩阵类型，最终的Matrix由LockKey决定8 D: g* m\\" G) n: M7 P* U
+ t2 y6 v# x2 i& F& r6 y& I% X
void _stdcall LuMessage(wchar_t *pch)//输出动态库信息，该函数注册到Lu，由Lu二级函数调用
* r$ G& Q8 C/ N1 Z! l$ B
{
7 T7 \& p5 @! J: ]/ r8 u
wcout<<pch;
+ K4 {, r8 z/ g. E; G\\" K) E- k5 }
}* k$ d# O( K& R3 T
void _stdcall DelMatrix(void *me) //用于LockKey函数，因为是基于系统内置实数数组创建矩阵，故该函数什么也不做
$ D5 v# e- S* l, u: r Y
{4 n- u- v: o9 _5 l1 R+ |. i3 Z
}3 Q5 h' f( C, ^/ m
LuData _stdcall OpMatrix(luINT mm,LuData *xx,void *hFor,int theOperator) //运算符重载函数，用于LockKey函数
$ A2 H, }9 n8 y) p
{% ~. U) N, J+ t+ w% s
LuData a;/ l* m5 V2 l0 A: u* g
luRealArray *pRealArray1,*pRealArray2,*pRealArray3;
( ~5 r' U2 C7 G' I/ H
luVOID i,j,k,m,n,u,v;
! a8 z- m/ d, f. {! ~# O- Q: X. D
double *pa,*pb,*pc;\\" A+ E4 n! I$ W: S0 \0 A* f) v
luMessage pMessage;
' }) |, O7 L) D( Q
wchar_t wchNum[32];
* L7 y\\" _! Y: P, o
char chNum[32];
' [% u% I2 [\\" i& {. g( ^ d. o& Q
a.BType=luStaData_nil; a.VType=luStaData_nil; a.x=0;/ h& i( Y5 m5 I
switch(theOperator)
$ C/ i) @, G+ ?( V) a; y/ u
{, Q- T9 g\\" F8 V
case 2: //重载运算符*8 T. l, r8 p) C! U5 B
pRealArray1=(luRealArray *)SearchKey((char *)&(xx->x),sizeof(luVOID),luDynData_realarray);
& `+ Z+ W\\" `7 s1 D
pRealArray2=(luRealArray *)SearchKey((char *)&((xx+1)->x),sizeof(luVOID),luDynData_realarray);6 C. {( _# y3 _6 \: @- \( U9 T
if(!pRealArray1 || !pRealArray2) break; //对象句柄无效，不是实数数组1 B5 ?+ {; s& A( |$ B
if(pRealArray1->DimLen!=2 || pRealArray2->DimLen!=2) break; //不是二维实数数组（矩阵）) c0 ]1 [0 H* o/ z+ {/ b
if(pRealArray1->Dim[1]!=pRealArray2->Dim[0]) break; //维数不匹配. S9 _& d( G; z8 x: K9 c% H1 j
pRealArray3=(luRealArray *)NewSysObj(luDynData_realarray,pRealArray1->Dim[0]*pRealArray2->Dim[1],2); //创建矩阵对象4 _+ d3 R i4 i
if(!pRealArray3) break;
) ~! O' N( o, Z9 t, } p5 [
pRealArray3->Dim[0]=pRealArray1->Dim[0]; pRealArray3->Dim[1]=pRealArray2->Dim[1]; //设置矩阵维数大小
[/ k# S7 t9 W1 \) H' o+ [
pa=pRealArray1->Array; pb=pRealArray2->Array; pc=pRealArray3->Array;
& U: P7 Q* a' W' E( _
m=pRealArray1->Dim[0]; n=pRealArray1->Dim[1]; k=pRealArray2->Dim[1];
+ v0 _9 ~( [- G4 }& L5 g
for(i=0; i<m; i++) //矩阵乘
4 k: z; e1 G; Y( ~( V, x
{; D4 H# {8 G6 D
for(j=0; j<k; j++)+ M5 q* S+ t( ]6 }
{( [9 D& K! f) g! Z2 m3 `
u=i*k+j; pc[u]=0.0;
( i3 o) R( k5 V1 J9 H) y# A( a5 x
for (v=0; v<n; v++)2 ?\\" [0 e/ Y' ^& F
{
, q! C W* {( F0 `
pc[u]=pc[u]+pa[i*n+v]*pb[v*k+j];
% }2 q: U- M; `
}5 n9 l% k/ l2 G. L
}
% m, j$ b6 [: x8 U6 ?
}4 J3 t6 a. q5 y% Z, c* ?8 i; |& h
FunReObj(hFor); //告诉Lu，返回一个动态对象1 N9 S \7 f7 j; D, J4 r
a.BType=luDynData_realarray; a.VType=Matrix; a.x=0; *(luVOID *)&(a.x)=(luVOID)pRealArray3;
% ^7 B; I6 ]& Y6 K2 G% F% I, Y1 D\\" c
break;. `' ^% ^* r\\" B+ g
case 25: //重载运算符.*
& q' c8 i3 v2 v9 B
pRealArray1=(luRealArray *)SearchKey((char *)&(xx->x),sizeof(luVOID),luDynData_realarray);+ R& d- r! w\\" T+ o
pRealArray2=(luRealArray *)SearchKey((char *)&((xx+1)->x),sizeof(luVOID),luDynData_realarray);
8 A4 Q5 d* w& y7 V* a: o# L) K
if(!pRealArray1 || !pRealArray2) break; //对象句柄无效，不是实数数组7 ?* Y9 I/ W6 u# }& v5 @
if(pRealArray1->DimLen!=2 || pRealArray2->DimLen!=2) break; //不是二维实数数组（矩阵）8 F, O$ _8 Y9 d4 ~
if(pRealArray1->Dim[0]!=pRealArray2->Dim[0] || pRealArray1->Dim[1]!=pRealArray2->Dim[1]) break; //维数不相同9 m# F7 d4 } s7 X; z% B- F0 G: X: [
pRealArray3=(luRealArray *)NewSysObj(luDynData_realarray,pRealArray1->ArrayLen,2); //创建矩阵对象# k; w! C% Y) U6 P+ l' ^7 v/ N
if(!pRealArray3) break;$ C* Z! B: J+ ~- J) r% Y: T
pRealArray3->Dim[0]=pRealArray1->Dim[0]; pRealArray3->Dim[1]=pRealArray1->Dim[1]; //设置矩阵维数大小# ?# U3 \8 a T
for(i=0;i<pRealArray1->ArrayLen;i++) pRealArray3->Array[i]=pRealArray1->Array[i]*pRealArray2->Array[i];//矩阵点乘
e0 V+ e! k/ K; r
FunReObj(hFor); //告诉Lu，返回一个动态对象
# o0 Y5 D0 O0 F
a.BType=luDynData_realarray; a.VType=Matrix; a.x=0; *(luVOID *)&(a.x)=(luVOID)pRealArray3;
% ]2 f/ Y: Z! l
break;0 h5 U6 J% j( d2 j0 H* N
case 46: //重载函数new; W, B/ O- L( v. t# }
a=ExeOperator(mm,xx,hFor,theOperator,luDynData_realarray); //直接调用基本类型luDynData_realarray的new函数% p% x( K' t% o0 Z5 N' ] C
if(a.VType==luDynData_realarray) a.VType=Matrix; //设置扩展类型为自定义的Matrix类型
+ `# P* z! s1 Q6 z
break;
; ?; E/ V- A+ \1 J% e5 v
case 49: //重载函数o' _4 J/ r/ N& J- s$ z, s
pMessage=(luMessage)SearchKey("\0\0\0\0",sizeof(luVOID),luPubKey_User);7 G3 n2 X9 ]7 D\\" ]
if(!pMessage) break;. w: V G& Y1 F5 k8 U: ]) P: \
pRealArray1=(luRealArray *)SearchKey((char *)&(xx->x),sizeof(luVOID),luDynData_realarray);
) R$ h7 t s& u6 A. P. {! G: `
if(!pRealArray1) break; //对象句柄无效，不是实数数组% G/ o0 n2 A, s' ]
if(pRealArray1->DimLen!=2) break; //不是二维实数数组（矩阵）
! f* n9 l; I+ Q
pa=pRealArray1->Array;1 z! W: z' n2 J3 E
m=pRealArray1->Dim[0]; n=pRealArray1->Dim[1]; k=0;
0 Q3 M& o\\" ^; K0 s) c: N
for(i=0; i<m; i++) //输出矩阵
) m, B& [' o\\" X) ?
{
& y! F3 M6 C2 a. g% B. Y
pMessage(L"\r\n"); k+=2;3 J5 l( f$ _( I' _. b' d
for(j=0; j<n; j++)7 u5 C4 _5 p7 `, H# g: z* e2 Z
{/ R: W! T! k2 w- C: K! H8 A
_gcvt_s(chNum,pa[i*n+j],16);7 X- x+ S* ^# G- i$ M& f& d/ A% D
for(u=0;chNum[u];u++) {wchNum[u]=chNum[u]; k++;}4 l5 Y# {/ k# m. w' G
wchNum[u]='\0';9 J8 }! s6 n; T/ B
pMessage(wchNum); pMessage(L" "); k+=2;7 O/ J4 j3 A: {* Z2 R
}0 F( R) o7 `/ j; _) U9 r; v
}
8 S3 H4 h0 X; r+ I0 V* i/ _5 z
pMessage(L"\r\n"); k+=2;
* Z- M! K% H\\" p; ]8 N, X6 q
a.BType=luStaData_int64; a.VType=luStaData_int64; a.x=k; //按函数o的要求，返回输出的字符总数. I1 \\\" O3 B) z5 M! V! l6 E9 H, W
break;: @5 e. l, d7 G* @0 Y& z- m
default:
! T0 ]# {- V: g. T( w( @
break;
6 t5 k! C- ^; z5 U7 k
}4 z7 j9 k+ P\\" g9 C/ v0 Z( a
return a;
) ?, B/ e) L& F' t0 J\\" L) A
}$ B' ?0 P7 l2 M8 Q
void main(void)$ _0 a1 h0 H& D {7 w
{
: V1 u\\" e* {; }! s3 N! W\\" t3 n
void *hFor; //表达式句柄: R, j2 s$ _# \2 H& A
luINT nPara; //存放表达式的自变量个数
1 p2 w) Z+ K7 m( p; I
LuData *pPara; //存放输入自变量的数组指针8 |+ S9 ]. ?; b8 L @! w
luINT ErrBegin,ErrEnd; //表达式编译出错的初始位置和结束位置
0 D( m0 f9 ?\\" r. d3 a8 p\\" p: v
int ErrCode; //错误代码3 d' z, }0 M8 R7 k7 q1 Q$ s G% Y
void *v;# y% }2 _0 x9 q+ ]/ O3 ]
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) o6 d( @1 `, 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.]}";//字符串表达式，矩阵点乘
3 I$ j' }$ q- P/ U/ `\\" P
LuData Val;! S, @ l$ b) m$ a' H
if(!InitLu()) return; //初始化Lu7 \6 a3 T, I. l* C! B
while(LockKey(Matrix,DelMatrix,OpMatrix)){Matrix++;} //锁定一个键，用于存储矩阵扩展类型6 X\\" g\\" H. ]0 Z9 S
/ j* n2 X6 a0 D) D\\" Q
Val.BType=luStaData_int64; Val.VType=luStaData_int64; Val.x=Matrix; //定义整数常量
+ a- B+ h3 E' \2 v' H6 \! [
SetConst(L"matrix",&Val); //设置整数常量' }* g6 `! Q# {7 Q% n
InsertKey("\0\0\0\0",4,luPubKey_User,LuMessage,NULL,NULL,1,v); //使Lu运行时可输出函数信息+ ^. ?$ c9 Q4 _, z3 v( a# h
wcout.imbue(locale("chs")); //设置输出的locale为中文
9 s8 f- E: v5 y4 W; e/ _
/ J {- ~( }9 Y( D% X3 f
ErrCode=LuCom(ForStr,0,0,0,hFor,nPara,pPara,ErrBegin,ErrEnd); //编译表达式
5 [3 C- c) `# Q: B. ^+ D
if(ErrCode)9 e5 O% [6 h+ ]
{6 y4 L) C7 a% D. F8 |\\" X
wcout<<L"表达式有错误！错误代码："<<ErrCode<<endl;
\\" x& s+ g# x. A* N) M# P0 B
}0 |8 u, d# S/ U0 G2 ~0 {8 ^
else% G$ i$ Q$ f+ g3 B% O: g
{ _, K# v: x9 B# Z; c
LuCal(hFor,pPara); //计算表达式的值1 d8 L* v7 r+ d\\" i
}# H7 @' B( Z1 K( j, u. [3 ^9 |
LockKey(Matrix,NULL,OpMatrix);//解锁键Matrix，本例中，该函数可以不用
1 }. K6 t' _0 d8 B
FreeLu(); //释放Lu
8 l6 I+ ^, i\\" e) l9 j) _ Q
}

#include <windows.h>' t+ ]% h\\" P) \; x( t. H  h# M2 c4 Z

#include <iostream>! X! O+ N, {0 M) Q- T

#include <math.h># R9 G) q! s( h% f, o

#include "lu32.h"9 @, A0 e' M) G/ W1 Q

' k3 F\\" ^4 R\\" P6 Y' y4 ]' e
#pragma comment( lib, "lu32.lib" ) 
& h1 f- x  _# i$ ^- h: s7 v
- u, n# [; H9 p9 f; b+ _

using namespace std;* @) {* [8 G/ [& D

8 z( g3 q. j; @4 O5 B. Q
luKEY Matrix=-1000;        //标识矩阵类型，最终的Matrix由LockKey决定8 D: g* m\\" G) n: M7 P* U

+ t2 y6 v# x2 i& F& r6 y& I% X
void _stdcall LuMessage(wchar_t *pch)//输出动态库信息，该函数注册到Lu，由Lu二级函数调用 
* r$ G& Q8 C/ N1 Z! l$ B
{ 
7 T7 \& p5 @! J: ]/ r8 u
        wcout<<pch; 
+ K4 {, r8 z/ g. E; G\\" K) E- k5 }
}* k$ d# O( K& R3 T

void _stdcall DelMatrix(void *me)        //用于LockKey函数，因为是基于系统内置实数数组创建矩阵，故该函数什么也不做 
$ D5 v# e- S* l, u: r  Y
{4 n- u- v: o9 _5 l1 R+ |. i3 Z

}3 Q5 h' f( C, ^/ m

LuData _stdcall OpMatrix(luINT mm,LuData *xx,void *hFor,int theOperator)        //运算符重载函数，用于LockKey函数 
$ A2 H, }9 n8 y) p
{% ~. U) N, J+ t+ w% s

LuData a;/ l* m5 V2 l0 A: u* g

luRealArray *pRealArray1,*pRealArray2,*pRealArray3; 
( ~5 r' U2 C7 G' I/ H
        luVOID i,j,k,m,n,u,v; 
! a8 z- m/ d, f. {! ~# O- Q: X. D
        double *pa,*pb,*pc;\\" A+ E4 n! I$ W: S0 \0 A* f) v

luMessage pMessage; 
' }) |, O7 L) D( Q
        wchar_t wchNum[32]; 
* L7 y\\" _! Y: P, o
        char chNum[32]; 
' [% u% I2 [\\" i& {. g( ^  d. o& Q
        a.BType=luStaData_nil; a.VType=luStaData_nil; a.x=0;/ h& i( Y5 m5 I

switch(theOperator) 
$ C/ i) @, G+ ?( V) a; y/ u
        {, Q- T9 g\\" F8 V

case 2:        //重载运算符*8 T. l, r8 p) C! U5 B

pRealArray1=(luRealArray *)SearchKey((char *)&(xx->x),sizeof(luVOID),luDynData_realarray); 
& `+ Z+ W\\" `7 s1 D
                pRealArray2=(luRealArray *)SearchKey((char *)&((xx+1)->x),sizeof(luVOID),luDynData_realarray);6 C. {( _# y3 _6 \: @- \( U9 T

if(!pRealArray1 || !pRealArray2) break;        //对象句柄无效，不是实数数组1 B5 ?+ {; s& A( |$ B

if(pRealArray1->DimLen!=2 || pRealArray2->DimLen!=2) break;        //不是二维实数数组（矩阵）) c0 ]1 [0 H* o/ z+ {/ b

if(pRealArray1->Dim[1]!=pRealArray2->Dim[0]) break;        //维数不匹配. S9 _& d( G; z8 x: K9 c% H1 j

pRealArray3=(luRealArray *)NewSysObj(luDynData_realarray,pRealArray1->Dim[0]*pRealArray2->Dim[1],2);        //创建矩阵对象4 _+ d3 R  i4 i

if(!pRealArray3) break; 
) ~! O' N( o, Z9 t, }  p5 [
                pRealArray3->Dim[0]=pRealArray1->Dim[0]; pRealArray3->Dim[1]=pRealArray2->Dim[1];        //设置矩阵维数大小 
  [/ k# S7 t9 W1 \) H' o+ [
                pa=pRealArray1->Array; pb=pRealArray2->Array; pc=pRealArray3->Array; 
& U: P7 Q* a' W' E( _
                m=pRealArray1->Dim[0]; n=pRealArray1->Dim[1]; k=pRealArray2->Dim[1]; 
+ v0 _9 ~( [- G4 }& L5 g
                for(i=0; i<m; i++)        //矩阵乘 
4 k: z; e1 G; Y( ~( V, x
                {; D4 H# {8 G6 D

for(j=0; j<k; j++)+ M5 q* S+ t( ]6 }

{( [9 D& K! f) g! Z2 m3 `

u=i*k+j; pc[u]=0.0; 
( i3 o) R( k5 V1 J9 H) y# A( a5 x
                                for (v=0; v<n; v++)2 ?\\" [0 e/ Y' ^& F

{ 
, q! C  W* {( F0 `
                                        pc[u]=pc[u]+pa[i*n+v]*pb[v*k+j]; 
% }2 q: U- M; `
                                }5 n9 l% k/ l2 G. L

} 
% m, j$ b6 [: x8 U6 ?
                }4 J3 t6 a. q5 y% Z, c* ?8 i; |& h

FunReObj(hFor);        //告诉Lu，返回一个动态对象1 N9 S  \7 f7 j; D, J4 r

a.BType=luDynData_realarray; a.VType=Matrix; a.x=0; *(luVOID *)&(a.x)=(luVOID)pRealArray3; 
% ^7 B; I6 ]& Y6 K2 G% F% I, Y1 D\\" c
                break;. `' ^% ^* r\\" B+ g

case 25:        //重载运算符.* 
& q' c8 i3 v2 v9 B
                pRealArray1=(luRealArray *)SearchKey((char *)&(xx->x),sizeof(luVOID),luDynData_realarray);+ R& d- r! w\\" T+ o

pRealArray2=(luRealArray *)SearchKey((char *)&((xx+1)->x),sizeof(luVOID),luDynData_realarray); 
8 A4 Q5 d* w& y7 V* a: o# L) K
                if(!pRealArray1 || !pRealArray2) break;        //对象句柄无效，不是实数数组7 ?* Y9 I/ W6 u# }& v5 @

if(pRealArray1->DimLen!=2 || pRealArray2->DimLen!=2) break;        //不是二维实数数组（矩阵）8 F, O$ _8 Y9 d4 ~

if(pRealArray1->Dim[0]!=pRealArray2->Dim[0] || pRealArray1->Dim[1]!=pRealArray2->Dim[1]) break;        //维数不相同9 m# F7 d4 }  s7 X; z% B- F0 G: X: [

pRealArray3=(luRealArray *)NewSysObj(luDynData_realarray,pRealArray1->ArrayLen,2);        //创建矩阵对象# k; w! C% Y) U6 P+ l' ^7 v/ N

if(!pRealArray3) break;$ C* Z! B: J+ ~- J) r% Y: T

pRealArray3->Dim[0]=pRealArray1->Dim[0]; pRealArray3->Dim[1]=pRealArray1->Dim[1];        //设置矩阵维数大小# ?# U3 \8 a  T

for(i=0;i<pRealArray1->ArrayLen;i++) pRealArray3->Array[i]=pRealArray1->Array[i]*pRealArray2->Array[i];//矩阵点乘 
  e0 V+ e! k/ K; r
                FunReObj(hFor);        //告诉Lu，返回一个动态对象 
# o0 Y5 D0 O0 F
                a.BType=luDynData_realarray; a.VType=Matrix; a.x=0; *(luVOID *)&(a.x)=(luVOID)pRealArray3; 
% ]2 f/ Y: Z! l
                break;0 h5 U6 J% j( d2 j0 H* N

case 46:        //重载函数new; W, B/ O- L( v. t# }

a=ExeOperator(mm,xx,hFor,theOperator,luDynData_realarray);        //直接调用基本类型luDynData_realarray的new函数% p% x( K' t% o0 Z5 N' ]  C

if(a.VType==luDynData_realarray) a.VType=Matrix;        //设置扩展类型为自定义的Matrix类型 
+ `# P* z! s1 Q6 z
                break; 
; ?; E/ V- A+ \1 J% e5 v
        case 49:        //重载函数o' _4 J/ r/ N& J- s$ z, s

pMessage=(luMessage)SearchKey("\0\0\0\0",sizeof(luVOID),luPubKey_User);7 G3 n2 X9 ]7 D\\" ]

if(!pMessage) break;. w: V  G& Y1 F5 k8 U: ]) P: \

pRealArray1=(luRealArray *)SearchKey((char *)&(xx->x),sizeof(luVOID),luDynData_realarray); 
) R$ h7 t  s& u6 A. P. {! G: `
                if(!pRealArray1) break;        //对象句柄无效，不是实数数组% G/ o0 n2 A, s' ]

if(pRealArray1->DimLen!=2) break;        //不是二维实数数组（矩阵） 
! f* n9 l; I+ Q
                pa=pRealArray1->Array;1 z! W: z' n2 J3 E

m=pRealArray1->Dim[0]; n=pRealArray1->Dim[1]; k=0; 
0 Q3 M& o\\" ^; K0 s) c: N
                for(i=0; i<m; i++)        //输出矩阵 
) m, B& [' o\\" X) ?
                { 
& y! F3 M6 C2 a. g% B. Y
                        pMessage(L"\r\n"); k+=2;3 J5 l( f$ _( I' _. b' d

for(j=0; j<n; j++)7 u5 C4 _5 p7 `, H# g: z* e2 Z

{/ R: W! T! k2 w- C: K! H8 A

_gcvt_s(chNum,pa[i*n+j],16);7 X- x+ S* ^# G- i$ M& f& d/ A% D

for(u=0;chNum[u];u++) {wchNum[u]=chNum[u]; k++;}4 l5 Y# {/ k# m. w' G

wchNum[u]='\0';9 J8 }! s6 n; T/ B

pMessage(wchNum); pMessage(L"  "); k+=2;7 O/ J4 j3 A: {* Z2 R

}0 F( R) o7 `/ j; _) U9 r; v

} 
8 S3 H4 h0 X; r+ I0 V* i/ _5 z
                pMessage(L"\r\n"); k+=2; 
* Z- M! K% H\\" p; ]8 N, X6 q
                a.BType=luStaData_int64; a.VType=luStaData_int64; a.x=k;        //按函数o的要求，返回输出的字符总数. I1 \\\" O3 B) z5 M! V! l6 E9 H, W

break;: @5 e. l, d7 G* @0 Y& z- m

default: 
! T0 ]# {- V: g. T( w( @
                break; 
6 t5 k! C- ^; z5 U7 k
        }4 z7 j9 k+ P\\" g9 C/ v0 Z( a

return a; 
) ?, B/ e) L& F' t0 J\\" L) A
}$ B' ?0 P7 l2 M8 Q

void main(void)$ _0 a1 h0 H& D  {7 w

{ 
: V1 u\\" e* {; }! s3 N! W\\" t3 n
        void *hFor;                //表达式句柄: R, j2 s$ _# \2 H& A

luINT nPara;                //存放表达式的自变量个数 
1 p2 w) Z+ K7 m( p; I
        LuData *pPara;                //存放输入自变量的数组指针8 |+ S9 ]. ?; b8 L  @! w

luINT ErrBegin,ErrEnd;        //表达式编译出错的初始位置和结束位置 
0 D( m0 f9 ?\\" r. d3 a8 p\\" p: v
        int ErrCode;                //错误代码3 d' z, }0 M8 R7 k7 q1 Q$ s  G% Y

void *v;# y% }2 _0 x9 q+ ]/ O3 ]

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) o6 d( @1 `, 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.]}";//字符串表达式，矩阵点乘 
3 I$ j' }$ q- P/ U/ `\\" P
        LuData Val;! S, @  l$ b) m$ a' H

if(!InitLu()) return;        //初始化Lu7 \6 a3 T, I. l* C! B

while(LockKey(Matrix,DelMatrix,OpMatrix)){Matrix++;}        //锁定一个键，用于存储矩阵扩展类型6 X\\" g\\" H. ]0 Z9 S

/ j* n2 X6 a0 D) D\\" Q

Val.BType=luStaData_int64; Val.VType=luStaData_int64; Val.x=Matrix;        //定义整数常量 
+ a- B+ h3 E' \2 v' H6 \! [
        SetConst(L"matrix",&Val);        //设置整数常量' }* g6 `! Q# {7 Q% n

InsertKey("\0\0\0\0",4,luPubKey_User,LuMessage,NULL,NULL,1,v); //使Lu运行时可输出函数信息+ ^. ?$ c9 Q4 _, z3 v( a# h

wcout.imbue(locale("chs"));        //设置输出的locale为中文 
9 s8 f- E: v5 y4 W; e/ _
   
/ J  {- ~( }9 Y( D% X3 f
        ErrCode=LuCom(ForStr,0,0,0,hFor,nPara,pPara,ErrBegin,ErrEnd); //编译表达式 
5 [3 C- c) `# Q: B. ^+ D
        if(ErrCode)9 e5 O% [6 h+ ]

{6 y4 L) C7 a% D. F8 |\\" X

wcout<<L"表达式有错误！错误代码："<<ErrCode<<endl; 
\\" x& s+ g# x. A* N) M# P0 B
        }0 |8 u, d# S/ U0 G2 ~0 {8 ^

else% G$ i$ Q$ f+ g3 B% O: g

{  _, K# v: x9 B# Z; c

LuCal(hFor,pPara);        //计算表达式的值1 d8 L* v7 r+ d\\" i

}# H7 @' B( Z1 K( j, u. [3 ^9 |

LockKey(Matrix,NULL,OpMatrix);//解锁键Matrix，本例中，该函数可以不用 
1 }. K6 t' _0 d8 B
        FreeLu();                        //释放Lu 
8 l6 I+ ^, i\\" e) l9 j) _  Q
}

习题：

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

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

main(:a,b,c,d,t,i)=
# _( K) l8 Y! P* c
a=new[matrix,2,2,data:1.,2.,2.,1.],
0 U/ g8 N/ \+ u/ A
b=new[matrix,2,2,data:2.,1.,1.,2.],: O* w% u7 u2 J( P2 h6 [$ M
c=new[matrix,2,2,data:2/3.,-1/3.,-1/3.,2/3.],$ u6 Y7 |2 a. Z% X
t=clock(),' c/ ~) E6 W& \, m4 Z# {4 U
d=a*b, i=0, while{i<1000000, d=d*c*b, i++},
! @% q* u' r\" g( P
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\"}";//字符串表达式

复制代码

结果：