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

查看: 7581|回复: 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>
* z! V% g3 T$ J
#include <iostream>
4 y# @; F% y( r. D\\" T( ~; Z
#include <math.h>) V( B3 M7 Z8 v& ^6 a! N; T- Y& y
#include "lu32.h"/ U p4 {3 H# s) F1 l1 s
. A2 u M6 E1 G d
#pragma comment( lib, "lu32.lib" )' z. G4 w. y% Y) A+ U- C
6 X+ c1 h4 C/ u) t& B6 ^
using namespace std;$ _* K9 |; }8 |# B* ]7 B g
% c; [+ |& j% [4 Q1 h( p
luKEY Matrix=-1000; //标识矩阵类型，最终的Matrix由LockKey决定 S `3 F% Z- i# Y' F1 x8 I0 M
/ D: _. ^) M& T1 ~8 A
void _stdcall LuMessage(wchar_t *pch)//输出动态库信息，该函数注册到Lu，由Lu二级函数调用
\\" A( v, j' F4 d2 \\\" O ]
{1 y2 O+ b# M% K8 K0 u
wcout<<pch;
, Z2 J' y3 N, n; K0 E
}
* A; F' \6 m9 ^5 D$ F% q/ ~; p
void _stdcall DelMatrix(void *me) //用于LockKey函数，因为是基于系统内置实数数组创建矩阵，故该函数什么也不做
0 a# U# ]( T( g* O4 U
{\\" E2 R, ^$ L, B- j
}
& x) j0 [4 c5 U; `) ]
LuData _stdcall OpMatrix(luINT mm,LuData *xx,void *hFor,int theOperator) //运算符重载函数，用于LockKey函数
+ q' S, S' I/ ?! C
{8 K, w* g ], d/ Z0 e' V& |3 C
LuData a;\\" C$ e/ P; X0 s3 N
luRealArray *pRealArray1,*pRealArray2,*pRealArray3;
luVOID i,j,k,m,n,u,v;& u) N( W! e' s6 a
double *pa,*pb,*pc;
5 p7 C' f5 }) ~: T0 d& T3 w
luMessage pMessage;
: q1 H! M2 {$ Z9 u1 U
wchar_t wchNum[32];
/ m' b$ u* m& j% Q& s3 u0 {- \: \
char chNum[32];& r8 b' z3 K% l' \9 b
a.BType=luStaData_nil; a.VType=luStaData_nil; a.x=0;( ?. x1 D( C\\" n% B# l. V: ~
switch(theOperator)) C9 P; m6 p E* c
{
; N. J2 J$ v& [( e, x
case 2: //重载运算符*$ A2 P: v+ l8 a5 M9 |. x/ U( {: `5 H
pRealArray1=(luRealArray *)SearchKey((char *)&(xx->x),sizeof(luVOID),luDynData_realarray);2 [: z8 n5 V% ], m& X! M$ j6 H
pRealArray2=(luRealArray *)SearchKey((char *)&((xx+1)->x),sizeof(luVOID),luDynData_realarray);
% z. f; y, Y8 [, n8 N# ]
if(!pRealArray1 || !pRealArray2) break; //对象句柄无效，不是实数数组
Q\\" |( I* D+ @
if(pRealArray1->DimLen!=2 || pRealArray2->DimLen!=2) break; //不是二维实数数组（矩阵）
; R\\" n7 w1 C# Z3 u3 O U2 V
if(pRealArray1->Dim[1]!=pRealArray2->Dim[0]) break; //维数不匹配
8 J: N7 L- F+ J8 R
pRealArray3=(luRealArray *)NewSysObj(luDynData_realarray,pRealArray1->Dim[0]*pRealArray2->Dim[1],2); //创建矩阵对象 `9 ~+ D; u* G2 }& f; ~$ u4 n9 P$ _: p
if(!pRealArray3) break;3 [5 S! s, |: G8 {0 h2 ^! Z' {
pRealArray3->Dim[0]=pRealArray1->Dim[0]; pRealArray3->Dim[1]=pRealArray2->Dim[1]; //设置矩阵维数大小
1 p+ w( k# G9 a4 U o
pa=pRealArray1->Array; pb=pRealArray2->Array; pc=pRealArray3->Array;( w. o8 `; H4 {( v' N
m=pRealArray1->Dim[0]; n=pRealArray1->Dim[1]; k=pRealArray2->Dim[1];
6 |\\" _9 ~5 s) K. X5 j
for(i=0; i<m; i++) //矩阵乘
0 B% M: Y2 O8 a
{
3 Q0 q5 u+ s: d7 z
for(j=0; j<k; j++); a8 \: R1 v; }
{& p8 `- t' ^1 X) @0 w
u=i*k+j; pc[u]=0.0;% `+ k# |& n/ d6 f, v- v7 m
for (v=0; v<n; v++)
( \0 _) f1 ~+ A# } P
{) |1 G+ S0 ^3 V z/ x
pc[u]=pc[u]+pa[i*n+v]*pb[v*k+j];
o. q8 t) H7 l% _
}; b# W& b5 t+ L# j+ n% S9 `9 t. ?
}5 E3 j+ A1 S\\" Z1 Y- w$ L$ A* L6 @
}
% U* c x3 @; h7 l
FunReObj(hFor); //告诉Lu，返回一个动态对象
& z5 x P: p. |9 r
a.BType=luDynData_realarray; a.VType=Matrix; a.x=0; *(luVOID *)&(a.x)=(luVOID)pRealArray3;
$ J; f; \* N1 f l, D k
break;0 u* J- W) p3 T* D/ q; E
case 25: //重载运算符.*, ?$ g' P t4 V8 I# x, w
pRealArray1=(luRealArray *)SearchKey((char *)&(xx->x),sizeof(luVOID),luDynData_realarray);
/ Z7 z; F; C9 G% @0 y
pRealArray2=(luRealArray *)SearchKey((char *)&((xx+1)->x),sizeof(luVOID),luDynData_realarray); h! ~# e7 L, Q9 h0 P$ |
if(!pRealArray1 || !pRealArray2) break; //对象句柄无效，不是实数数组
I. L/ l' A; ~0 r3 ?8 p
if(pRealArray1->DimLen!=2 || pRealArray2->DimLen!=2) break; //不是二维实数数组（矩阵）! ~: m5 J2 O$ p
if(pRealArray1->Dim[0]!=pRealArray2->Dim[0] || pRealArray1->Dim[1]!=pRealArray2->Dim[1]) break; //维数不相同
4 M% P/ `; m- P4 \
pRealArray3=(luRealArray *)NewSysObj(luDynData_realarray,pRealArray1->ArrayLen,2); //创建矩阵对象; N: t( c% V3 f' @( K4 c7 Y
if(!pRealArray3) break;% x& b8 W\\" V2 U8 D2 U! W
pRealArray3->Dim[0]=pRealArray1->Dim[0]; pRealArray3->Dim[1]=pRealArray1->Dim[1]; //设置矩阵维数大小1 O) r* Z& { U9 ]. A\\" m. t
for(i=0;i<pRealArray1->ArrayLen;i++) pRealArray3->Array[i]=pRealArray1->Array[i]*pRealArray2->Array[i];//矩阵点乘7 U0 O4 K9 x& |7 e
FunReObj(hFor); //告诉Lu，返回一个动态对象
' N/ n* o4 K+ @# Q7 W% f' E
a.BType=luDynData_realarray; a.VType=Matrix; a.x=0; *(luVOID *)&(a.x)=(luVOID)pRealArray3;) a U$ @% |0 R$ E\\" E
break; \, i; c {; U\\" u' E7 N
case 46: //重载函数new
' O& L/ |9 L7 H$ r- }
a=ExeOperator(mm,xx,hFor,theOperator,luDynData_realarray); //直接调用基本类型luDynData_realarray的new函数
, Z! g' L2 W Y c7 I
if(a.VType==luDynData_realarray) a.VType=Matrix; //设置扩展类型为自定义的Matrix类型
9 J9 \: | c- u# A( T* a x
break;
$ C7 n z6 {# ~: S( T' n
case 49: //重载函数o
. p/ ^\\" g- [+ @9 P$ b
pMessage=(luMessage)SearchKey("\0\0\0\0",sizeof(luVOID),luPubKey_User);
z0 J9 y; v- ]0 L! L# y$ f* c e
if(!pMessage) break;
, A7 X( _6 Q6 w4 V
pRealArray1=(luRealArray *)SearchKey((char *)&(xx->x),sizeof(luVOID),luDynData_realarray);
$ c: j/ N, f4 h$ q\\" s# t9 m
if(!pRealArray1) break; //对象句柄无效，不是实数数组
! U# M\\" Z1 t: m9 e8 u
if(pRealArray1->DimLen!=2) break; //不是二维实数数组（矩阵）
\\" I+ t% y7 s- [7 J3 ^# O
pa=pRealArray1->Array;
8 ?+ _3 U8 ~6 V* j0 [: h3 ?
m=pRealArray1->Dim[0]; n=pRealArray1->Dim[1]; k=0;+ Z: h) W ~, }
for(i=0; i<m; i++) //输出矩阵\\" v8 n' n7 N& u# x. H6 b
{
7 ~8 o! g# t& B6 B
pMessage(L"\r\n"); k+=2;
5 i- b# f9 {: U9 H
for(j=0; j<n; j++)8 e+ J# H' U5 o8 I
{4 p& Z5 v. l( l5 p0 k* P n% R6 G
_gcvt_s(chNum,pa[i*n+j],16);& H: \6 |/ n3 v& W/ E2 d) P
for(u=0;chNum[u];u++) {wchNum[u]=chNum[u]; k++;}
6 L5 L0 q- u3 b v3 T; b5 ?& t5 [
wchNum[u]='\0';/ f# B9 V, a; m/ i, O. E
pMessage(wchNum); pMessage(L" "); k+=2;
6 I\\" K2 Z$ `! g4 \
}
; K4 ~1 B {& S- j- r* N6 [: [# ^
}2 Y- L: b: ^5 e( M$ f' C9 Q
pMessage(L"\r\n"); k+=2;
. p5 Z* U\\" t4 I$ a\\" _+ A
a.BType=luStaData_int64; a.VType=luStaData_int64; a.x=k; //按函数o的要求，返回输出的字符总数
- W1 m/ ^* e\\" R& u) D8 {/ D
break;
( P3 O+ n% T0 W+ j
default:6 J1 v Q) x4 X6 E1 V
break;$ }9 J/ p3 y( H& u3 A, K! f! b
}1 L: Y! ]; B+ Z( H1 m
return a;+ N7 s$ D* D) d\\" d9 P
}) w- g2 N' C0 ]7 z
void main(void)
$ `\\" s0 G! K. v1 c6 j, s. ]
{& ~# E/ R- W- F8 t6 ]
void *hFor; //表达式句柄/ j5 u. y: v; N5 I
luINT nPara; //存放表达式的自变量个数
( b3 f5 q/ k b% ^. u- F$ \& m
LuData *pPara; //存放输入自变量的数组指针
9 r' B4 a( U% S: P' {$ d: n
luINT ErrBegin,ErrEnd; //表达式编译出错的初始位置和结束位置% z' c7 ~) Q- v/ }7 }& l
int ErrCode; //错误代码
& Y& f2 D$ E: D3 l, l' @* D
void *v;; T& V: l; P( A1 \
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.]}";//字符串表达式，矩阵乘
1 G1 Y, X! @' t
//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.]}";//字符串表达式，矩阵点乘: l: {; B) b' n4 B8 }4 \
LuData Val;; n! K( K8 e1 l3 E
if(!InitLu()) return; //初始化Lu5 X0 u\\" W1 e d4 ~2 H {& F) ]5 q- o1 r
while(LockKey(Matrix,DelMatrix,OpMatrix)){Matrix++;} //锁定一个键，用于存储矩阵扩展类型+ Q% @5 I q& y- x2 C
5 z% P- n# e3 D6 B
Val.BType=luStaData_int64; Val.VType=luStaData_int64; Val.x=Matrix; //定义整数常量# `& r; J. |# H& x! [- V
SetConst(L"matrix",&Val); //设置整数常量
9 w/ f G: ~$ L1 `( z& I% Z
InsertKey("\0\0\0\0",4,luPubKey_User,LuMessage,NULL,NULL,1,v); //使Lu运行时可输出函数信息% i* ]5 O) [! T/ u\\" m5 z
wcout.imbue(locale("chs")); //设置输出的locale为中文( R\\" [+ u6 g) y5 C
6 g% j0 k2 L: W5 p! V, I; Z; [
ErrCode=LuCom(ForStr,0,0,0,hFor,nPara,pPara,ErrBegin,ErrEnd); //编译表达式& D& z- s! \3 v! n# X6 u, x+ ?
if(ErrCode)
, B$ D* a3 @0 b! |
{6 R6 k, C9 d3 p/ A9 b
wcout<<L"表达式有错误！错误代码："<<ErrCode<<endl;
\\" K. d7 p. f- b* x\\" t5 o9 ~
}% N i7 k4 s, ]; U+ g0 ]
else3 \9 e, H( u3 Z$ S
{' q/ a! }- g\\" L1 B' ?
LuCal(hFor,pPara); //计算表达式的值6 d$ D) P0 e. B3 ^- ?
}
1 @/ j\\" B8 b0 s3 ~( ^
LockKey(Matrix,NULL,OpMatrix);//解锁键Matrix，本例中，该函数可以不用3 E$ V- C/ F* E/ t# ?1 y
FreeLu(); //释放Lu
5 G1 ~. d3 f. @& N
}

#include <windows.h> 
* z! V% g3 T$ J
#include <iostream> 
4 y# @; F% y( r. D\\" T( ~; Z
#include <math.h>) V( B3 M7 Z8 v& ^6 a! N; T- Y& y

#include "lu32.h"/ U  p4 {3 H# s) F1 l1 s

. A2 u  M6 E1 G  d
#pragma comment( lib, "lu32.lib" )' z. G4 w. y% Y) A+ U- C

6 X+ c1 h4 C/ u) t& B6 ^
using namespace std;$ _* K9 |; }8 |# B* ]7 B  g

% c; [+ |& j% [4 Q1 h( p
luKEY Matrix=-1000;        //标识矩阵类型，最终的Matrix由LockKey决定  S  `3 F% Z- i# Y' F1 x8 I0 M

/ D: _. ^) M& T1 ~8 A

void _stdcall LuMessage(wchar_t *pch)//输出动态库信息，该函数注册到Lu，由Lu二级函数调用 
\\" A( v, j' F4 d2 \\\" O  ]
{1 y2 O+ b# M% K8 K0 u

wcout<<pch; 
, Z2 J' y3 N, n; K0 E
} 
* A; F' \6 m9 ^5 D$ F% q/ ~; p
void _stdcall DelMatrix(void *me)        //用于LockKey函数，因为是基于系统内置实数数组创建矩阵，故该函数什么也不做 
0 a# U# ]( T( g* O4 U
{\\" E2 R, ^$ L, B- j

} 
& x) j0 [4 c5 U; `) ]
LuData _stdcall OpMatrix(luINT mm,LuData *xx,void *hFor,int theOperator)        //运算符重载函数，用于LockKey函数 
+ q' S, S' I/ ?! C
{8 K, w* g  ], d/ Z0 e' V& |3 C

LuData a;\\" C$ e/ P; X0 s3 N

luRealArray *pRealArray1,*pRealArray2,*pRealArray3; 
\\" D\\" H& h3 x9 p1 s3 ]; G\\" [+ R# P8 \
        luVOID i,j,k,m,n,u,v;& u) N( W! e' s6 a

double *pa,*pb,*pc; 
5 p7 C' f5 }) ~: T0 d& T3 w
        luMessage pMessage; 
: q1 H! M2 {$ Z9 u1 U
        wchar_t wchNum[32]; 
/ m' b$ u* m& j% Q& s3 u0 {- \: \
        char chNum[32];& r8 b' z3 K% l' \9 b

a.BType=luStaData_nil; a.VType=luStaData_nil; a.x=0;( ?. x1 D( C\\" n% B# l. V: ~

switch(theOperator)) C9 P; m6 p  E* c

{ 
; N. J2 J$ v& [( e, x
        case 2:        //重载运算符*$ A2 P: v+ l8 a5 M9 |. x/ U( {: `5 H

pRealArray1=(luRealArray *)SearchKey((char *)&(xx->x),sizeof(luVOID),luDynData_realarray);2 [: z8 n5 V% ], m& X! M$ j6 H

pRealArray2=(luRealArray *)SearchKey((char *)&((xx+1)->x),sizeof(luVOID),luDynData_realarray); 
% z. f; y, Y8 [, n8 N# ]
                if(!pRealArray1 || !pRealArray2) break;        //对象句柄无效，不是实数数组 
  Q\\" |( I* D+ @
                if(pRealArray1->DimLen!=2 || pRealArray2->DimLen!=2) break;        //不是二维实数数组（矩阵） 
; R\\" n7 w1 C# Z3 u3 O  U2 V
                if(pRealArray1->Dim[1]!=pRealArray2->Dim[0]) break;        //维数不匹配 
8 J: N7 L- F+ J8 R
                pRealArray3=(luRealArray *)NewSysObj(luDynData_realarray,pRealArray1->Dim[0]*pRealArray2->Dim[1],2);        //创建矩阵对象  `9 ~+ D; u* G2 }& f; ~$ u4 n9 P$ _: p

if(!pRealArray3) break;3 [5 S! s, |: G8 {0 h2 ^! Z' {

pRealArray3->Dim[0]=pRealArray1->Dim[0]; pRealArray3->Dim[1]=pRealArray2->Dim[1];        //设置矩阵维数大小 
1 p+ w( k# G9 a4 U  o
                pa=pRealArray1->Array; pb=pRealArray2->Array; pc=pRealArray3->Array;( w. o8 `; H4 {( v' N

m=pRealArray1->Dim[0]; n=pRealArray1->Dim[1]; k=pRealArray2->Dim[1]; 
6 |\\" _9 ~5 s) K. X5 j
                for(i=0; i<m; i++)        //矩阵乘 
0 B% M: Y2 O8 a
                { 
3 Q0 q5 u+ s: d7 z
                        for(j=0; j<k; j++); a8 \: R1 v; }

{& p8 `- t' ^1 X) @0 w

u=i*k+j; pc[u]=0.0;% `+ k# |& n/ d6 f, v- v7 m

for (v=0; v<n; v++) 
( \0 _) f1 ~+ A# }  P
                                {) |1 G+ S0 ^3 V  z/ x

pc[u]=pc[u]+pa[i*n+v]*pb[v*k+j]; 
  o. q8 t) H7 l% _
                                }; b# W& b5 t+ L# j+ n% S9 `9 t. ?

}5 E3 j+ A1 S\\" Z1 Y- w$ L$ A* L6 @

} 
% U* c  x3 @; h7 l
                FunReObj(hFor);        //告诉Lu，返回一个动态对象 
& z5 x  P: p. |9 r
                a.BType=luDynData_realarray; a.VType=Matrix; a.x=0; *(luVOID *)&(a.x)=(luVOID)pRealArray3; 
$ J; f; \* N1 f  l, D  k
                break;0 u* J- W) p3 T* D/ q; E

case 25:        //重载运算符.*, ?$ g' P  t4 V8 I# x, w

pRealArray1=(luRealArray *)SearchKey((char *)&(xx->x),sizeof(luVOID),luDynData_realarray); 
/ Z7 z; F; C9 G% @0 y
                pRealArray2=(luRealArray *)SearchKey((char *)&((xx+1)->x),sizeof(luVOID),luDynData_realarray);  h! ~# e7 L, Q9 h0 P$ |

if(!pRealArray1 || !pRealArray2) break;        //对象句柄无效，不是实数数组 
  I. L/ l' A; ~0 r3 ?8 p
                if(pRealArray1->DimLen!=2 || pRealArray2->DimLen!=2) break;        //不是二维实数数组（矩阵）! ~: m5 J2 O$ p

if(pRealArray1->Dim[0]!=pRealArray2->Dim[0] || pRealArray1->Dim[1]!=pRealArray2->Dim[1]) break;        //维数不相同 
4 M% P/ `; m- P4 \
                pRealArray3=(luRealArray *)NewSysObj(luDynData_realarray,pRealArray1->ArrayLen,2);        //创建矩阵对象; N: t( c% V3 f' @( K4 c7 Y

if(!pRealArray3) break;% x& b8 W\\" V2 U8 D2 U! W

pRealArray3->Dim[0]=pRealArray1->Dim[0]; pRealArray3->Dim[1]=pRealArray1->Dim[1];        //设置矩阵维数大小1 O) r* Z& {  U9 ]. A\\" m. t

for(i=0;i<pRealArray1->ArrayLen;i++) pRealArray3->Array[i]=pRealArray1->Array[i]*pRealArray2->Array[i];//矩阵点乘7 U0 O4 K9 x& |7 e

FunReObj(hFor);        //告诉Lu，返回一个动态对象 
' N/ n* o4 K+ @# Q7 W% f' E
                a.BType=luDynData_realarray; a.VType=Matrix; a.x=0; *(luVOID *)&(a.x)=(luVOID)pRealArray3;) a  U$ @% |0 R$ E\\" E

break;  \, i; c  {; U\\" u' E7 N

case 46:        //重载函数new 
' O& L/ |9 L7 H$ r- }
                a=ExeOperator(mm,xx,hFor,theOperator,luDynData_realarray);        //直接调用基本类型luDynData_realarray的new函数 
, Z! g' L2 W  Y  c7 I
                if(a.VType==luDynData_realarray) a.VType=Matrix;        //设置扩展类型为自定义的Matrix类型 
9 J9 \: |  c- u# A( T* a  x
                break; 
$ C7 n  z6 {# ~: S( T' n
        case 49:        //重载函数o 
. p/ ^\\" g- [+ @9 P$ b
                pMessage=(luMessage)SearchKey("\0\0\0\0",sizeof(luVOID),luPubKey_User); 
  z0 J9 y; v- ]0 L! L# y$ f* c  e
                if(!pMessage) break; 
, A7 X( _6 Q6 w4 V
                pRealArray1=(luRealArray *)SearchKey((char *)&(xx->x),sizeof(luVOID),luDynData_realarray); 
$ c: j/ N, f4 h$ q\\" s# t9 m
                if(!pRealArray1) break;        //对象句柄无效，不是实数数组 
! U# M\\" Z1 t: m9 e8 u
                if(pRealArray1->DimLen!=2) break;        //不是二维实数数组（矩阵） 
\\" I+ t% y7 s- [7 J3 ^# O
                pa=pRealArray1->Array; 
8 ?+ _3 U8 ~6 V* j0 [: h3 ?
                m=pRealArray1->Dim[0]; n=pRealArray1->Dim[1]; k=0;+ Z: h) W  ~, }

for(i=0; i<m; i++)        //输出矩阵\\" v8 n' n7 N& u# x. H6 b

{ 
7 ~8 o! g# t& B6 B
                        pMessage(L"\r\n"); k+=2; 
5 i- b# f9 {: U9 H
                        for(j=0; j<n; j++)8 e+ J# H' U5 o8 I

{4 p& Z5 v. l( l5 p0 k* P  n% R6 G

_gcvt_s(chNum,pa[i*n+j],16);& H: \6 |/ n3 v& W/ E2 d) P

for(u=0;chNum[u];u++) {wchNum[u]=chNum[u]; k++;} 
6 L5 L0 q- u3 b  v3 T; b5 ?& t5 [
                                wchNum[u]='\0';/ f# B9 V, a; m/ i, O. E

pMessage(wchNum); pMessage(L"  "); k+=2; 
6 I\\" K2 Z$ `! g4 \
                        } 
; K4 ~1 B  {& S- j- r* N6 [: [# ^
                }2 Y- L: b: ^5 e( M$ f' C9 Q

pMessage(L"\r\n"); k+=2; 
. p5 Z* U\\" t4 I$ a\\" _+ A
                a.BType=luStaData_int64; a.VType=luStaData_int64; a.x=k;        //按函数o的要求，返回输出的字符总数 
- W1 m/ ^* e\\" R& u) D8 {/ D
                break; 
( P3 O+ n% T0 W+ j
        default:6 J1 v  Q) x4 X6 E1 V

break;$ }9 J/ p3 y( H& u3 A, K! f! b

}1 L: Y! ]; B+ Z( H1 m

return a;+ N7 s$ D* D) d\\" d9 P

}) w- g2 N' C0 ]7 z

void main(void) 
$ `\\" s0 G! K. v1 c6 j, s. ]
{& ~# E/ R- W- F8 t6 ]

void *hFor;                //表达式句柄/ j5 u. y: v; N5 I

luINT nPara;                //存放表达式的自变量个数 
( b3 f5 q/ k  b% ^. u- F$ \& m
        LuData *pPara;                //存放输入自变量的数组指针 
9 r' B4 a( U% S: P' {$ d: n
        luINT ErrBegin,ErrEnd;        //表达式编译出错的初始位置和结束位置% z' c7 ~) Q- v/ }7 }& l

int ErrCode;                //错误代码 
& Y& f2 D$ E: D3 l, l' @* D
        void *v;; T& V: l; P( A1 \

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.]}";//字符串表达式，矩阵乘 
1 G1 Y, X! @' t
        //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.]}";//字符串表达式，矩阵点乘: l: {; B) b' n4 B8 }4 \

LuData Val;; n! K( K8 e1 l3 E

if(!InitLu()) return;        //初始化Lu5 X0 u\\" W1 e  d4 ~2 H  {& F) ]5 q- o1 r

while(LockKey(Matrix,DelMatrix,OpMatrix)){Matrix++;}        //锁定一个键，用于存储矩阵扩展类型+ Q% @5 I  q& y- x2 C

5 z% P- n# e3 D6 B
        Val.BType=luStaData_int64; Val.VType=luStaData_int64; Val.x=Matrix;        //定义整数常量# `& r; J. |# H& x! [- V

SetConst(L"matrix",&Val);        //设置整数常量 
9 w/ f  G: ~$ L1 `( z& I% Z
        InsertKey("\0\0\0\0",4,luPubKey_User,LuMessage,NULL,NULL,1,v); //使Lu运行时可输出函数信息% i* ]5 O) [! T/ u\\" m5 z

wcout.imbue(locale("chs"));        //设置输出的locale为中文( R\\" [+ u6 g) y5 C

6 g% j0 k2 L: W5 p! V, I; Z; [

ErrCode=LuCom(ForStr,0,0,0,hFor,nPara,pPara,ErrBegin,ErrEnd); //编译表达式& D& z- s! \3 v! n# X6 u, x+ ?

if(ErrCode) 
, B$ D* a3 @0 b! |
        {6 R6 k, C9 d3 p/ A9 b

wcout<<L"表达式有错误！错误代码："<<ErrCode<<endl; 
\\" K. d7 p. f- b* x\\" t5 o9 ~
        }% N  i7 k4 s, ]; U+ g0 ]

else3 \9 e, H( u3 Z$ S

{' q/ a! }- g\\" L1 B' ?

LuCal(hFor,pPara);        //计算表达式的值6 d$ D) P0 e. B3 ^- ?

} 
1 @/ j\\" B8 b0 s3 ~( ^
        LockKey(Matrix,NULL,OpMatrix);//解锁键Matrix，本例中，该函数可以不用3 E$ V- C/ F* E/ t# ?1 y

FreeLu();                        //释放Lu 
5 G1 ~. d3 f. @& N
}

习题：

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

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

main(:a,b,c,d,t,i)=; |* H% t) e4 Y) ^7 n3 d0 t& Q
a=new[matrix,2,2,data:1.,2.,2.,1.],% B) g. |& c\" I2 T' Y% O9 \\" l
b=new[matrix,2,2,data:2.,1.,1.,2.],
8 C( S' f% Q9 ]8 [
c=new[matrix,2,2,data:2/3.,-1/3.,-1/3.,2/3.],\" D+ {' I; D5 P1 I
t=clock(),
8 |; X' @! N4 K/ A' ^1 q
d=a*b, i=0, while{i<1000000, d=d*c*b, i++},% L! }, l 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\"}";//字符串表达式

复制代码

结果：