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

查看: 8877|回复: 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>7 m4 A, g( q# P9 s& y6 H
#include <iostream>\\" j d/ [' F4 m3 [, D8 I$ }
#include <math.h>
6 @8 }! t8 \7 y7 U: t+ X% X( o
#include "lu32.h"# C G* Q+ P5 t( Y2 Y
O% z/ T+ H4 d\\" f
#pragma comment( lib, "lu32.lib" )- L) d9 o4 p3 i. S6 E0 F
/ c% |4 W- k7 v2 `7 o) m7 l
using namespace std;% L# q# ^% D' F7 d7 }9 L
, ?7 J; ^- Q3 E\\" U8 U$ B
luKEY Matrix=-1000; //标识矩阵类型，最终的Matrix由LockKey决定/ ` }& _% D3 G7 J
U( r+ t, l, ^9 Y3 e6 u
void _stdcall LuMessage(wchar_t *pch)//输出动态库信息，该函数注册到Lu，由Lu二级函数调用 - D a' R( X9 A9 {: I\\" W# S
{2 L6 k3 x! M! C# F- x a. x P+ Y
wcout<<pch;
% `* Z& C- z4 ~* ^, _2 @
}
/ A, ]2 K0 p\\" }$ p/ f0 `. V
void _stdcall DelMatrix(void *me) //用于LockKey函数，因为是基于系统内置实数数组创建矩阵，故该函数什么也不做
5 U9 G( w7 O$ F
{4 q- V8 ?8 }5 }\\" h' n2 [3 @# K8 v. r% p
}
, _+ y# o! u) v m; ?/ p: X1 l
LuData _stdcall OpMatrix(luINT mm,LuData *xx,void *hFor,int theOperator) //运算符重载函数，用于LockKey函数: a( f2 l# O' B7 ?. j3 [) O ?
{. c9 a' A4 w, X& F, c, o3 V/ I$ Y
LuData a;
% R o5 Y, q B4 U
luRealArray *pRealArray1,*pRealArray2,*pRealArray3;( ^9 }& h7 u# q Z; T
luVOID i,j,k,m,n,u,v;' |7 _) i0 {+ o. w: g, t6 r& k
double *pa,*pb,*pc;
F- D0 M( [, U# f
luMessage pMessage;
6 g' E2 v) E# P\\" f, ?
wchar_t wchNum[32];
7 Y+ ^3 P8 B8 a( U3 L
char chNum[32];* a! e, { Q' r/ M
a.BType=luStaData_nil; a.VType=luStaData_nil; a.x=0;
6 x) V; d8 i1 h: q: Z6 g
switch(theOperator)& |1 ]5 O& y# d
{. i ]+ ^3 n* d
case 2: //重载运算符*( M9 {: z O+ q\\" H8 g
pRealArray1=(luRealArray *)SearchKey((char *)&(xx->x),sizeof(luVOID),luDynData_realarray);* W$ D: V\\" d\\" J4 T2 [: C
pRealArray2=(luRealArray *)SearchKey((char *)&((xx+1)->x),sizeof(luVOID),luDynData_realarray);* n$ r. |1 I) K
if(!pRealArray1 || !pRealArray2) break; //对象句柄无效，不是实数数组2 Q: E u4 k a3 M4 x+ o/ T
if(pRealArray1->DimLen!=2 || pRealArray2->DimLen!=2) break; //不是二维实数数组（矩阵）, y: f' D& s6 O( m- x/ M; G
if(pRealArray1->Dim[1]!=pRealArray2->Dim[0]) break; //维数不匹配
2 K5 ?. x: y9 i- D5 F- N' b
pRealArray3=(luRealArray *)NewSysObj(luDynData_realarray,pRealArray1->Dim[0]*pRealArray2->Dim[1],2); //创建矩阵对象
: \! Y\\" ~( g' z$ t. S+ e
if(!pRealArray3) break;: S! L# ?5 O0 |, c8 u! Q1 j
pRealArray3->Dim[0]=pRealArray1->Dim[0]; pRealArray3->Dim[1]=pRealArray2->Dim[1]; //设置矩阵维数大小
0 Z3 Z6 @1 C2 k5 x1 b! H
pa=pRealArray1->Array; pb=pRealArray2->Array; pc=pRealArray3->Array;
% ~9 q+ }. @, f3 f3 S% F: k4 g
m=pRealArray1->Dim[0]; n=pRealArray1->Dim[1]; k=pRealArray2->Dim[1];' n7 x: C0 `) a/ H8 V
for(i=0; i<m; i++) //矩阵乘 l' L8 J6 l, ~2 O% U! ^
{$ h- x& d4 H4 e# g7 p
for(j=0; j<k; j++)
# A# i( m. ^7 T X4 F: a7 n0 \
{
4 t \5 Q. S) k6 s. j; a
u=i*k+j; pc[u]=0.0;
9 a! L+ _ i5 K- G
for (v=0; v<n; v++)
8 m9 J7 y7 S) s\\" ^% ^\\" }
{
) O1 F( n\\" J3 n4 J- O
pc[u]=pc[u]+pa[i*n+v]*pb[v*k+j];
1 Z$ h' T1 s3 p
} A* @) [9 E9 n3 J2 w
}, X4 ^5 e7 r Y/ S6 e& w; G A8 c) r
}- P- j% R0 h1 K$ i' Q
FunReObj(hFor); //告诉Lu，返回一个动态对象$ R6 K; \( e4 j! I$ c/ X\\" p5 M! v
a.BType=luDynData_realarray; a.VType=Matrix; a.x=0; *(luVOID *)&(a.x)=(luVOID)pRealArray3;: t0 ^0 |% F% l8 t, z( V
break;
& k2 N6 [$ v; u. _8 j% T9 m% C) O2 ^
case 25: //重载运算符.*
' s\\" F3 Y: b2 n
pRealArray1=(luRealArray *)SearchKey((char *)&(xx->x),sizeof(luVOID),luDynData_realarray);
, K6 W/ O$ c5 A
pRealArray2=(luRealArray *)SearchKey((char *)&((xx+1)->x),sizeof(luVOID),luDynData_realarray);: ?1 J- @1 {0 `
if(!pRealArray1 || !pRealArray2) break; //对象句柄无效，不是实数数组0 K3 ~- w: P2 m) k7 V3 ^
if(pRealArray1->DimLen!=2 || pRealArray2->DimLen!=2) break; //不是二维实数数组（矩阵）7 `6 o( Z. e3 q. }: _4 h$ R6 b# E* T
if(pRealArray1->Dim[0]!=pRealArray2->Dim[0] || pRealArray1->Dim[1]!=pRealArray2->Dim[1]) break; //维数不相同
+ X; _! Q+ k9 D, J1 ~
pRealArray3=(luRealArray *)NewSysObj(luDynData_realarray,pRealArray1->ArrayLen,2); //创建矩阵对象2 n! p) k\\" b' Q! ^
if(!pRealArray3) break;
+ ^. d, f4 z$ g$ A7 Z4 G6 q, \5 H\\" Z
pRealArray3->Dim[0]=pRealArray1->Dim[0]; pRealArray3->Dim[1]=pRealArray1->Dim[1]; //设置矩阵维数大小2 }5 M2 d. o' q
for(i=0;i<pRealArray1->ArrayLen;i++) pRealArray3->Array[i]=pRealArray1->Array[i]*pRealArray2->Array[i];//矩阵点乘
\\" y, w6 _5 x0 \# g$ I$ C
FunReObj(hFor); //告诉Lu，返回一个动态对象$ V+ b' s1 U y3 N( @9 f
a.BType=luDynData_realarray; a.VType=Matrix; a.x=0; *(luVOID *)&(a.x)=(luVOID)pRealArray3;# N, z5 \3 K0 F
break;/ L8 i, l; i+ g; g
case 46: //重载函数new
8 P9 |( ~& h( B& q, z8 w
a=ExeOperator(mm,xx,hFor,theOperator,luDynData_realarray); //直接调用基本类型luDynData_realarray的new函数
/ W2 N4 F, g4 M9 R6 U. [
if(a.VType==luDynData_realarray) a.VType=Matrix; //设置扩展类型为自定义的Matrix类型
# y9 X+ ~3 X, J' C3 H$ z
break;/ ?: P0 F+ n9 D) o\\" n9 H
case 49: //重载函数o
# j( M5 B5 J$ r# \
pMessage=(luMessage)SearchKey("\0\0\0\0",sizeof(luVOID),luPubKey_User);! P, g9 w\\" E, ]4 [- }/ N
if(!pMessage) break;\\" F\\" T# f\\" m2 s
pRealArray1=(luRealArray *)SearchKey((char *)&(xx->x),sizeof(luVOID),luDynData_realarray);) L- A- u/ `& a$ e. F6 `+ @
if(!pRealArray1) break; //对象句柄无效，不是实数数组1 Y% |7 s: y. _- u& B1 p2 r
if(pRealArray1->DimLen!=2) break; //不是二维实数数组（矩阵）
0 h% r1 ~6 T3 n
pa=pRealArray1->Array;2 V' ]* B3 w6 ?\\" e7 \
m=pRealArray1->Dim[0]; n=pRealArray1->Dim[1]; k=0;
0 D2 B, o6 y$ P: y+ H4 d
for(i=0; i<m; i++) //输出矩阵
\\" m* D2 \( X1 I) T
{
\\" I' Q& k; Q/ h! e; r: \
pMessage(L"\r\n"); k+=2;
' S1 a8 D6 ?\\" f+ h2 y
for(j=0; j<n; j++)
}+ v$ {2 Y o) f# T
{9 P% n4 C9 q( D\\" U) J1 [4 ]9 d
_gcvt_s(chNum,pa[i*n+j],16);
* U5 ~) b& e6 Z
for(u=0;chNum[u];u++) {wchNum[u]=chNum[u]; k++;}
' T6 Q) B: i3 G
wchNum[u]='\0';0 o- p& v1 ?9 t' b
pMessage(wchNum); pMessage(L" "); k+=2;
8 B' e0 t; x7 Y8 t
}2 Y8 _* g- c1 V
}) Y9 z' p( ^; b1 @
pMessage(L"\r\n"); k+=2;
\\" z, h; H\\" S7 \, o
a.BType=luStaData_int64; a.VType=luStaData_int64; a.x=k; //按函数o的要求，返回输出的字符总数0 D$ r& Z* n; F0 O' J\\" `
break;
4 a4 P( C6 g, M
default:0 Z1 {: l( `3 x6 f
break;
( L# p8 ^8 d9 F
}# k( z2 S7 h( e4 a: K\\" o. Y1 }
return a;\\" A) K: [, Y# L: F7 v
}
( ?! g& E4 D\\" ]! @7 W7 n& g
void main(void)
9 j4 Q$ U0 l: h6 a8 f7 E6 F$ l% o; f
{5 n& v7 E. l$ W* P: @
void *hFor; //表达式句柄6 L+ ?- `% J) C
luINT nPara; //存放表达式的自变量个数$ X# S% b, }1 @9 ]5 t+ W3 Z8 Q: [
LuData *pPara; //存放输入自变量的数组指针, P Q: V( a+ a
luINT ErrBegin,ErrEnd; //表达式编译出错的初始位置和结束位置. O- w\\" k# I7 p) k$ S7 K9 k7 x2 l
int ErrCode; //错误代码8 q% N4 _\\" l1 Y
void *v;
* X( t; w& e8 a
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.]}";//字符串表达式，矩阵乘
) ]6 q+ D h* z1 H( R E* N
//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: h/ {: O6 J. v% y% F1 b
LuData Val;
if(!InitLu()) return; //初始化Lu7 B' D! _# J9 |# t6 S. R\\" @: c+ H2 Q
while(LockKey(Matrix,DelMatrix,OpMatrix)){Matrix++;} //锁定一个键，用于存储矩阵扩展类型
& k9 O. ?/ W8 n# c( U# ]% j
+ D+ f) R7 ^) \$ X0 V) j D
Val.BType=luStaData_int64; Val.VType=luStaData_int64; Val.x=Matrix; //定义整数常量$ T. I0 K+ r/ {1 T5 x
SetConst(L"matrix",&Val); //设置整数常量
6 u, w1 N\\" K# U; S' ?\\" M
InsertKey("\0\0\0\0",4,luPubKey_User,LuMessage,NULL,NULL,1,v); //使Lu运行时可输出函数信息
( V8 a4 z- S( [\\" @+ j; l; k# Z
wcout.imbue(locale("chs")); //设置输出的locale为中文) \5 D. R1 R9 g/ n+ J9 P- ~
- C% S6 N j- H, o
ErrCode=LuCom(ForStr,0,0,0,hFor,nPara,pPara,ErrBegin,ErrEnd); //编译表达式5 B$ n6 B* K8 O4 X- n
if(ErrCode)* P' Q% U) J7 B9 L, w2 I
{2 C6 T0 |! e* t) v! N0 I
wcout<<L"表达式有错误！错误代码："<<ErrCode<<endl;
$ y: X$ A) }\\" d$ C1 \. |2 A, A
}
3 m, z/ D' C2 M$ l0 x, F) ]
else
$ R% x; z. a# `( ?) x
{
1 W7 C7 ?, E/ c& ]7 D1 Z
LuCal(hFor,pPara); //计算表达式的值. O\\" b, p1 W7 Y
}/ `% g2 W( q u. x' F8 y
LockKey(Matrix,NULL,OpMatrix);//解锁键Matrix，本例中，该函数可以不用! z% l N# j2 u
FreeLu(); //释放Lu; R* v% x b' _- P% W, u2 \7 I$ X
}

#include <windows.h>7 m4 A, g( q# P9 s& y6 H

#include <iostream>\\" j  d/ [' F4 m3 [, D8 I$ }

#include <math.h> 
6 @8 }! t8 \7 y7 U: t+ X% X( o
#include "lu32.h"# C  G* Q+ P5 t( Y2 Y

O% z/ T+ H4 d\\" f

#pragma comment( lib, "lu32.lib" )- L) d9 o4 p3 i. S6 E0 F

/ c% |4 W- k7 v2 `7 o) m7 l

using namespace std;% L# q# ^% D' F7 d7 }9 L

, ?7 J; ^- Q3 E\\" U8 U$ B
luKEY Matrix=-1000;        //标识矩阵类型，最终的Matrix由LockKey决定/ `  }& _% D3 G7 J

U( r+ t, l, ^9 Y3 e6 u
void _stdcall LuMessage(wchar_t *pch)//输出动态库信息，该函数注册到Lu，由Lu二级函数调用 - D  a' R( X9 A9 {: I\\" W# S

{2 L6 k3 x! M! C# F- x  a. x  P+ Y

wcout<<pch; 
% `* Z& C- z4 ~* ^, _2 @
} 
/ A, ]2 K0 p\\" }$ p/ f0 `. V
void _stdcall DelMatrix(void *me)        //用于LockKey函数，因为是基于系统内置实数数组创建矩阵，故该函数什么也不做 
5 U9 G( w7 O$ F
{4 q- V8 ?8 }5 }\\" h' n2 [3 @# K8 v. r% p

} 
, _+ y# o! u) v  m; ?/ p: X1 l
LuData _stdcall OpMatrix(luINT mm,LuData *xx,void *hFor,int theOperator)        //运算符重载函数，用于LockKey函数: a( f2 l# O' B7 ?. j3 [) O  ?

{. c9 a' A4 w, X& F, c, o3 V/ I$ Y

LuData a; 
% R  o5 Y, q  B4 U
        luRealArray *pRealArray1,*pRealArray2,*pRealArray3;( ^9 }& h7 u# q  Z; T

luVOID i,j,k,m,n,u,v;' |7 _) i0 {+ o. w: g, t6 r& k

double *pa,*pb,*pc; 
  F- D0 M( [, U# f
        luMessage pMessage; 
6 g' E2 v) E# P\\" f, ?
        wchar_t wchNum[32]; 
7 Y+ ^3 P8 B8 a( U3 L
        char chNum[32];* a! e, {  Q' r/ M

a.BType=luStaData_nil; a.VType=luStaData_nil; a.x=0; 
6 x) V; d8 i1 h: q: Z6 g
        switch(theOperator)& |1 ]5 O& y# d

{. i  ]+ ^3 n* d

case 2:        //重载运算符*( M9 {: z  O+ q\\" H8 g

pRealArray1=(luRealArray *)SearchKey((char *)&(xx->x),sizeof(luVOID),luDynData_realarray);* W$ D: V\\" d\\" J4 T2 [: C

pRealArray2=(luRealArray *)SearchKey((char *)&((xx+1)->x),sizeof(luVOID),luDynData_realarray);* n$ r. |1 I) K

if(!pRealArray1 || !pRealArray2) break;        //对象句柄无效，不是实数数组2 Q: E  u4 k  a3 M4 x+ o/ T

if(pRealArray1->DimLen!=2 || pRealArray2->DimLen!=2) break;        //不是二维实数数组（矩阵）, y: f' D& s6 O( m- x/ M; G

if(pRealArray1->Dim[1]!=pRealArray2->Dim[0]) break;        //维数不匹配 
2 K5 ?. x: y9 i- D5 F- N' b
                pRealArray3=(luRealArray *)NewSysObj(luDynData_realarray,pRealArray1->Dim[0]*pRealArray2->Dim[1],2);        //创建矩阵对象 
: \! Y\\" ~( g' z$ t. S+ e
                if(!pRealArray3) break;: S! L# ?5 O0 |, c8 u! Q1 j

pRealArray3->Dim[0]=pRealArray1->Dim[0]; pRealArray3->Dim[1]=pRealArray2->Dim[1];        //设置矩阵维数大小 
0 Z3 Z6 @1 C2 k5 x1 b! H
                pa=pRealArray1->Array; pb=pRealArray2->Array; pc=pRealArray3->Array; 
% ~9 q+ }. @, f3 f3 S% F: k4 g
                m=pRealArray1->Dim[0]; n=pRealArray1->Dim[1]; k=pRealArray2->Dim[1];' n7 x: C0 `) a/ H8 V

for(i=0; i<m; i++)        //矩阵乘  l' L8 J6 l, ~2 O% U! ^

{$ h- x& d4 H4 e# g7 p

for(j=0; j<k; j++) 
# A# i( m. ^7 T  X4 F: a7 n0 \
                        { 
4 t  \5 Q. S) k6 s. j; a
                                u=i*k+j; pc[u]=0.0; 
9 a! L+ _  i5 K- G
                                for (v=0; v<n; v++) 
8 m9 J7 y7 S) s\\" ^% ^\\" }
                                { 
) O1 F( n\\" J3 n4 J- O
                                        pc[u]=pc[u]+pa[i*n+v]*pb[v*k+j]; 
1 Z$ h' T1 s3 p
                                }  A* @) [9 E9 n3 J2 w

}, X4 ^5 e7 r  Y/ S6 e& w; G  A8 c) r

}- P- j% R0 h1 K$ i' Q

FunReObj(hFor);        //告诉Lu，返回一个动态对象$ R6 K; \( e4 j! I$ c/ X\\" p5 M! v

a.BType=luDynData_realarray; a.VType=Matrix; a.x=0; *(luVOID *)&(a.x)=(luVOID)pRealArray3;: t0 ^0 |% F% l8 t, z( V

break; 
& k2 N6 [$ v; u. _8 j% T9 m% C) O2 ^
        case 25:        //重载运算符.* 
' s\\" F3 Y: b2 n
                pRealArray1=(luRealArray *)SearchKey((char *)&(xx->x),sizeof(luVOID),luDynData_realarray); 
, K6 W/ O$ c5 A
                pRealArray2=(luRealArray *)SearchKey((char *)&((xx+1)->x),sizeof(luVOID),luDynData_realarray);: ?1 J- @1 {0 `

if(!pRealArray1 || !pRealArray2) break;        //对象句柄无效，不是实数数组0 K3 ~- w: P2 m) k7 V3 ^

if(pRealArray1->DimLen!=2 || pRealArray2->DimLen!=2) break;        //不是二维实数数组（矩阵）7 `6 o( Z. e3 q. }: _4 h$ R6 b# E* T

if(pRealArray1->Dim[0]!=pRealArray2->Dim[0] || pRealArray1->Dim[1]!=pRealArray2->Dim[1]) break;        //维数不相同 
+ X; _! Q+ k9 D, J1 ~
                pRealArray3=(luRealArray *)NewSysObj(luDynData_realarray,pRealArray1->ArrayLen,2);        //创建矩阵对象2 n! p) k\\" b' Q! ^

if(!pRealArray3) break; 
+ ^. d, f4 z$ g$ A7 Z4 G6 q, \5 H\\" Z
                pRealArray3->Dim[0]=pRealArray1->Dim[0]; pRealArray3->Dim[1]=pRealArray1->Dim[1];        //设置矩阵维数大小2 }5 M2 d. o' q

for(i=0;i<pRealArray1->ArrayLen;i++) pRealArray3->Array[i]=pRealArray1->Array[i]*pRealArray2->Array[i];//矩阵点乘 
\\" y, w6 _5 x0 \# g$ I$ C
                FunReObj(hFor);        //告诉Lu，返回一个动态对象$ V+ b' s1 U  y3 N( @9 f

a.BType=luDynData_realarray; a.VType=Matrix; a.x=0; *(luVOID *)&(a.x)=(luVOID)pRealArray3;# N, z5 \3 K0 F

break;/ L8 i, l; i+ g; g

case 46:        //重载函数new 
8 P9 |( ~& h( B& q, z8 w
                a=ExeOperator(mm,xx,hFor,theOperator,luDynData_realarray);        //直接调用基本类型luDynData_realarray的new函数 
/ W2 N4 F, g4 M9 R6 U. [
                if(a.VType==luDynData_realarray) a.VType=Matrix;        //设置扩展类型为自定义的Matrix类型 
# y9 X+ ~3 X, J' C3 H$ z
                break;/ ?: P0 F+ n9 D) o\\" n9 H

case 49:        //重载函数o 
# j( M5 B5 J$ r# \
                pMessage=(luMessage)SearchKey("\0\0\0\0",sizeof(luVOID),luPubKey_User);! P, g9 w\\" E, ]4 [- }/ N

if(!pMessage) break;\\" F\\" T# f\\" m2 s

pRealArray1=(luRealArray *)SearchKey((char *)&(xx->x),sizeof(luVOID),luDynData_realarray);) L- A- u/ `& a$ e. F6 `+ @

if(!pRealArray1) break;        //对象句柄无效，不是实数数组1 Y% |7 s: y. _- u& B1 p2 r

if(pRealArray1->DimLen!=2) break;        //不是二维实数数组（矩阵） 
0 h% r1 ~6 T3 n
                pa=pRealArray1->Array;2 V' ]* B3 w6 ?\\" e7 \

m=pRealArray1->Dim[0]; n=pRealArray1->Dim[1]; k=0; 
0 D2 B, o6 y$ P: y+ H4 d
                for(i=0; i<m; i++)        //输出矩阵 
\\" m* D2 \( X1 I) T
                { 
\\" I' Q& k; Q/ h! e; r: \
                        pMessage(L"\r\n"); k+=2; 
' S1 a8 D6 ?\\" f+ h2 y
                        for(j=0; j<n; j++) 
  }+ v$ {2 Y  o) f# T
                        {9 P% n4 C9 q( D\\" U) J1 [4 ]9 d

_gcvt_s(chNum,pa[i*n+j],16); 
* U5 ~) b& e6 Z
                                for(u=0;chNum[u];u++) {wchNum[u]=chNum[u]; k++;} 
' T6 Q) B: i3 G
                                wchNum[u]='\0';0 o- p& v1 ?9 t' b

pMessage(wchNum); pMessage(L"  "); k+=2; 
8 B' e0 t; x7 Y8 t
                        }2 Y8 _* g- c1 V

}) Y9 z' p( ^; b1 @

pMessage(L"\r\n"); k+=2; 
\\" z, h; H\\" S7 \, o
                a.BType=luStaData_int64; a.VType=luStaData_int64; a.x=k;        //按函数o的要求，返回输出的字符总数0 D$ r& Z* n; F0 O' J\\" `

break; 
4 a4 P( C6 g, M
        default:0 Z1 {: l( `3 x6 f

break; 
( L# p8 ^8 d9 F
        }# k( z2 S7 h( e4 a: K\\" o. Y1 }

return a;\\" A) K: [, Y# L: F7 v

} 
( ?! g& E4 D\\" ]! @7 W7 n& g
void main(void) 
9 j4 Q$ U0 l: h6 a8 f7 E6 F$ l% o; f
{5 n& v7 E. l$ W* P: @

void *hFor;                //表达式句柄6 L+ ?- `% J) C

luINT nPara;                //存放表达式的自变量个数$ X# S% b, }1 @9 ]5 t+ W3 Z8 Q: [

LuData *pPara;                //存放输入自变量的数组指针, P  Q: V( a+ a

luINT ErrBegin,ErrEnd;        //表达式编译出错的初始位置和结束位置. O- w\\" k# I7 p) k$ S7 K9 k7 x2 l

int ErrCode;                //错误代码8 q% N4 _\\" l1 Y

void *v; 
* X( t; w& e8 a
        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.]}";//字符串表达式，矩阵乘 
) ]6 q+ D  h* z1 H( R  E* N
        //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: h/ {: O6 J. v% y% F1 b

LuData Val; 
/ e# K; S5 l+ C' }& ?$ M  v2 e5 V\\" [
        if(!InitLu()) return;        //初始化Lu7 B' D! _# J9 |# t6 S. R\\" @: c+ H2 Q

while(LockKey(Matrix,DelMatrix,OpMatrix)){Matrix++;}        //锁定一个键，用于存储矩阵扩展类型 
& k9 O. ?/ W8 n# c( U# ]% j
 
+ D+ f) R7 ^) \$ X0 V) j  D
        Val.BType=luStaData_int64; Val.VType=luStaData_int64; Val.x=Matrix;        //定义整数常量$ T. I0 K+ r/ {1 T5 x

SetConst(L"matrix",&Val);        //设置整数常量 
6 u, w1 N\\" K# U; S' ?\\" M
        InsertKey("\0\0\0\0",4,luPubKey_User,LuMessage,NULL,NULL,1,v); //使Lu运行时可输出函数信息 
( V8 a4 z- S( [\\" @+ j; l; k# Z
        wcout.imbue(locale("chs"));        //设置输出的locale为中文) \5 D. R1 R9 g/ n+ J9 P- ~

- C% S6 N  j- H, o
        ErrCode=LuCom(ForStr,0,0,0,hFor,nPara,pPara,ErrBegin,ErrEnd); //编译表达式5 B$ n6 B* K8 O4 X- n

if(ErrCode)* P' Q% U) J7 B9 L, w2 I

{2 C6 T0 |! e* t) v! N0 I

wcout<<L"表达式有错误！错误代码："<<ErrCode<<endl; 
$ y: X$ A) }\\" d$ C1 \. |2 A, A
        } 
3 m, z/ D' C2 M$ l0 x, F) ]
        else 
$ R% x; z. a# `( ?) x
        { 
1 W7 C7 ?, E/ c& ]7 D1 Z
                LuCal(hFor,pPara);        //计算表达式的值. O\\" b, p1 W7 Y

}/ `% g2 W( q  u. x' F8 y

LockKey(Matrix,NULL,OpMatrix);//解锁键Matrix，本例中，该函数可以不用! z% l  N# j2 u

FreeLu();                        //释放Lu; R* v% x  b' _- P% W, u2 \7 I$ X

}

习题：

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

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

main(:a,b,c,d,t,i)=9 C3 L# F! p9 q; G1 y, a5 U
a=new[matrix,2,2,data:1.,2.,2.,1.],\" d, t, t) R5 o$ z
b=new[matrix,2,2,data:2.,1.,1.,2.],
- U/ W\" i2 W* G0 Y- b- a+ q; }1 |
c=new[matrix,2,2,data:2/3.,-1/3.,-1/3.,2/3.],! r3 \\" }8 `4 b# ~
t=clock(),
. o5 w% O0 Y$ x
d=a*b, i=0, while{i<1000000, d=d*c*b, i++},
, f4 J1 d( X4 t1 z5 ]/ q/ d! ~
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\"}";//字符串表达式

复制代码

结果：