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

查看: 8823|回复: 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>
0 m& h& V3 U! u4 S, t
#include <iostream>* j. O }/ }% \
#include <math.h>
\\" Q: v8 {0 [# g5 V
#include "lu32.h"
+ t( p2 \+ S4 Q4 W& g) `8 |\\" `
( O. @ T& i: i) T8 N+ k
#pragma comment( lib, "lu32.lib" )
, ]) N, X7 a) h, c9 f
6 a4 J4 V1 \! `* W8 F: ^
using namespace std;0 `+ g- q0 l; k3 z! u* @% I% ?
\\" j; O% {3 r! P# U4 G3 _
luKEY Matrix=-1000; //标识矩阵类型，最终的Matrix由LockKey决定3 q' J2 t0 v4 ~) J
0 N% {5 Z/ u+ a& L
void _stdcall LuMessage(wchar_t *pch)//输出动态库信息，该函数注册到Lu，由Lu二级函数调用 ' m* ]+ Q9 `3 E2 U O
{! G/ o$ y8 a Q7 U2 I
wcout<<pch;, |5 a0 ]6 Q: b* I2 x, y
}8 s' S' o5 M8 t0 {' t, S- P
void _stdcall DelMatrix(void *me) //用于LockKey函数，因为是基于系统内置实数数组创建矩阵，故该函数什么也不做4 l1 q1 W- g$ ]- P. e& i7 r2 M( j) J& Z
{
4 N. ]7 j. @\\" t! I! E: N; [$ t5 E% W
}
G' `* p# y$ c3 ]
LuData _stdcall OpMatrix(luINT mm,LuData *xx,void *hFor,int theOperator) //运算符重载函数，用于LockKey函数 V- B q8 J7 f\\" v\\" U/ R
{' H2 X# r+ b5 |' h! ^
LuData a;2 V) {2 h3 K3 l. X
luRealArray *pRealArray1,*pRealArray2,*pRealArray3;( q' j: H5 l( w; `/ J
luVOID i,j,k,m,n,u,v;
. p4 _* w/ t Q# t& X+ N
double *pa,*pb,*pc;
, B$ k/ o3 L0 N, M3 b b, `
luMessage pMessage;2 U+ P1 X8 {- [
wchar_t wchNum[32];# \1 x' @+ U5 q$ \
char chNum[32];2 N- @& T+ z; F2 l
a.BType=luStaData_nil; a.VType=luStaData_nil; a.x=0;
: l$ v. v! j$ F- N% F1 M* e. y N
switch(theOperator)0 p/ m' `% F+ k( G# b5 Z
{
( s# |' n; r! x7 t
case 2: //重载运算符*
\\" W) t* ^! \: x/ b+ b% w6 [0 J; `
pRealArray1=(luRealArray *)SearchKey((char *)&(xx->x),sizeof(luVOID),luDynData_realarray);
/ O) G4 R% b6 G
pRealArray2=(luRealArray *)SearchKey((char *)&((xx+1)->x),sizeof(luVOID),luDynData_realarray);
8 U5 R \( `5 Q2 j) a8 z\\" t, [
if(!pRealArray1 || !pRealArray2) break; //对象句柄无效，不是实数数组
. E4 f) s: S' O6 k
if(pRealArray1->DimLen!=2 || pRealArray2->DimLen!=2) break; //不是二维实数数组（矩阵）! a. K\\" w$ ~( z4 p% ?9 E& w9 C
if(pRealArray1->Dim[1]!=pRealArray2->Dim[0]) break; //维数不匹配
$ b r* F8 y( o\\" ?- k
pRealArray3=(luRealArray *)NewSysObj(luDynData_realarray,pRealArray1->Dim[0]*pRealArray2->Dim[1],2); //创建矩阵对象
% V1 f& l o4 _4 g& E- ^0 Y
if(!pRealArray3) break;! Q( P7 c. c& k7 w+ f1 I- e3 X, H' u
pRealArray3->Dim[0]=pRealArray1->Dim[0]; pRealArray3->Dim[1]=pRealArray2->Dim[1]; //设置矩阵维数大小
0 t9 z8 l2 Y\\" _8 }+ S! w
pa=pRealArray1->Array; pb=pRealArray2->Array; pc=pRealArray3->Array;
9 g9 }5 P( K. m2 P
m=pRealArray1->Dim[0]; n=pRealArray1->Dim[1]; k=pRealArray2->Dim[1];
! I; D+ L7 D; u5 ?0 ^\\" c
for(i=0; i<m; i++) //矩阵乘\\" f* d8 d Z' F; L. [* a
{
9 p- x. J7 g/ [+ ]/ R) E( P# s
for(j=0; j<k; j++)
# J U/ P. k: P; r8 r! l
{, S# p5 h' @; {+ `0 b
u=i*k+j; pc[u]=0.0;
( V% S4 A; M E4 R$ H- ~
for (v=0; v<n; v++)2 C% r$ }4 u8 m3 o
{
: V# t/ v' D$ |\\" z* D {) o3 m
pc[u]=pc[u]+pa[i*n+v]*pb[v*k+j]; M, i+ j0 h0 K: z- H7 p0 G9 V1 j2 t
}
8 ]0 s/ d5 H5 W
}
: ]- t! G! m5 l5 n
}. [2 i/ a X, q6 w( k
FunReObj(hFor); //告诉Lu，返回一个动态对象3 w7 c4 `$ q\\" o7 K E
a.BType=luDynData_realarray; a.VType=Matrix; a.x=0; *(luVOID *)&(a.x)=(luVOID)pRealArray3;
$ L. ^& `# P$ X& ^$ Q
break;% H\\" I\\" X5 k! i3 j2 v- E: B, s
case 25: //重载运算符.*1 Z: O9 n/ {; j\\" Y* Y% F J
pRealArray1=(luRealArray *)SearchKey((char *)&(xx->x),sizeof(luVOID),luDynData_realarray);% n6 T4 o. `' C/ l4 a; |
pRealArray2=(luRealArray *)SearchKey((char *)&((xx+1)->x),sizeof(luVOID),luDynData_realarray);
: p8 m3 K' \* m4 W
if(!pRealArray1 || !pRealArray2) break; //对象句柄无效，不是实数数组- e% i# T- H: ?( W
if(pRealArray1->DimLen!=2 || pRealArray2->DimLen!=2) break; //不是二维实数数组（矩阵）
6 j9 F$ T& r0 Y' p1 Z( ^/ [. E6 E\\" r
if(pRealArray1->Dim[0]!=pRealArray2->Dim[0] || pRealArray1->Dim[1]!=pRealArray2->Dim[1]) break; //维数不相同
K; Z- }7 a+ [ g. O
pRealArray3=(luRealArray *)NewSysObj(luDynData_realarray,pRealArray1->ArrayLen,2); //创建矩阵对象* [5 J7 s, ~& }; }- q
if(!pRealArray3) break;
; l; z8 U) A. {& T
pRealArray3->Dim[0]=pRealArray1->Dim[0]; pRealArray3->Dim[1]=pRealArray1->Dim[1]; //设置矩阵维数大小
5 {+ O9 \' L5 {4 [& Z
for(i=0;i<pRealArray1->ArrayLen;i++) pRealArray3->Array[i]=pRealArray1->Array[i]*pRealArray2->Array[i];//矩阵点乘2 O( O$ F9 ^, Z n
FunReObj(hFor); //告诉Lu，返回一个动态对象! ~* D! r& e$ k+ F, h$ w
a.BType=luDynData_realarray; a.VType=Matrix; a.x=0; *(luVOID *)&(a.x)=(luVOID)pRealArray3;
* }1 s2 |0 Z, X/ m- Y
break;
0 t, Q# [' u) h
case 46: //重载函数new
9 p4 t: X2 j% w0 x2 v0 j3 o* b
a=ExeOperator(mm,xx,hFor,theOperator,luDynData_realarray); //直接调用基本类型luDynData_realarray的new函数
; M6 h& b, ~# O F# r; H! T/ r
if(a.VType==luDynData_realarray) a.VType=Matrix; //设置扩展类型为自定义的Matrix类型
% O; X; R$ f8 Z9 n
break;3 d- A; Q6 F' S, H
case 49: //重载函数o
( j3 a4 c! q' y- v
pMessage=(luMessage)SearchKey("\0\0\0\0",sizeof(luVOID),luPubKey_User);/ Z+ r8 ^% i& I, s! @' z
if(!pMessage) break;% Q, ?6 S6 ~! X
pRealArray1=(luRealArray *)SearchKey((char *)&(xx->x),sizeof(luVOID),luDynData_realarray);0 t! V G( w( b8 {5 s# X. g
if(!pRealArray1) break; //对象句柄无效，不是实数数组$ Y+ d, R( Q9 e6 n/ f
if(pRealArray1->DimLen!=2) break; //不是二维实数数组（矩阵）% j# J$ e; m& D
pa=pRealArray1->Array;
! T m2 u5 S\\" |
m=pRealArray1->Dim[0]; n=pRealArray1->Dim[1]; k=0;
$ d4 h* j$ {9 _2 m0 h$ w
for(i=0; i<m; i++) //输出矩阵
( F$ \5 f! O3 M) e
{
& n6 i\\" T7 f! u( J- ?
pMessage(L"\r\n"); k+=2;
3 J1 z8 s* ?\\" h! b
for(j=0; j<n; j++)
$ r: Q2 o\\" l. s. f9 I x2 L
{2 c1 t$ a, c+ H7 u0 k) a: J4 H
_gcvt_s(chNum,pa[i*n+j],16);
& d7 x; U# G7 d- S5 t7 k4 e
for(u=0;chNum[u];u++) {wchNum[u]=chNum[u]; k++;}
( v) O; A8 v& e$ n' }4 ]2 Q
wchNum[u]='\0';: U+ p \' M# _+ z# z& \
pMessage(wchNum); pMessage(L" "); k+=2;
2 }, {; X9 i+ M% F! v
}
; Q) d- d4 v4 ^! u, i/ |' s
}. ^% l$ f* S* e: W: d1 S4 X* T4 y
pMessage(L"\r\n"); k+=2;( W6 Y; d& ~/ }
a.BType=luStaData_int64; a.VType=luStaData_int64; a.x=k; //按函数o的要求，返回输出的字符总数
& ^, j& H, B) Y+ z) d1 E
break;, I8 b6 U& o! m/ v
default:
9 w {& }+ Q\\" [
break;
( }. `9 d8 V/ y; A8 y
}$ R7 |* b; k% z( {& `
return a;
. _$ i7 t/ r# w
}: J8 u, g6 |% w$ w* _$ b# s7 D
void main(void), K7 y- t) R5 l6 m
{
\\" v' x9 x8 u* h! x3 F8 ?. G. f
void *hFor; //表达式句柄* H' O! G Q* U9 A+ |
luINT nPara; //存放表达式的自变量个数
2 i% L$ k+ u/ X. N
LuData *pPara; //存放输入自变量的数组指针
/ W7 [2 [1 P\\" J( |$ ~4 Q4 T
luINT ErrBegin,ErrEnd; //表达式编译出错的初始位置和结束位置
$ D, D. F+ J: l$ b) i
int ErrCode; //错误代码. s- B7 C1 q+ X7 O* F3 T+ W6 F\\" V' l
void *v;
\\" F, o; n8 ?; T1 Y
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.]}";//字符串表达式，矩阵乘
$ S* t) J9 H- f& K0 d' y, _7 c# y
//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 R# Z+ h4 d6 x0 ?( V8 Q, U
LuData Val;
6 o& W& c! a0 ^! ~$ C
if(!InitLu()) return; //初始化Lu
6 R5 n1 o) `/ I0 y: U4 w/ e m
while(LockKey(Matrix,DelMatrix,OpMatrix)){Matrix++;} //锁定一个键，用于存储矩阵扩展类型4 C8 Q# ]( H4 J) o1 e2 e: ?
' o+ u( M6 `8 F0 a1 H
Val.BType=luStaData_int64; Val.VType=luStaData_int64; Val.x=Matrix; //定义整数常量
# g3 ]# n' }8 \2 Y% g
SetConst(L"matrix",&Val); //设置整数常量' E8 B' h* P& Z: _6 l: y9 T y
InsertKey("\0\0\0\0",4,luPubKey_User,LuMessage,NULL,NULL,1,v); //使Lu运行时可输出函数信息8 V: |\\" x6 B$ w% z\\" Z6 x9 A2 E
wcout.imbue(locale("chs")); //设置输出的locale为中文
- d\\" p8 J( B* t ]
+ z9 k( w- I# N5 y$ W
ErrCode=LuCom(ForStr,0,0,0,hFor,nPara,pPara,ErrBegin,ErrEnd); //编译表达式
7 B; w; p/ E2 s! b# y2 ]6 a4 e& n
if(ErrCode)6 e* z. k1 E1 U3 l: o: Z
{\\" s. G- |; A9 A% c5 t
wcout<<L"表达式有错误！错误代码："<<ErrCode<<endl;8 c- x6 O: ]+ Q+ M; C* d* I3 d
}
9 v\\" |. A+ r+ ]! x
else4 A6 P/ C0 u; T7 W
{1 K0 I; P! ?9 k8 q6 q2 E4 i D0 F
LuCal(hFor,pPara); //计算表达式的值$ s, [- o1 z1 W% W2 N& ^9 ~! H
}
& t: ~( I. u I7 p5 m
LockKey(Matrix,NULL,OpMatrix);//解锁键Matrix，本例中，该函数可以不用
0 H+ d- E+ L9 h8 P$ J& N9 A
FreeLu(); //释放Lu3 R* X7 P$ `/ o
}

#include <windows.h> 
0 m& h& V3 U! u4 S, t
#include <iostream>* j. O  }/ }% \

#include <math.h> 
\\" Q: v8 {0 [# g5 V
#include "lu32.h" 
+ t( p2 \+ S4 Q4 W& g) `8 |\\" `
 
( O. @  T& i: i) T8 N+ k
#pragma comment( lib, "lu32.lib" ) 
, ]) N, X7 a) h, c9 f
 
6 a4 J4 V1 \! `* W8 F: ^
using namespace std;0 `+ g- q0 l; k3 z! u* @% I% ?

\\" j; O% {3 r! P# U4 G3 _

luKEY Matrix=-1000;        //标识矩阵类型，最终的Matrix由LockKey决定3 q' J2 t0 v4 ~) J

0 N% {5 Z/ u+ a& L
void _stdcall LuMessage(wchar_t *pch)//输出动态库信息，该函数注册到Lu，由Lu二级函数调用 ' m* ]+ Q9 `3 E2 U  O

{! G/ o$ y8 a  Q7 U2 I

wcout<<pch;, |5 a0 ]6 Q: b* I2 x, y

}8 s' S' o5 M8 t0 {' t, S- P

void _stdcall DelMatrix(void *me)        //用于LockKey函数，因为是基于系统内置实数数组创建矩阵，故该函数什么也不做4 l1 q1 W- g$ ]- P. e& i7 r2 M( j) J& Z

{ 
4 N. ]7 j. @\\" t! I! E: N; [$ t5 E% W
} 
  G' `* p# y$ c3 ]
LuData _stdcall OpMatrix(luINT mm,LuData *xx,void *hFor,int theOperator)        //运算符重载函数，用于LockKey函数  V- B  q8 J7 f\\" v\\" U/ R

{' H2 X# r+ b5 |' h! ^

LuData a;2 V) {2 h3 K3 l. X

luRealArray *pRealArray1,*pRealArray2,*pRealArray3;( q' j: H5 l( w; `/ J

luVOID i,j,k,m,n,u,v; 
. p4 _* w/ t  Q# t& X+ N
        double *pa,*pb,*pc; 
, B$ k/ o3 L0 N, M3 b  b, `
        luMessage pMessage;2 U+ P1 X8 {- [

wchar_t wchNum[32];# \1 x' @+ U5 q$ \

char chNum[32];2 N- @& T+ z; F2 l

a.BType=luStaData_nil; a.VType=luStaData_nil; a.x=0; 
: l$ v. v! j$ F- N% F1 M* e. y  N
        switch(theOperator)0 p/ m' `% F+ k( G# b5 Z

{ 
( s# |' n; r! x7 t
        case 2:        //重载运算符* 
\\" W) t* ^! \: x/ b+ b% w6 [0 J; `
                pRealArray1=(luRealArray *)SearchKey((char *)&(xx->x),sizeof(luVOID),luDynData_realarray); 
/ O) G4 R% b6 G
                pRealArray2=(luRealArray *)SearchKey((char *)&((xx+1)->x),sizeof(luVOID),luDynData_realarray); 
8 U5 R  \( `5 Q2 j) a8 z\\" t, [
                if(!pRealArray1 || !pRealArray2) break;        //对象句柄无效，不是实数数组 
. E4 f) s: S' O6 k
                if(pRealArray1->DimLen!=2 || pRealArray2->DimLen!=2) break;        //不是二维实数数组（矩阵）! a. K\\" w$ ~( z4 p% ?9 E& w9 C

if(pRealArray1->Dim[1]!=pRealArray2->Dim[0]) break;        //维数不匹配 
$ b  r* F8 y( o\\" ?- k
                pRealArray3=(luRealArray *)NewSysObj(luDynData_realarray,pRealArray1->Dim[0]*pRealArray2->Dim[1],2);        //创建矩阵对象 
% V1 f& l  o4 _4 g& E- ^0 Y
                if(!pRealArray3) break;! Q( P7 c. c& k7 w+ f1 I- e3 X, H' u

pRealArray3->Dim[0]=pRealArray1->Dim[0]; pRealArray3->Dim[1]=pRealArray2->Dim[1];        //设置矩阵维数大小 
0 t9 z8 l2 Y\\" _8 }+ S! w
                pa=pRealArray1->Array; pb=pRealArray2->Array; pc=pRealArray3->Array; 
9 g9 }5 P( K. m2 P
                m=pRealArray1->Dim[0]; n=pRealArray1->Dim[1]; k=pRealArray2->Dim[1]; 
! I; D+ L7 D; u5 ?0 ^\\" c
                for(i=0; i<m; i++)        //矩阵乘\\" f* d8 d  Z' F; L. [* a

{ 
9 p- x. J7 g/ [+ ]/ R) E( P# s
                        for(j=0; j<k; j++) 
# J  U/ P. k: P; r8 r! l
                        {, S# p5 h' @; {+ `0 b

u=i*k+j; pc[u]=0.0; 
( V% S4 A; M  E4 R$ H- ~
                                for (v=0; v<n; v++)2 C% r$ }4 u8 m3 o

{ 
: V# t/ v' D$ |\\" z* D  {) o3 m
                                        pc[u]=pc[u]+pa[i*n+v]*pb[v*k+j];  M, i+ j0 h0 K: z- H7 p0 G9 V1 j2 t

} 
8 ]0 s/ d5 H5 W
                        } 
: ]- t! G! m5 l5 n
                }. [2 i/ a  X, q6 w( k

FunReObj(hFor);        //告诉Lu，返回一个动态对象3 w7 c4 `$ q\\" o7 K  E

a.BType=luDynData_realarray; a.VType=Matrix; a.x=0; *(luVOID *)&(a.x)=(luVOID)pRealArray3; 
$ L. ^& `# P$ X& ^$ Q
                break;% H\\" I\\" X5 k! i3 j2 v- E: B, s

case 25:        //重载运算符.*1 Z: O9 n/ {; j\\" Y* Y% F  J

pRealArray1=(luRealArray *)SearchKey((char *)&(xx->x),sizeof(luVOID),luDynData_realarray);% n6 T4 o. `' C/ l4 a; |

pRealArray2=(luRealArray *)SearchKey((char *)&((xx+1)->x),sizeof(luVOID),luDynData_realarray); 
: p8 m3 K' \* m4 W
                if(!pRealArray1 || !pRealArray2) break;        //对象句柄无效，不是实数数组- e% i# T- H: ?( W

if(pRealArray1->DimLen!=2 || pRealArray2->DimLen!=2) break;        //不是二维实数数组（矩阵） 
6 j9 F$ T& r0 Y' p1 Z( ^/ [. E6 E\\" r
                if(pRealArray1->Dim[0]!=pRealArray2->Dim[0] || pRealArray1->Dim[1]!=pRealArray2->Dim[1]) break;        //维数不相同 
  K; Z- }7 a+ [  g. O
                pRealArray3=(luRealArray *)NewSysObj(luDynData_realarray,pRealArray1->ArrayLen,2);        //创建矩阵对象* [5 J7 s, ~& }; }- q

if(!pRealArray3) break; 
; l; z8 U) A. {& T
                pRealArray3->Dim[0]=pRealArray1->Dim[0]; pRealArray3->Dim[1]=pRealArray1->Dim[1];        //设置矩阵维数大小 
5 {+ O9 \' L5 {4 [& Z
                for(i=0;i<pRealArray1->ArrayLen;i++) pRealArray3->Array[i]=pRealArray1->Array[i]*pRealArray2->Array[i];//矩阵点乘2 O( O$ F9 ^, Z  n

FunReObj(hFor);        //告诉Lu，返回一个动态对象! ~* D! r& e$ k+ F, h$ w

a.BType=luDynData_realarray; a.VType=Matrix; a.x=0; *(luVOID *)&(a.x)=(luVOID)pRealArray3; 
* }1 s2 |0 Z, X/ m- Y
                break; 
0 t, Q# [' u) h
        case 46:        //重载函数new 
9 p4 t: X2 j% w0 x2 v0 j3 o* b
                a=ExeOperator(mm,xx,hFor,theOperator,luDynData_realarray);        //直接调用基本类型luDynData_realarray的new函数 
; M6 h& b, ~# O  F# r; H! T/ r
                if(a.VType==luDynData_realarray) a.VType=Matrix;        //设置扩展类型为自定义的Matrix类型 
% O; X; R$ f8 Z9 n
                break;3 d- A; Q6 F' S, H

case 49:        //重载函数o 
( j3 a4 c! q' y- v
                pMessage=(luMessage)SearchKey("\0\0\0\0",sizeof(luVOID),luPubKey_User);/ Z+ r8 ^% i& I, s! @' z

if(!pMessage) break;% Q, ?6 S6 ~! X

pRealArray1=(luRealArray *)SearchKey((char *)&(xx->x),sizeof(luVOID),luDynData_realarray);0 t! V  G( w( b8 {5 s# X. g

if(!pRealArray1) break;        //对象句柄无效，不是实数数组$ Y+ d, R( Q9 e6 n/ f

if(pRealArray1->DimLen!=2) break;        //不是二维实数数组（矩阵）% j# J$ e; m& D

pa=pRealArray1->Array; 
! T  m2 u5 S\\" |
                m=pRealArray1->Dim[0]; n=pRealArray1->Dim[1]; k=0; 
$ d4 h* j$ {9 _2 m0 h$ w
                for(i=0; i<m; i++)        //输出矩阵 
( F$ \5 f! O3 M) e
                { 
& n6 i\\" T7 f! u( J- ?
                        pMessage(L"\r\n"); k+=2; 
3 J1 z8 s* ?\\" h! b
                        for(j=0; j<n; j++) 
$ r: Q2 o\\" l. s. f9 I  x2 L
                        {2 c1 t$ a, c+ H7 u0 k) a: J4 H

_gcvt_s(chNum,pa[i*n+j],16); 
& d7 x; U# G7 d- S5 t7 k4 e
                                for(u=0;chNum[u];u++) {wchNum[u]=chNum[u]; k++;} 
( v) O; A8 v& e$ n' }4 ]2 Q
                                wchNum[u]='\0';: U+ p  \' M# _+ z# z& \

pMessage(wchNum); pMessage(L"  "); k+=2; 
2 }, {; X9 i+ M% F! v
                        } 
; Q) d- d4 v4 ^! u, i/ |' s
                }. ^% l$ f* S* e: W: d1 S4 X* T4 y

pMessage(L"\r\n"); k+=2;( W6 Y; d& ~/ }

a.BType=luStaData_int64; a.VType=luStaData_int64; a.x=k;        //按函数o的要求，返回输出的字符总数 
& ^, j& H, B) Y+ z) d1 E
                break;, I8 b6 U& o! m/ v

default: 
9 w  {& }+ Q\\" [
                break; 
( }. `9 d8 V/ y; A8 y
        }$ R7 |* b; k% z( {& `

return a; 
. _$ i7 t/ r# w
}: J8 u, g6 |% w$ w* _$ b# s7 D

void main(void), K7 y- t) R5 l6 m

{ 
\\" v' x9 x8 u* h! x3 F8 ?. G. f
        void *hFor;                //表达式句柄* H' O! G  Q* U9 A+ |

luINT nPara;                //存放表达式的自变量个数 
2 i% L$ k+ u/ X. N
        LuData *pPara;                //存放输入自变量的数组指针 
/ W7 [2 [1 P\\" J( |$ ~4 Q4 T
        luINT ErrBegin,ErrEnd;        //表达式编译出错的初始位置和结束位置 
$ D, D. F+ J: l$ b) i
        int ErrCode;                //错误代码. s- B7 C1 q+ X7 O* F3 T+ W6 F\\" V' l

void *v; 
\\" F, o; n8 ?; T1 Y
        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.]}";//字符串表达式，矩阵乘 
$ S* t) J9 H- f& K0 d' y, _7 c# y
        //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 R# Z+ h4 d6 x0 ?( V8 Q, U

LuData Val; 
6 o& W& c! a0 ^! ~$ C
        if(!InitLu()) return;        //初始化Lu 
6 R5 n1 o) `/ I0 y: U4 w/ e  m
        while(LockKey(Matrix,DelMatrix,OpMatrix)){Matrix++;}        //锁定一个键，用于存储矩阵扩展类型4 C8 Q# ]( H4 J) o1 e2 e: ?

' o+ u( M6 `8 F0 a1 H

Val.BType=luStaData_int64; Val.VType=luStaData_int64; Val.x=Matrix;        //定义整数常量 
# g3 ]# n' }8 \2 Y% g
        SetConst(L"matrix",&Val);        //设置整数常量' E8 B' h* P& Z: _6 l: y9 T  y

InsertKey("\0\0\0\0",4,luPubKey_User,LuMessage,NULL,NULL,1,v); //使Lu运行时可输出函数信息8 V: |\\" x6 B$ w% z\\" Z6 x9 A2 E

wcout.imbue(locale("chs"));        //设置输出的locale为中文 
- d\\" p8 J( B* t  ]
   
+ z9 k( w- I# N5 y$ W
        ErrCode=LuCom(ForStr,0,0,0,hFor,nPara,pPara,ErrBegin,ErrEnd); //编译表达式 
7 B; w; p/ E2 s! b# y2 ]6 a4 e& n
        if(ErrCode)6 e* z. k1 E1 U3 l: o: Z

{\\" s. G- |; A9 A% c5 t

wcout<<L"表达式有错误！错误代码："<<ErrCode<<endl;8 c- x6 O: ]+ Q+ M; C* d* I3 d

} 
9 v\\" |. A+ r+ ]! x
        else4 A6 P/ C0 u; T7 W

{1 K0 I; P! ?9 k8 q6 q2 E4 i  D0 F

LuCal(hFor,pPara);        //计算表达式的值$ s, [- o1 z1 W% W2 N& ^9 ~! H

} 
& t: ~( I. u  I7 p5 m
        LockKey(Matrix,NULL,OpMatrix);//解锁键Matrix，本例中，该函数可以不用 
0 H+ d- E+ L9 h8 P$ J& N9 A
        FreeLu();                        //释放Lu3 R* X7 P$ `/ o

}

习题：

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

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

main(:a,b,c,d,t,i)=# ~, H- F+ k2 R% L) O
a=new[matrix,2,2,data:1.,2.,2.,1.],
# B2 u. d$ A6 W. u
b=new[matrix,2,2,data:2.,1.,1.,2.],
% ]4 f! `+ I0 v9 \
c=new[matrix,2,2,data:2/3.,-1/3.,-1/3.,2/3.],
3 ^- ~& o A, g* Z
t=clock(),. R C! G/ C. c5 n; E8 a1 w
d=a*b, i=0, while{i<1000000, d=d*c*b, i++},8 u% T/ j5 F6 k/ C
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\"}";//字符串表达式

复制代码

结果：