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

查看: 8904|回复: 0

Lu基于系统内置对象创建扩展数据类型，小矩阵乘效率测试

[复制链接]

字体大小: 正常放大

forcal

45 主题	3 听众	282 积分

升级 91%

TA的每日心情

	难过 2012-8-27 18:22

签到天数: 1 天

[LV.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>
% ]- s! D. U% T L
#include <iostream>
8 d, O1 S+ x7 g% L- ]& x/ W
#include <math.h>! h; p9 ?: A( K# |& X/ ^
#include "lu32.h"
+ C5 Z) \$ X Q# `# u x4 o1 P
# X3 V! D2 Z& N( {! R# S$ T+ m
#pragma comment( lib, "lu32.lib" )! [- _! \ b/ G+ k\\" O& R
8 m2 D+ b. z1 a
using namespace std;) r1 G0 V( f/ n
% P; M' ^# U/ J$ v0 E
luKEY Matrix=-1000; //标识矩阵类型，最终的Matrix由LockKey决定
5 ^8 z# K% v9 B2 i: x
7 i# L/ ^5 [* U7 A6 ~\\" G% D8 |
void _stdcall LuMessage(wchar_t *pch)//输出动态库信息，该函数注册到Lu，由Lu二级函数调用
( u, N+ |0 q a- a6 P) l5 l$ d; f
{; a' |% L# M2 { ]
wcout<<pch;5 ]: d' ]- R4 a4 B
}( ~+ u5 g- R1 ^' g
void _stdcall DelMatrix(void *me) //用于LockKey函数，因为是基于系统内置实数数组创建矩阵，故该函数什么也不做
9 k, l, t% L ^7 A& l* K& i! ~
{
; a* y! D+ G2 R7 ^
}
7 ^& f2 P0 ` D: m
LuData _stdcall OpMatrix(luINT mm,LuData *xx,void *hFor,int theOperator) //运算符重载函数，用于LockKey函数4 \ ~% q. |) k( P$ C
{
8 Q, [8 t( h0 b& e. t
LuData a;0 W' c& }7 B. v# t) Z6 G8 Y
luRealArray *pRealArray1,*pRealArray2,*pRealArray3;8 \: _, h- ?# v' _) B+ M
luVOID i,j,k,m,n,u,v;
5 G+ t: `8 Y* g3 p& r. y4 G
double *pa,*pb,*pc;9 S/ J4 U1 _4 O6 m- Z. k) M
luMessage pMessage;
4 m, p W, j1 P* S
wchar_t wchNum[32];6 E8 _$ `, @7 G\\" q* E& Y
char chNum[32];: D) ]* ^3 Q& |4 \: [6 Y
a.BType=luStaData_nil; a.VType=luStaData_nil; a.x=0;0 F0 J9 d7 B6 t+ [ s\\" e
switch(theOperator)
& \- E; t7 F3 h5 ?: }1 I& ]2 @1 T
{# H8 F/ |% \, v2 O( j9 j
case 2: //重载运算符*% {& P2 @, Q) U. A
pRealArray1=(luRealArray *)SearchKey((char *)&(xx->x),sizeof(luVOID),luDynData_realarray);
/ Q$ r8 p$ d1 ^$ H/ E
pRealArray2=(luRealArray *)SearchKey((char *)&((xx+1)->x),sizeof(luVOID),luDynData_realarray);2 O; l4 F M3 ^; b9 u I% m$ M% I
if(!pRealArray1 || !pRealArray2) break; //对象句柄无效，不是实数数组# C$ B7 r* |# i: v _% ^
if(pRealArray1->DimLen!=2 || pRealArray2->DimLen!=2) break; //不是二维实数数组（矩阵）; u. y; Z! {: Y7 X
if(pRealArray1->Dim[1]!=pRealArray2->Dim[0]) break; //维数不匹配& G4 |' v, \5 Q1 {' o7 e5 s2 s
pRealArray3=(luRealArray *)NewSysObj(luDynData_realarray,pRealArray1->Dim[0]*pRealArray2->Dim[1],2); //创建矩阵对象; G4 c# l6 K5 J' j. U5 W. p% Z
if(!pRealArray3) break;% L\\" c4 X7 D, R- D% `; d
pRealArray3->Dim[0]=pRealArray1->Dim[0]; pRealArray3->Dim[1]=pRealArray2->Dim[1]; //设置矩阵维数大小
. ?6 b' W. b) \5 m- D% {+ o
pa=pRealArray1->Array; pb=pRealArray2->Array; pc=pRealArray3->Array;
4 S- j7 S: @, T' U. w' W
m=pRealArray1->Dim[0]; n=pRealArray1->Dim[1]; k=pRealArray2->Dim[1];+ |! [; K' U4 `* z. n( v* q
for(i=0; i<m; i++) //矩阵乘
. e5 n: e+ j\\" n* Q# a7 V- k
{
+ `9 v0 h% V2 U- @2 r0 ^4 C
for(j=0; j<k; j++)
* e5 o! z6 [1 _% j- h$ b
{
3 L: X8 ?' d& l+ I
u=i*k+j; pc[u]=0.0;: p$ E8 \ b* N, P# S
for (v=0; v<n; v++)
8 R Z; ~: C, x: A% P7 w4 |\\" D- H
{9 Q: `2 i6 v9 M
pc[u]=pc[u]+pa[i*n+v]*pb[v*k+j];
. N+ y3 c6 X# b, x o& h
}
/ P* o K: Y, ?
}: y# {3 ~4 `( D; _: X
}+ E% g/ E+ F0 j) r& A7 W6 ]
FunReObj(hFor); //告诉Lu，返回一个动态对象
& u/ t) h9 w8 | w: i- b/ ]# G& r
a.BType=luDynData_realarray; a.VType=Matrix; a.x=0; *(luVOID *)&(a.x)=(luVOID)pRealArray3;; U6 X+ K1 M8 c5 d\\" r0 N5 I
break;7 c3 h( w4 C0 c
case 25: //重载运算符.* |\\" r1 G* g\\" d6 V! R
pRealArray1=(luRealArray *)SearchKey((char *)&(xx->x),sizeof(luVOID),luDynData_realarray);) V S0 X\\" j\\" B; P
pRealArray2=(luRealArray *)SearchKey((char *)&((xx+1)->x),sizeof(luVOID),luDynData_realarray);) \: c# @: Q\\" N- Q
if(!pRealArray1 || !pRealArray2) break; //对象句柄无效，不是实数数组
+ ~* a7 I: a( T/ r
if(pRealArray1->DimLen!=2 || pRealArray2->DimLen!=2) break; //不是二维实数数组（矩阵）$ H0 g) N, @# t8 J7 Y1 g
if(pRealArray1->Dim[0]!=pRealArray2->Dim[0] || pRealArray1->Dim[1]!=pRealArray2->Dim[1]) break; //维数不相同- D/ B5 L# x# B+ T- [4 M
pRealArray3=(luRealArray *)NewSysObj(luDynData_realarray,pRealArray1->ArrayLen,2); //创建矩阵对象4 \: E. h4 c1 \. _2 m: P% p* P
if(!pRealArray3) break;
7 G! S1 {' [% u
pRealArray3->Dim[0]=pRealArray1->Dim[0]; pRealArray3->Dim[1]=pRealArray1->Dim[1]; //设置矩阵维数大小$ B/ J5 ^$ e. E8 c. _) v
for(i=0;i<pRealArray1->ArrayLen;i++) pRealArray3->Array[i]=pRealArray1->Array[i]*pRealArray2->Array[i];//矩阵点乘# N: u7 E% W; `& R' a7 L- x# i0 I
FunReObj(hFor); //告诉Lu，返回一个动态对象; s' p2 X# y& }3 B% i# n1 E$ D( o d8 R
a.BType=luDynData_realarray; a.VType=Matrix; a.x=0; *(luVOID *)&(a.x)=(luVOID)pRealArray3;
# l; ^% P2 V8 ^+ y, {. V/ C
break;6 z6 Q2 C2 W& q# x% S
case 46: //重载函数new B* |0 f6 t4 |* x\\" Y
a=ExeOperator(mm,xx,hFor,theOperator,luDynData_realarray); //直接调用基本类型luDynData_realarray的new函数
, U' j3 @, f) N! B$ O\\" j# V, L
if(a.VType==luDynData_realarray) a.VType=Matrix; //设置扩展类型为自定义的Matrix类型7 i, O& ~: I0 b$ W6 |% k) i: w+ \
break;9 Q9 d0 P& v. E7 s; ~
case 49: //重载函数o
5 i3 n( c! G) K8 p
pMessage=(luMessage)SearchKey("\0\0\0\0",sizeof(luVOID),luPubKey_User);5 z. r. a+ v% q |/ |
if(!pMessage) break;
- P+ y* S8 a: D S4 Z& |
pRealArray1=(luRealArray *)SearchKey((char *)&(xx->x),sizeof(luVOID),luDynData_realarray);, X. z4 h$ `7 a. Q' C
if(!pRealArray1) break; //对象句柄无效，不是实数数组
0 w% u V# l5 m
if(pRealArray1->DimLen!=2) break; //不是二维实数数组（矩阵）
! F( q# |: i& N' X
pa=pRealArray1->Array;7 C1 u' d5 J% e6 {: B
m=pRealArray1->Dim[0]; n=pRealArray1->Dim[1]; k=0;
% m! R7 v2 A i0 ?8 {4 ^% h
for(i=0; i<m; i++) //输出矩阵2 t/ z5 S8 _! _- d1 ~
{3 a- q3 R- s8 {( l! y
pMessage(L"\r\n"); k+=2;. y9 q6 A/ U2 S( \8 j+ `7 R2 x
for(j=0; j<n; j++)
n: p$ p* ]. o& U3 x# F. ]
{
\\" E6 j: o x5 a. \; n
_gcvt_s(chNum,pa[i*n+j],16);
4 }% x8 ~% J9 M4 e, I) Y
for(u=0;chNum[u];u++) {wchNum[u]=chNum[u]; k++;}) j0 X# |: A1 ?9 g) {
wchNum[u]='\0';- l0 ^5 d- ?: p; B
pMessage(wchNum); pMessage(L" "); k+=2;4 U6 p1 v1 x+ c% E5 P
}6 p+ e* ^) Q L
}7 G) I# X' B5 }# I, h
pMessage(L"\r\n"); k+=2;2 D+ }3 Z. q+ s# a, d
a.BType=luStaData_int64; a.VType=luStaData_int64; a.x=k; //按函数o的要求，返回输出的字符总数; }' h: l) W, h
break;8 a\\" X! f0 }+ x- R
default:
3 J& P& [* b4 F+ g: E) F
break;
}' u- A6 k3 P8 v& Z/ u+ M5 L) V& @
return a;& O5 Y2 k9 J7 ^\\" S, f `5 h4 W6 c
}
! s T+ M+ L3 m3 g, N$ @7 ~
void main(void)9 N' ~7 y$ K) }$ ~# M8 `
{, W5 i; t+ ^$ H |; U1 f. Y% \
void *hFor; //表达式句柄
$ m2 ?8 a* r! t1 e/ G. [. ]# W
luINT nPara; //存放表达式的自变量个数- m' C7 X5 R\\" M% w6 u9 Q6 Q+ G
LuData *pPara; //存放输入自变量的数组指针$ ^9 O$ w# Q' K% N' U5 U5 \
luINT ErrBegin,ErrEnd; //表达式编译出错的初始位置和结束位置, A. y( k0 ^7 C' w% ]. D% P
int ErrCode; //错误代码
+ `& s( s1 B7 h$ Y- @! k/ l
void *v;- b& R% B, p: N+ D' e3 r
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.]}";//字符串表达式，矩阵乘
! D- U, {2 ^9 [# l
//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 ~8 J* z0 B0 P+ b
LuData Val;
% r. P: N* B0 C6 c
if(!InitLu()) return; //初始化Lu
3 y\\" [/ F. ~/ ^8 B1 R
while(LockKey(Matrix,DelMatrix,OpMatrix)){Matrix++;} //锁定一个键，用于存储矩阵扩展类型' d) H/ }& F0 i/ F\\" C6 @
% R* `! |; W+ \ D1 }
Val.BType=luStaData_int64; Val.VType=luStaData_int64; Val.x=Matrix; //定义整数常量, z6 M$ H1 E# f4 |\\" W/ o! H* F
SetConst(L"matrix",&Val); //设置整数常量
1 p8 G1 r y6 b7 E1 `& |6 K
InsertKey("\0\0\0\0",4,luPubKey_User,LuMessage,NULL,NULL,1,v); //使Lu运行时可输出函数信息/ z/ o0 K7 k. D: O* Q7 c% U* k
wcout.imbue(locale("chs")); //设置输出的locale为中文
, c1 S* e, l$ Q1 N
[0 \3 p1 T- L2 ~5 p1 a; D
ErrCode=LuCom(ForStr,0,0,0,hFor,nPara,pPara,ErrBegin,ErrEnd); //编译表达式
& Q\\" |0 T4 t6 q% ~, x: P
if(ErrCode)
8 ?% V7 ^4 q+ f2 G. ]; R0 w% Z
{
$ a4 B: k, b5 g2 }* u: k( X
wcout<<L"表达式有错误！错误代码："<<ErrCode<<endl;7 v+ v6 u1 }' S2 h5 f1 U
}8 E1 D& O }: W1 a5 ]
else- x4 |& w* y$ g/ A6 Y& g7 x
{1 @8 B7 ?( e) \' @5 z
LuCal(hFor,pPara); //计算表达式的值
: \0 [4 o1 p$ j# d; A: D5 v
}! s3 x6 o7 q, l! e5 J# E4 v
LockKey(Matrix,NULL,OpMatrix);//解锁键Matrix，本例中，该函数可以不用0 p# O* t8 R! e: \- i
FreeLu(); //释放Lu
) `) {3 M, O8 N6 |; n
}

#include <windows.h> 
% ]- s! D. U% T  L
#include <iostream> 
8 d, O1 S+ x7 g% L- ]& x/ W
#include <math.h>! h; p9 ?: A( K# |& X/ ^

#include "lu32.h" 
+ C5 Z) \$ X  Q# `# u  x4 o1 P
 
# X3 V! D2 Z& N( {! R# S$ T+ m
#pragma comment( lib, "lu32.lib" )! [- _! \  b/ G+ k\\" O& R

8 m2 D+ b. z1 a

using namespace std;) r1 G0 V( f/ n

% P; M' ^# U/ J$ v0 E

luKEY Matrix=-1000;        //标识矩阵类型，最终的Matrix由LockKey决定 
5 ^8 z# K% v9 B2 i: x
 
7 i# L/ ^5 [* U7 A6 ~\\" G% D8 |
void _stdcall LuMessage(wchar_t *pch)//输出动态库信息，该函数注册到Lu，由Lu二级函数调用 
( u, N+ |0 q  a- a6 P) l5 l$ d; f
{; a' |% L# M2 {  ]

wcout<<pch;5 ]: d' ]- R4 a4 B

}( ~+ u5 g- R1 ^' g

void _stdcall DelMatrix(void *me)        //用于LockKey函数，因为是基于系统内置实数数组创建矩阵，故该函数什么也不做 
9 k, l, t% L  ^7 A& l* K& i! ~
{ 
; a* y! D+ G2 R7 ^
} 
7 ^& f2 P0 `  D: m
LuData _stdcall OpMatrix(luINT mm,LuData *xx,void *hFor,int theOperator)        //运算符重载函数，用于LockKey函数4 \  ~% q. |) k( P$ C

{ 
8 Q, [8 t( h0 b& e. t
        LuData a;0 W' c& }7 B. v# t) Z6 G8 Y

luRealArray *pRealArray1,*pRealArray2,*pRealArray3;8 \: _, h- ?# v' _) B+ M

luVOID i,j,k,m,n,u,v; 
5 G+ t: `8 Y* g3 p& r. y4 G
        double *pa,*pb,*pc;9 S/ J4 U1 _4 O6 m- Z. k) M

luMessage pMessage; 
4 m, p  W, j1 P* S
        wchar_t wchNum[32];6 E8 _$ `, @7 G\\" q* E& Y

char chNum[32];: D) ]* ^3 Q& |4 \: [6 Y

a.BType=luStaData_nil; a.VType=luStaData_nil; a.x=0;0 F0 J9 d7 B6 t+ [  s\\" e

switch(theOperator) 
& \- E; t7 F3 h5 ?: }1 I& ]2 @1 T
        {# H8 F/ |% \, v2 O( j9 j

case 2:        //重载运算符*% {& P2 @, Q) U. A

pRealArray1=(luRealArray *)SearchKey((char *)&(xx->x),sizeof(luVOID),luDynData_realarray); 
/ Q$ r8 p$ d1 ^$ H/ E
                pRealArray2=(luRealArray *)SearchKey((char *)&((xx+1)->x),sizeof(luVOID),luDynData_realarray);2 O; l4 F  M3 ^; b9 u  I% m$ M% I

if(!pRealArray1 || !pRealArray2) break;        //对象句柄无效，不是实数数组# C$ B7 r* |# i: v  _% ^

if(pRealArray1->DimLen!=2 || pRealArray2->DimLen!=2) break;        //不是二维实数数组（矩阵）; u. y; Z! {: Y7 X

if(pRealArray1->Dim[1]!=pRealArray2->Dim[0]) break;        //维数不匹配& G4 |' v, \5 Q1 {' o7 e5 s2 s

pRealArray3=(luRealArray *)NewSysObj(luDynData_realarray,pRealArray1->Dim[0]*pRealArray2->Dim[1],2);        //创建矩阵对象; G4 c# l6 K5 J' j. U5 W. p% Z

if(!pRealArray3) break;% L\\" c4 X7 D, R- D% `; d

pRealArray3->Dim[0]=pRealArray1->Dim[0]; pRealArray3->Dim[1]=pRealArray2->Dim[1];        //设置矩阵维数大小 
. ?6 b' W. b) \5 m- D% {+ o
                pa=pRealArray1->Array; pb=pRealArray2->Array; pc=pRealArray3->Array; 
4 S- j7 S: @, T' U. w' W
                m=pRealArray1->Dim[0]; n=pRealArray1->Dim[1]; k=pRealArray2->Dim[1];+ |! [; K' U4 `* z. n( v* q

for(i=0; i<m; i++)        //矩阵乘 
. e5 n: e+ j\\" n* Q# a7 V- k
                { 
+ `9 v0 h% V2 U- @2 r0 ^4 C
                        for(j=0; j<k; j++) 
* e5 o! z6 [1 _% j- h$ b
                        { 
3 L: X8 ?' d& l+ I
                                u=i*k+j; pc[u]=0.0;: p$ E8 \  b* N, P# S

for (v=0; v<n; v++) 
8 R  Z; ~: C, x: A% P7 w4 |\\" D- H
                                {9 Q: `2 i6 v9 M

pc[u]=pc[u]+pa[i*n+v]*pb[v*k+j]; 
. N+ y3 c6 X# b, x  o& h
                                } 
/ P* o  K: Y, ?
                        }: y# {3 ~4 `( D; _: X

}+ E% g/ E+ F0 j) r& A7 W6 ]

FunReObj(hFor);        //告诉Lu，返回一个动态对象 
& u/ t) h9 w8 |  w: i- b/ ]# G& r
                a.BType=luDynData_realarray; a.VType=Matrix; a.x=0; *(luVOID *)&(a.x)=(luVOID)pRealArray3;; U6 X+ K1 M8 c5 d\\" r0 N5 I

break;7 c3 h( w4 C0 c

case 25:        //重载运算符.*  |\\" r1 G* g\\" d6 V! R

pRealArray1=(luRealArray *)SearchKey((char *)&(xx->x),sizeof(luVOID),luDynData_realarray);) V  S0 X\\" j\\" B; P

pRealArray2=(luRealArray *)SearchKey((char *)&((xx+1)->x),sizeof(luVOID),luDynData_realarray);) \: c# @: Q\\" N- Q

if(!pRealArray1 || !pRealArray2) break;        //对象句柄无效，不是实数数组 
+ ~* a7 I: a( T/ r
                if(pRealArray1->DimLen!=2 || pRealArray2->DimLen!=2) break;        //不是二维实数数组（矩阵）$ H0 g) N, @# t8 J7 Y1 g

if(pRealArray1->Dim[0]!=pRealArray2->Dim[0] || pRealArray1->Dim[1]!=pRealArray2->Dim[1]) break;        //维数不相同- D/ B5 L# x# B+ T- [4 M

pRealArray3=(luRealArray *)NewSysObj(luDynData_realarray,pRealArray1->ArrayLen,2);        //创建矩阵对象4 \: E. h4 c1 \. _2 m: P% p* P

if(!pRealArray3) break; 
7 G! S1 {' [% u
                pRealArray3->Dim[0]=pRealArray1->Dim[0]; pRealArray3->Dim[1]=pRealArray1->Dim[1];        //设置矩阵维数大小$ B/ J5 ^$ e. E8 c. _) v

for(i=0;i<pRealArray1->ArrayLen;i++) pRealArray3->Array[i]=pRealArray1->Array[i]*pRealArray2->Array[i];//矩阵点乘# N: u7 E% W; `& R' a7 L- x# i0 I

FunReObj(hFor);        //告诉Lu，返回一个动态对象; s' p2 X# y& }3 B% i# n1 E$ D( o  d8 R

a.BType=luDynData_realarray; a.VType=Matrix; a.x=0; *(luVOID *)&(a.x)=(luVOID)pRealArray3; 
# l; ^% P2 V8 ^+ y, {. V/ C
                break;6 z6 Q2 C2 W& q# x% S

case 46:        //重载函数new  B* |0 f6 t4 |* x\\" Y

a=ExeOperator(mm,xx,hFor,theOperator,luDynData_realarray);        //直接调用基本类型luDynData_realarray的new函数 
, U' j3 @, f) N! B$ O\\" j# V, L
                if(a.VType==luDynData_realarray) a.VType=Matrix;        //设置扩展类型为自定义的Matrix类型7 i, O& ~: I0 b$ W6 |% k) i: w+ \

break;9 Q9 d0 P& v. E7 s; ~

case 49:        //重载函数o 
5 i3 n( c! G) K8 p
                pMessage=(luMessage)SearchKey("\0\0\0\0",sizeof(luVOID),luPubKey_User);5 z. r. a+ v% q  |/ |

if(!pMessage) break; 
- P+ y* S8 a: D  S4 Z& |
                pRealArray1=(luRealArray *)SearchKey((char *)&(xx->x),sizeof(luVOID),luDynData_realarray);, X. z4 h$ `7 a. Q' C

if(!pRealArray1) break;        //对象句柄无效，不是实数数组 
0 w% u  V# l5 m
                if(pRealArray1->DimLen!=2) break;        //不是二维实数数组（矩阵） 
! F( q# |: i& N' X
                pa=pRealArray1->Array;7 C1 u' d5 J% e6 {: B

m=pRealArray1->Dim[0]; n=pRealArray1->Dim[1]; k=0; 
% m! R7 v2 A  i0 ?8 {4 ^% h
                for(i=0; i<m; i++)        //输出矩阵2 t/ z5 S8 _! _- d1 ~

{3 a- q3 R- s8 {( l! y

pMessage(L"\r\n"); k+=2;. y9 q6 A/ U2 S( \8 j+ `7 R2 x

for(j=0; j<n; j++) 
  n: p$ p* ]. o& U3 x# F. ]
                        { 
\\" E6 j: o  x5 a. \; n
                                _gcvt_s(chNum,pa[i*n+j],16); 
4 }% x8 ~% J9 M4 e, I) Y
                                for(u=0;chNum[u];u++) {wchNum[u]=chNum[u]; k++;}) j0 X# |: A1 ?9 g) {

wchNum[u]='\0';- l0 ^5 d- ?: p; B

pMessage(wchNum); pMessage(L"  "); k+=2;4 U6 p1 v1 x+ c% E5 P

}6 p+ e* ^) Q  L

}7 G) I# X' B5 }# I, h

pMessage(L"\r\n"); k+=2;2 D+ }3 Z. q+ s# a, d

a.BType=luStaData_int64; a.VType=luStaData_int64; a.x=k;        //按函数o的要求，返回输出的字符总数; }' h: l) W, h

break;8 a\\" X! f0 }+ x- R

default: 
3 J& P& [* b4 F+ g: E) F
                break; 
: ^7 m* T: V3 Z  H% B4 p; S$ \% E& }! v
        }' u- A6 k3 P8 v& Z/ u+ M5 L) V& @

return a;& O5 Y2 k9 J7 ^\\" S, f  `5 h4 W6 c

} 
! s  T+ M+ L3 m3 g, N$ @7 ~
void main(void)9 N' ~7 y$ K) }$ ~# M8 `

{, W5 i; t+ ^$ H  |; U1 f. Y% \

void *hFor;                //表达式句柄 
$ m2 ?8 a* r! t1 e/ G. [. ]# W
        luINT nPara;                //存放表达式的自变量个数- m' C7 X5 R\\" M% w6 u9 Q6 Q+ G

LuData *pPara;                //存放输入自变量的数组指针$ ^9 O$ w# Q' K% N' U5 U5 \

luINT ErrBegin,ErrEnd;        //表达式编译出错的初始位置和结束位置, A. y( k0 ^7 C' w% ]. D% P

int ErrCode;                //错误代码 
+ `& s( s1 B7 h$ Y- @! k/ l
        void *v;- b& R% B, p: N+ D' e3 r

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.]}";//字符串表达式，矩阵乘 
! D- U, {2 ^9 [# l
        //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 ~8 J* z0 B0 P+ b

LuData Val; 
% r. P: N* B0 C6 c
        if(!InitLu()) return;        //初始化Lu 
3 y\\" [/ F. ~/ ^8 B1 R
        while(LockKey(Matrix,DelMatrix,OpMatrix)){Matrix++;}        //锁定一个键，用于存储矩阵扩展类型' d) H/ }& F0 i/ F\\" C6 @

% R* `! |; W+ \  D1 }
        Val.BType=luStaData_int64; Val.VType=luStaData_int64; Val.x=Matrix;        //定义整数常量, z6 M$ H1 E# f4 |\\" W/ o! H* F

SetConst(L"matrix",&Val);        //设置整数常量 
1 p8 G1 r  y6 b7 E1 `& |6 K
        InsertKey("\0\0\0\0",4,luPubKey_User,LuMessage,NULL,NULL,1,v); //使Lu运行时可输出函数信息/ z/ o0 K7 k. D: O* Q7 c% U* k

wcout.imbue(locale("chs"));        //设置输出的locale为中文 
, c1 S* e, l$ Q1 N
   
  [0 \3 p1 T- L2 ~5 p1 a; D
        ErrCode=LuCom(ForStr,0,0,0,hFor,nPara,pPara,ErrBegin,ErrEnd); //编译表达式 
& Q\\" |0 T4 t6 q% ~, x: P
        if(ErrCode) 
8 ?% V7 ^4 q+ f2 G. ]; R0 w% Z
        { 
$ a4 B: k, b5 g2 }* u: k( X
                wcout<<L"表达式有错误！错误代码："<<ErrCode<<endl;7 v+ v6 u1 }' S2 h5 f1 U

}8 E1 D& O  }: W1 a5 ]

else- x4 |& w* y$ g/ A6 Y& g7 x

{1 @8 B7 ?( e) \' @5 z

LuCal(hFor,pPara);        //计算表达式的值 
: \0 [4 o1 p$ j# d; A: D5 v
        }! s3 x6 o7 q, l! e5 J# E4 v

LockKey(Matrix,NULL,OpMatrix);//解锁键Matrix，本例中，该函数可以不用0 p# O* t8 R! e: \- i

FreeLu();                        //释放Lu 
) `) {3 M, O8 N6 |; n
}

习题：

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

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

main(:a,b,c,d,t,i)=
& v( \) R0 ?+ O$ H( U- x\" T- @1 p! g
a=new[matrix,2,2,data:1.,2.,2.,1.],( d2 U: z2 q# J
b=new[matrix,2,2,data:2.,1.,1.,2.],
1 c/ {3 a% w6 A# |
c=new[matrix,2,2,data:2/3.,-1/3.,-1/3.,2/3.],
$ V+ g) {8 f' A y& X5 K: V* G
t=clock(),3 h- ?4 {4 K( F
d=a*b, i=0, while{i<1000000, d=d*c*b, i++},
, t8 g% r* `) }1 v( U
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\"}";//字符串表达式

复制代码

结果：