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

查看: 8814|回复: 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>
2 g$ N& C$ |- ]. Z! ~9 x- D
#include <iostream>8 i+ C3 v/ l0 T: V, E; X( {
#include <math.h>
, d& ?8 W/ R\\" y0 ^/ ~( `
#include "lu32.h" ~# Z+ a# a8 ~% t3 r) y
/ k; N7 k( {4 K\\" L: O
#pragma comment( lib, "lu32.lib" )
! t& y7 Q- L: J# I7 @- M
- X t1 P4 g, T' j7 F
using namespace std;/ h6 m# a9 }0 Z; E
& O\\" g& \+ ^$ M
luKEY Matrix=-1000; //标识矩阵类型，最终的Matrix由LockKey决定\\" Y# D4 t. p0 J2 |# ?
: X! y1 I) B; y
void _stdcall LuMessage(wchar_t *pch)//输出动态库信息，该函数注册到Lu，由Lu二级函数调用 3 U, q\\" D+ a/ d7 s! [
{
7 m4 i( k) o) P: P( Y3 Q: N
wcout<<pch;
4 ~; |* Z: O; ~) U
}
7 ^# p! ~* m% @\\" h m/ m: z3 D
void _stdcall DelMatrix(void *me) //用于LockKey函数，因为是基于系统内置实数数组创建矩阵，故该函数什么也不做
+ z$ X3 }: _2 M& A8 @4 F
{
% s, K' f- A, c8 v8 N* e1 M& x0 _
}+ c( G; x t8 f3 E
LuData _stdcall OpMatrix(luINT mm,LuData *xx,void *hFor,int theOperator) //运算符重载函数，用于LockKey函数5 f. c& K$ E' ?! S$ u% N
{! P; |, N7 {; w
LuData a;! }2 G# U# z' s2 h
luRealArray *pRealArray1,*pRealArray2,*pRealArray3;
; O1 \/ f8 g7 e9 G\\" _( F3 }
luVOID i,j,k,m,n,u,v;
5 i) W, P6 e8 M\\" W; w\\" s
double *pa,*pb,*pc;- \) M9 l8 H, v, j5 \2 m) Y
luMessage pMessage;2 A& X! G8 {2 K% s
wchar_t wchNum[32];. ?( R+ g6 v- X
char chNum[32]; L1 a% l+ i: a$ I: v
a.BType=luStaData_nil; a.VType=luStaData_nil; a.x=0;
& p2 D$ P' a( {
switch(theOperator)
+ N( N: s) `# }! K7 E4 L
{3 G# }% U e: H# {8 G
case 2: //重载运算符*3 |9 }! @* N& R4 y0 S' Q0 J/ o
pRealArray1=(luRealArray *)SearchKey((char *)&(xx->x),sizeof(luVOID),luDynData_realarray);
: m7 i\\" q9 j5 z0 Y$ D9 Y0 v
pRealArray2=(luRealArray *)SearchKey((char *)&((xx+1)->x),sizeof(luVOID),luDynData_realarray);
7 \$ `- f: |+ G, U- M$ G
if(!pRealArray1 || !pRealArray2) break; //对象句柄无效，不是实数数组- | ]1 i) P) w; M+ c
if(pRealArray1->DimLen!=2 || pRealArray2->DimLen!=2) break; //不是二维实数数组（矩阵）' m1 X& h& H I9 [# C\\" `
if(pRealArray1->Dim[1]!=pRealArray2->Dim[0]) break; //维数不匹配 Z- P( F+ L' \: t( N8 p+ r
pRealArray3=(luRealArray *)NewSysObj(luDynData_realarray,pRealArray1->Dim[0]*pRealArray2->Dim[1],2); //创建矩阵对象9 [% O\\" @# K* B e5 {; m\\" Y
if(!pRealArray3) break; k; \5 ?$ Z3 z
pRealArray3->Dim[0]=pRealArray1->Dim[0]; pRealArray3->Dim[1]=pRealArray2->Dim[1]; //设置矩阵维数大小
& C2 h* e+ g* A2 e( |
pa=pRealArray1->Array; pb=pRealArray2->Array; pc=pRealArray3->Array;
+ \! k: d4 y9 I6 W; z1 Q% A3 D
m=pRealArray1->Dim[0]; n=pRealArray1->Dim[1]; k=pRealArray2->Dim[1];% Q8 f+ N\\" g3 }6 r
for(i=0; i<m; i++) //矩阵乘 G/ n$ o- ^. p, {
{
) ~9 p9 }/ g9 T) A4 G0 k
for(j=0; j<k; j++)
, f d8 g, P8 r% L, G
{
2 X; H0 o3 @\\" C' |
u=i*k+j; pc[u]=0.0;
& N, c4 }1 o0 z$ {: N) N8 y
for (v=0; v<n; v++)
( t9 v2 Q9 q u$ ^- P3 I* h3 O
{
4 M% \$ W\\" @9 J, P6 n3 z% Y
pc[u]=pc[u]+pa[i*n+v]*pb[v*k+j];! W. c1 a! P+ g$ `; ]: U8 }! u
}: L' M/ Y! X7 O0 e. A
}
0 `( I# `/ @2 Z# D8 z5 Q0 t
}
/ M Y; k5 O7 k
FunReObj(hFor); //告诉Lu，返回一个动态对象\\" t, Q7 t2 W: @5 j( C
a.BType=luDynData_realarray; a.VType=Matrix; a.x=0; *(luVOID *)&(a.x)=(luVOID)pRealArray3;
U! `1 G0 O. a0 d) h$ M0 ^ y
break;
% V' U7 n$ i) @( V
case 25: //重载运算符.*
' N- @: g& Y7 Z$ Z' D6 e
pRealArray1=(luRealArray *)SearchKey((char *)&(xx->x),sizeof(luVOID),luDynData_realarray);
0 r: `8 h# u1 o, @
pRealArray2=(luRealArray *)SearchKey((char *)&((xx+1)->x),sizeof(luVOID),luDynData_realarray);1 I I9 f& J% L3 X& u, ^# n
if(!pRealArray1 || !pRealArray2) break; //对象句柄无效，不是实数数组
2 o0 J4 F- p' \/ M
if(pRealArray1->DimLen!=2 || pRealArray2->DimLen!=2) break; //不是二维实数数组（矩阵）, C) t2 I$ P$ @2 ?5 S3 C
if(pRealArray1->Dim[0]!=pRealArray2->Dim[0] || pRealArray1->Dim[1]!=pRealArray2->Dim[1]) break; //维数不相同
' D) z+ b' D s1 S# ?
pRealArray3=(luRealArray *)NewSysObj(luDynData_realarray,pRealArray1->ArrayLen,2); //创建矩阵对象- K, ~0 ?\\" I9 K' ~! M3 \
if(!pRealArray3) break;9 N\\" @$ P! ?7 I# H
pRealArray3->Dim[0]=pRealArray1->Dim[0]; pRealArray3->Dim[1]=pRealArray1->Dim[1]; //设置矩阵维数大小0 ^- _5 F, k' a
for(i=0;i<pRealArray1->ArrayLen;i++) pRealArray3->Array[i]=pRealArray1->Array[i]*pRealArray2->Array[i];//矩阵点乘
; m7 [% k7 I7 |9 q8 y2 e! E. I8 W
FunReObj(hFor); //告诉Lu，返回一个动态对象: L4 @\\" \0 w/ a2 z( u
a.BType=luDynData_realarray; a.VType=Matrix; a.x=0; *(luVOID *)&(a.x)=(luVOID)pRealArray3;) a& R5 I4 W5 F5 R P( c: H
break;
. T) h m( z) d+ x7 L
case 46: //重载函数new- `7 K! r) }) r* Z$ o( }8 x; \0 q6 L7 w
a=ExeOperator(mm,xx,hFor,theOperator,luDynData_realarray); //直接调用基本类型luDynData_realarray的new函数, i% A+ q D$ G, }/ C% ?: ?% b& i
if(a.VType==luDynData_realarray) a.VType=Matrix; //设置扩展类型为自定义的Matrix类型
4 d- U! W3 W/ g1 D( L8 H9 E
break; a9 m! X2 q) S
case 49: //重载函数o
) C5 p0 G* [, b; \0 j. E- T
pMessage=(luMessage)SearchKey("\0\0\0\0",sizeof(luVOID),luPubKey_User);2 a) x$ f2 s$ M+ L9 W7 L# a
if(!pMessage) break;) \. v, |, |/ b- z2 W
pRealArray1=(luRealArray *)SearchKey((char *)&(xx->x),sizeof(luVOID),luDynData_realarray);
( a* K1 e1 h5 w, l- X
if(!pRealArray1) break; //对象句柄无效，不是实数数组
' |\\" ~* U0 ^8 Q$ c; b) k9 \. @9 J9 C
if(pRealArray1->DimLen!=2) break; //不是二维实数数组（矩阵）
: f, f6 i8 u4 E3 N& i7 q2 w: C9 K9 x
pa=pRealArray1->Array;7 q2 V( {/ g' {' P y6 @5 Y; S
m=pRealArray1->Dim[0]; n=pRealArray1->Dim[1]; k=0;\\" [1 Z\\" Y+ ?, ~, l! K
for(i=0; i<m; i++) //输出矩阵0 I( w. W; Q: O' ~9 k
{
6 v& L6 f3 j/ ?: c' Z6 d# R j- [
pMessage(L"\r\n"); k+=2;
# U2 }$ ^2 ^7 C8 e! s
for(j=0; j<n; j++)
$ Y* `8 [8 O) V! _5 o
{\\" W; x- w* u: @$ f\\" {# I
_gcvt_s(chNum,pa[i*n+j],16);/ Z; M; `\\" @& e0 D
for(u=0;chNum[u];u++) {wchNum[u]=chNum[u]; k++;}. ]2 k( Q\\" D% I- E
wchNum[u]='\0';' D r* O0 d/ R- _( L
pMessage(wchNum); pMessage(L" "); k+=2;- J) D7 {; T9 e9 O: ?
}
\\" d$ @# U' z! m4 q# U) \* g
}9 k9 s+ a$ W, `
pMessage(L"\r\n"); k+=2; `- ~* Z/ G\\" g! F8 ?# A7 b/ x4 Y' M
a.BType=luStaData_int64; a.VType=luStaData_int64; a.x=k; //按函数o的要求，返回输出的字符总数
$ ]: v\\" Y9 ?* n9 l$ }
break;0 W2 d( o# Q- t3 k. c
default:* x8 Y1 W\\" A. ]0 o. _2 b
break;\\" o$ n2 ?: {8 R/ K
}5 v4 O5 H8 s9 l
return a;& N) A\\" p' |( m. D6 N+ l\\" }
}2 O2 {1 Y3 Z/ s( Y! r9 @
void main(void)
+ h' Z1 M9 @' f7 Z( c7 a\\" [9 G M
{+ Q4 @4 n) k/ m$ X2 u
void *hFor; //表达式句柄
. a/ s y3 a2 |7 W
luINT nPara; //存放表达式的自变量个数
/ t/ r) {$ a, O, l4 Z0 L0 ?3 v
LuData *pPara; //存放输入自变量的数组指针
. R9 @\\" L1 D5 k! V5 N5 W1 d9 z
luINT ErrBegin,ErrEnd; //表达式编译出错的初始位置和结束位置
$ |0 |! ?7 f- b3 C9 P. U
int ErrCode; //错误代码) d4 T. N6 j! O, F5 w! n
void *v;
+ w6 z, J: r6 V\\" P/ e/ H+ ~
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.]}";//字符串表达式，矩阵乘
% ]9 K* V! G% v1 o4 b# }
//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.]}";//字符串表达式，矩阵点乘& U+ V5 l y7 ]6 z: x
LuData Val;
if(!InitLu()) return; //初始化Lu6 Y& N I8 y7 U* T+ L0 u
while(LockKey(Matrix,DelMatrix,OpMatrix)){Matrix++;} //锁定一个键，用于存储矩阵扩展类型1 M. Y2 O! H' d\\" E; V' f$ ?
0 j: P8 ? {4 K& d5 L, O
Val.BType=luStaData_int64; Val.VType=luStaData_int64; Val.x=Matrix; //定义整数常量
' c2 q' P% ]3 W, v- a0 s8 d
SetConst(L"matrix",&Val); //设置整数常量
0 Y/ |+ ~: m' E8 @ k( v$ S
InsertKey("\0\0\0\0",4,luPubKey_User,LuMessage,NULL,NULL,1,v); //使Lu运行时可输出函数信息
2 X w6 M3 u+ L) a+ O
wcout.imbue(locale("chs")); //设置输出的locale为中文
, h4 }\\" H\\" l% v- d4 A$ k
6 L; H' \' q& G7 b5 A% F$ K
ErrCode=LuCom(ForStr,0,0,0,hFor,nPara,pPara,ErrBegin,ErrEnd); //编译表达式. H) I6 R1 M2 }! H0 k- L1 q* Y. @
if(ErrCode)- X# E& I9 I1 A# P! ~% G$ g; F/ }
{, q# B\\" I& e0 V) s) ]
wcout<<L"表达式有错误！错误代码："<<ErrCode<<endl;2 b M' c- v7 O3 p
}& T$ S2 E) T- [6 {( c9 t
else3 w) e8 O& W T\\" s' c* O; Y8 o/ v
{2 t7 d6 z; A) k% m2 L7 _6 S
LuCal(hFor,pPara); //计算表达式的值6 u+ r. {, @3 B! n& Y( P! K
}
0 r0 c2 {$ j4 E1 G( L5 b$ s) F, v4 P
LockKey(Matrix,NULL,OpMatrix);//解锁键Matrix，本例中，该函数可以不用$ r9 S6 ~\\" m! R\\" f
FreeLu(); //释放Lu% b; x\\" ]0 m5 u: u x
}

#include <windows.h> 
2 g$ N& C$ |- ]. Z! ~9 x- D
#include <iostream>8 i+ C3 v/ l0 T: V, E; X( {

#include <math.h> 
, d& ?8 W/ R\\" y0 ^/ ~( `
#include "lu32.h"  ~# Z+ a# a8 ~% t3 r) y

/ k; N7 k( {4 K\\" L: O
#pragma comment( lib, "lu32.lib" ) 
! t& y7 Q- L: J# I7 @- M
- X  t1 P4 g, T' j7 F

using namespace std;/ h6 m# a9 }0 Z; E

& O\\" g& \+ ^$ M
luKEY Matrix=-1000;        //标识矩阵类型，最终的Matrix由LockKey决定\\" Y# D4 t. p0 J2 |# ?

: X! y1 I) B; y

void _stdcall LuMessage(wchar_t *pch)//输出动态库信息，该函数注册到Lu，由Lu二级函数调用 3 U, q\\" D+ a/ d7 s! [

{ 
7 m4 i( k) o) P: P( Y3 Q: N
        wcout<<pch; 
4 ~; |* Z: O; ~) U
} 
7 ^# p! ~* m% @\\" h  m/ m: z3 D
void _stdcall DelMatrix(void *me)        //用于LockKey函数，因为是基于系统内置实数数组创建矩阵，故该函数什么也不做 
+ z$ X3 }: _2 M& A8 @4 F
{ 
% s, K' f- A, c8 v8 N* e1 M& x0 _
}+ c( G; x  t8 f3 E

LuData _stdcall OpMatrix(luINT mm,LuData *xx,void *hFor,int theOperator)        //运算符重载函数，用于LockKey函数5 f. c& K$ E' ?! S$ u% N

{! P; |, N7 {; w

LuData a;! }2 G# U# z' s2 h

luRealArray *pRealArray1,*pRealArray2,*pRealArray3; 
; O1 \/ f8 g7 e9 G\\" _( F3 }
        luVOID i,j,k,m,n,u,v; 
5 i) W, P6 e8 M\\" W; w\\" s
        double *pa,*pb,*pc;- \) M9 l8 H, v, j5 \2 m) Y

luMessage pMessage;2 A& X! G8 {2 K% s

wchar_t wchNum[32];. ?( R+ g6 v- X

char chNum[32];  L1 a% l+ i: a$ I: v

a.BType=luStaData_nil; a.VType=luStaData_nil; a.x=0; 
& p2 D$ P' a( {
        switch(theOperator) 
+ N( N: s) `# }! K7 E4 L
        {3 G# }% U  e: H# {8 G

case 2:        //重载运算符*3 |9 }! @* N& R4 y0 S' Q0 J/ o

pRealArray1=(luRealArray *)SearchKey((char *)&(xx->x),sizeof(luVOID),luDynData_realarray); 
: m7 i\\" q9 j5 z0 Y$ D9 Y0 v
                pRealArray2=(luRealArray *)SearchKey((char *)&((xx+1)->x),sizeof(luVOID),luDynData_realarray); 
7 \$ `- f: |+ G, U- M$ G
                if(!pRealArray1 || !pRealArray2) break;        //对象句柄无效，不是实数数组- |  ]1 i) P) w; M+ c

if(pRealArray1->DimLen!=2 || pRealArray2->DimLen!=2) break;        //不是二维实数数组（矩阵）' m1 X& h& H  I9 [# C\\" `

if(pRealArray1->Dim[1]!=pRealArray2->Dim[0]) break;        //维数不匹配  Z- P( F+ L' \: t( N8 p+ r

pRealArray3=(luRealArray *)NewSysObj(luDynData_realarray,pRealArray1->Dim[0]*pRealArray2->Dim[1],2);        //创建矩阵对象9 [% O\\" @# K* B  e5 {; m\\" Y

if(!pRealArray3) break;  k; \5 ?$ Z3 z

pRealArray3->Dim[0]=pRealArray1->Dim[0]; pRealArray3->Dim[1]=pRealArray2->Dim[1];        //设置矩阵维数大小 
& C2 h* e+ g* A2 e( |
                pa=pRealArray1->Array; pb=pRealArray2->Array; pc=pRealArray3->Array; 
+ \! k: d4 y9 I6 W; z1 Q% A3 D
                m=pRealArray1->Dim[0]; n=pRealArray1->Dim[1]; k=pRealArray2->Dim[1];% Q8 f+ N\\" g3 }6 r

for(i=0; i<m; i++)        //矩阵乘  G/ n$ o- ^. p, {

{ 
) ~9 p9 }/ g9 T) A4 G0 k
                        for(j=0; j<k; j++) 
, f  d8 g, P8 r% L, G
                        { 
2 X; H0 o3 @\\" C' |
                                u=i*k+j; pc[u]=0.0; 
& N, c4 }1 o0 z$ {: N) N8 y
                                for (v=0; v<n; v++) 
( t9 v2 Q9 q  u$ ^- P3 I* h3 O
                                { 
4 M% \$ W\\" @9 J, P6 n3 z% Y
                                        pc[u]=pc[u]+pa[i*n+v]*pb[v*k+j];! W. c1 a! P+ g$ `; ]: U8 }! u

}: L' M/ Y! X7 O0 e. A

} 
0 `( I# `/ @2 Z# D8 z5 Q0 t
                } 
/ M  Y; k5 O7 k
                FunReObj(hFor);        //告诉Lu，返回一个动态对象\\" t, Q7 t2 W: @5 j( C

a.BType=luDynData_realarray; a.VType=Matrix; a.x=0; *(luVOID *)&(a.x)=(luVOID)pRealArray3; 
  U! `1 G0 O. a0 d) h$ M0 ^  y
                break; 
% V' U7 n$ i) @( V
        case 25:        //重载运算符.* 
' N- @: g& Y7 Z$ Z' D6 e
                pRealArray1=(luRealArray *)SearchKey((char *)&(xx->x),sizeof(luVOID),luDynData_realarray); 
0 r: `8 h# u1 o, @
                pRealArray2=(luRealArray *)SearchKey((char *)&((xx+1)->x),sizeof(luVOID),luDynData_realarray);1 I  I9 f& J% L3 X& u, ^# n

if(!pRealArray1 || !pRealArray2) break;        //对象句柄无效，不是实数数组 
2 o0 J4 F- p' \/ M
                if(pRealArray1->DimLen!=2 || pRealArray2->DimLen!=2) break;        //不是二维实数数组（矩阵）, C) t2 I$ P$ @2 ?5 S3 C

if(pRealArray1->Dim[0]!=pRealArray2->Dim[0] || pRealArray1->Dim[1]!=pRealArray2->Dim[1]) break;        //维数不相同 
' D) z+ b' D  s1 S# ?
                pRealArray3=(luRealArray *)NewSysObj(luDynData_realarray,pRealArray1->ArrayLen,2);        //创建矩阵对象- K, ~0 ?\\" I9 K' ~! M3 \

if(!pRealArray3) break;9 N\\" @$ P! ?7 I# H

pRealArray3->Dim[0]=pRealArray1->Dim[0]; pRealArray3->Dim[1]=pRealArray1->Dim[1];        //设置矩阵维数大小0 ^- _5 F, k' a

for(i=0;i<pRealArray1->ArrayLen;i++) pRealArray3->Array[i]=pRealArray1->Array[i]*pRealArray2->Array[i];//矩阵点乘 
; m7 [% k7 I7 |9 q8 y2 e! E. I8 W
                FunReObj(hFor);        //告诉Lu，返回一个动态对象: L4 @\\" \0 w/ a2 z( u

a.BType=luDynData_realarray; a.VType=Matrix; a.x=0; *(luVOID *)&(a.x)=(luVOID)pRealArray3;) a& R5 I4 W5 F5 R  P( c: H

break; 
. T) h  m( z) d+ x7 L
        case 46:        //重载函数new- `7 K! r) }) r* Z$ o( }8 x; \0 q6 L7 w

a=ExeOperator(mm,xx,hFor,theOperator,luDynData_realarray);        //直接调用基本类型luDynData_realarray的new函数, i% A+ q  D$ G, }/ C% ?: ?% b& i

if(a.VType==luDynData_realarray) a.VType=Matrix;        //设置扩展类型为自定义的Matrix类型 
4 d- U! W3 W/ g1 D( L8 H9 E
                break;  a9 m! X2 q) S

case 49:        //重载函数o 
) C5 p0 G* [, b; \0 j. E- T
                pMessage=(luMessage)SearchKey("\0\0\0\0",sizeof(luVOID),luPubKey_User);2 a) x$ f2 s$ M+ L9 W7 L# a

if(!pMessage) break;) \. v, |, |/ b- z2 W

pRealArray1=(luRealArray *)SearchKey((char *)&(xx->x),sizeof(luVOID),luDynData_realarray); 
( a* K1 e1 h5 w, l- X
                if(!pRealArray1) break;        //对象句柄无效，不是实数数组 
' |\\" ~* U0 ^8 Q$ c; b) k9 \. @9 J9 C
                if(pRealArray1->DimLen!=2) break;        //不是二维实数数组（矩阵） 
: f, f6 i8 u4 E3 N& i7 q2 w: C9 K9 x
                pa=pRealArray1->Array;7 q2 V( {/ g' {' P  y6 @5 Y; S

m=pRealArray1->Dim[0]; n=pRealArray1->Dim[1]; k=0;\\" [1 Z\\" Y+ ?, ~, l! K

for(i=0; i<m; i++)        //输出矩阵0 I( w. W; Q: O' ~9 k

{ 
6 v& L6 f3 j/ ?: c' Z6 d# R  j- [
                        pMessage(L"\r\n"); k+=2; 
# U2 }$ ^2 ^7 C8 e! s
                        for(j=0; j<n; j++) 
$ Y* `8 [8 O) V! _5 o
                        {\\" W; x- w* u: @$ f\\" {# I

_gcvt_s(chNum,pa[i*n+j],16);/ Z; M; `\\" @& e0 D

for(u=0;chNum[u];u++) {wchNum[u]=chNum[u]; k++;}. ]2 k( Q\\" D% I- E

wchNum[u]='\0';' D  r* O0 d/ R- _( L

pMessage(wchNum); pMessage(L"  "); k+=2;- J) D7 {; T9 e9 O: ?

} 
\\" d$ @# U' z! m4 q# U) \* g
                }9 k9 s+ a$ W, `

pMessage(L"\r\n"); k+=2;  `- ~* Z/ G\\" g! F8 ?# A7 b/ x4 Y' M

a.BType=luStaData_int64; a.VType=luStaData_int64; a.x=k;        //按函数o的要求，返回输出的字符总数 
$ ]: v\\" Y9 ?* n9 l$ }
                break;0 W2 d( o# Q- t3 k. c

default:* x8 Y1 W\\" A. ]0 o. _2 b

break;\\" o$ n2 ?: {8 R/ K

}5 v4 O5 H8 s9 l

return a;& N) A\\" p' |( m. D6 N+ l\\" }

}2 O2 {1 Y3 Z/ s( Y! r9 @

void main(void) 
+ h' Z1 M9 @' f7 Z( c7 a\\" [9 G  M
{+ Q4 @4 n) k/ m$ X2 u

void *hFor;                //表达式句柄 
. a/ s  y3 a2 |7 W
        luINT nPara;                //存放表达式的自变量个数 
/ t/ r) {$ a, O, l4 Z0 L0 ?3 v
        LuData *pPara;                //存放输入自变量的数组指针 
. R9 @\\" L1 D5 k! V5 N5 W1 d9 z
        luINT ErrBegin,ErrEnd;        //表达式编译出错的初始位置和结束位置 
$ |0 |! ?7 f- b3 C9 P. U
        int ErrCode;                //错误代码) d4 T. N6 j! O, F5 w! n

void *v; 
+ w6 z, J: r6 V\\" P/ e/ H+ ~
        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.]}";//字符串表达式，矩阵乘 
% ]9 K* V! G% v1 o4 b# }
        //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.]}";//字符串表达式，矩阵点乘& U+ V5 l  y7 ]6 z: x

LuData Val; 
1 U: H8 \1 R) j8 A, U8 t7 M2 \7 s0 U% ?* z
        if(!InitLu()) return;        //初始化Lu6 Y& N  I8 y7 U* T+ L0 u

while(LockKey(Matrix,DelMatrix,OpMatrix)){Matrix++;}        //锁定一个键，用于存储矩阵扩展类型1 M. Y2 O! H' d\\" E; V' f$ ?

0 j: P8 ?  {4 K& d5 L, O
        Val.BType=luStaData_int64; Val.VType=luStaData_int64; Val.x=Matrix;        //定义整数常量 
' c2 q' P% ]3 W, v- a0 s8 d
        SetConst(L"matrix",&Val);        //设置整数常量 
0 Y/ |+ ~: m' E8 @  k( v$ S
        InsertKey("\0\0\0\0",4,luPubKey_User,LuMessage,NULL,NULL,1,v); //使Lu运行时可输出函数信息 
2 X  w6 M3 u+ L) a+ O
        wcout.imbue(locale("chs"));        //设置输出的locale为中文 
, h4 }\\" H\\" l% v- d4 A$ k
  6 L; H' \' q& G7 b5 A% F$ K

ErrCode=LuCom(ForStr,0,0,0,hFor,nPara,pPara,ErrBegin,ErrEnd); //编译表达式. H) I6 R1 M2 }! H0 k- L1 q* Y. @

if(ErrCode)- X# E& I9 I1 A# P! ~% G$ g; F/ }

{, q# B\\" I& e0 V) s) ]

wcout<<L"表达式有错误！错误代码："<<ErrCode<<endl;2 b  M' c- v7 O3 p

}& T$ S2 E) T- [6 {( c9 t

else3 w) e8 O& W  T\\" s' c* O; Y8 o/ v

{2 t7 d6 z; A) k% m2 L7 _6 S

LuCal(hFor,pPara);        //计算表达式的值6 u+ r. {, @3 B! n& Y( P! K

} 
0 r0 c2 {$ j4 E1 G( L5 b$ s) F, v4 P
        LockKey(Matrix,NULL,OpMatrix);//解锁键Matrix，本例中，该函数可以不用$ r9 S6 ~\\" m! R\\" f

FreeLu();                        //释放Lu% b; x\\" ]0 m5 u: u  x

}

习题：

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

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

main(:a,b,c,d,t,i)= k: o\" Y0 |# W) `: ^
a=new[matrix,2,2,data:1.,2.,2.,1.],
\" {: ~/ `8 G1 i# {8 L& S. N
b=new[matrix,2,2,data:2.,1.,1.,2.],
8 F' ~) y+ A# B\" ^, G$ a
c=new[matrix,2,2,data:2/3.,-1/3.,-1/3.,2/3.],8 \* \3 @9 L4 ~. \; j6 u8 i8 x1 }6 g
t=clock(),
4 C4 A* @# p, ^5 t& \
d=a*b, i=0, while{i<1000000, d=d*c*b, i++},
0 U. V; |0 R$ E8 W
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\"}";//字符串表达式

复制代码

结果：