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

查看: 8686|回复: 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>
$ e8 b1 d8 j3 r1 d ]1 c# ^5 @4 {
#include <iostream>& K; L9 ] ]+ P# [5 w1 G
#include <math.h>
8 ^' v, d\\" }( w6 M6 W; a
#include "lu32.h"' d% G8 f0 ~# @' M) ^; e0 Z
\\" ]! v# f- n3 I5 i5 D- J
#pragma comment( lib, "lu32.lib" )0 u( [5 S7 J8 ?8 X6 |; `# Z7 U
R! l) Q* e& d: s# u/ [) o* o1 u0 Q
using namespace std;4 A- B8 j( L! D' K
0 h% H# z$ ]8 `- N7 U
luKEY Matrix=-1000; //标识矩阵类型，最终的Matrix由LockKey决定\\" k5 Z8 P! u1 ], w4 h0 D: L* ^5 F
) B1 D* Z+ V0 M, U, w4 _8 }, N! N
void _stdcall LuMessage(wchar_t *pch)//输出动态库信息，该函数注册到Lu，由Lu二级函数调用 ) a7 n( m8 F) r2 z\\" h3 y; y% O. o H
{8 B4 W2 S; [( i
wcout<<pch;
# F/ Y6 C1 M; r
}
# B9 W9 h1 l+ A; i0 I
void _stdcall DelMatrix(void *me) //用于LockKey函数，因为是基于系统内置实数数组创建矩阵，故该函数什么也不做& E- E) n! E\\" a* y- {
{4 t3 u( r\\" \6 Q
}
2 t6 l& F: P$ H7 n; t% V
LuData _stdcall OpMatrix(luINT mm,LuData *xx,void *hFor,int theOperator) //运算符重载函数，用于LockKey函数3 x' g. ~$ ]/ f; `1 }; a
{: \/ U7 _/ `7 {& n
LuData a;\\" A$ n\\" j8 c. b! A\\" |% `
luRealArray *pRealArray1,*pRealArray2,*pRealArray3;
, k+ b7 c& q+ g5 G% o( s4 N
luVOID i,j,k,m,n,u,v;, ?+ @* N8 [\\" Y' N3 z
double *pa,*pb,*pc;1 [' b4 U# V* I
luMessage pMessage;
. h( @$ U, h& S* K, T- ~+ H
wchar_t wchNum[32];
/ _8 P8 R9 T8 J5 Y$ D' R! r
char chNum[32];& ]* q1 C7 \5 h, C4 _9 }* m
a.BType=luStaData_nil; a.VType=luStaData_nil; a.x=0;/ g3 M; U: {1 R* j/ L7 ?, P) v- |
switch(theOperator)
/ I7 r: S: V' N& z
{8 \; e) T) M! }
case 2: //重载运算符*
/ |: e4 U. I2 m* T6 s1 X% |6 g* @
pRealArray1=(luRealArray *)SearchKey((char *)&(xx->x),sizeof(luVOID),luDynData_realarray);; o1 \3 D\\" A8 v4 }7 ] M
pRealArray2=(luRealArray *)SearchKey((char *)&((xx+1)->x),sizeof(luVOID),luDynData_realarray);
# X: \3 R+ j: C% I8 i$ ?
if(!pRealArray1 || !pRealArray2) break; //对象句柄无效，不是实数数组
! A/ u+ F E; F1 d\\" ~+ @
if(pRealArray1->DimLen!=2 || pRealArray2->DimLen!=2) break; //不是二维实数数组（矩阵）( y\\" y# Q( o% e1 R0 \; R
if(pRealArray1->Dim[1]!=pRealArray2->Dim[0]) break; //维数不匹配
. T' Z* A\\" i# w+ x
pRealArray3=(luRealArray *)NewSysObj(luDynData_realarray,pRealArray1->Dim[0]*pRealArray2->Dim[1],2); //创建矩阵对象
# A, s/ _- s5 U) S! e
if(!pRealArray3) break;
- P9 M& e; P1 L4 W
pRealArray3->Dim[0]=pRealArray1->Dim[0]; pRealArray3->Dim[1]=pRealArray2->Dim[1]; //设置矩阵维数大小9 n6 j: x! V- {$ H* b5 i
pa=pRealArray1->Array; pb=pRealArray2->Array; pc=pRealArray3->Array;; B7 T6 A' K% P1 ^/ N9 E( e
m=pRealArray1->Dim[0]; n=pRealArray1->Dim[1]; k=pRealArray2->Dim[1];
9 P# J9 I/ f' S\\" B5 E
for(i=0; i<m; i++) //矩阵乘0 J% X' w) }4 c0 t, c$ S7 @
{0 w, `4 s& d4 L! i: }2 H1 @! Z
for(j=0; j<k; j++)
, [4 Z( m- b8 j% ]2 l
{, H) _6 q. ]8 u
u=i*k+j; pc[u]=0.0;
( b% i g+ s: s
for (v=0; v<n; v++)
! Y5 q0 {: @ w, h e6 [( l' [
{7 e\\" h( A; h- {) z2 Y
pc[u]=pc[u]+pa[i*n+v]*pb[v*k+j];
2 I, o: S: O0 j0 I& K3 u; R
}
5 R1 m, Y$ B6 ~2 j0 ?5 B% B
}
\\" y- _. l6 z. y$ b/ {( ^5 t
}* | \+ ~# _- d9 H4 A( m
FunReObj(hFor); //告诉Lu，返回一个动态对象+ N+ Z+ J+ o' T. X3 c1 z- ]/ e
a.BType=luDynData_realarray; a.VType=Matrix; a.x=0; *(luVOID *)&(a.x)=(luVOID)pRealArray3;
V; v1 \ i+ M% B
break;/ ]$ _/ @7 m2 E: h: ~/ U
case 25: //重载运算符.*& ]0 g! |0 t) l0 w1 C8 [4 c! F5 Y s
pRealArray1=(luRealArray *)SearchKey((char *)&(xx->x),sizeof(luVOID),luDynData_realarray);\\" v: @& h5 M+ U1 \$ U4 G8 k
pRealArray2=(luRealArray *)SearchKey((char *)&((xx+1)->x),sizeof(luVOID),luDynData_realarray); d% P+ I, \\\" ?& _2 P5 s: |
if(!pRealArray1 || !pRealArray2) break; //对象句柄无效，不是实数数组
# S6 m: i/ ~: c8 V
if(pRealArray1->DimLen!=2 || pRealArray2->DimLen!=2) break; //不是二维实数数组（矩阵）; b( v8 v\\" ]9 C2 K
if(pRealArray1->Dim[0]!=pRealArray2->Dim[0] || pRealArray1->Dim[1]!=pRealArray2->Dim[1]) break; //维数不相同* R [. g\\" @! y- Z
pRealArray3=(luRealArray *)NewSysObj(luDynData_realarray,pRealArray1->ArrayLen,2); //创建矩阵对象
) k1 N+ d+ M: j& ]+ n
if(!pRealArray3) break;
! b$ R1 s. V0 V. C1 _) P
pRealArray3->Dim[0]=pRealArray1->Dim[0]; pRealArray3->Dim[1]=pRealArray1->Dim[1]; //设置矩阵维数大小
6 i3 \% w* a+ F M, F4 W
for(i=0;i<pRealArray1->ArrayLen;i++) pRealArray3->Array[i]=pRealArray1->Array[i]*pRealArray2->Array[i];//矩阵点乘
* P. p0 e+ V8 W4 \* n
FunReObj(hFor); //告诉Lu，返回一个动态对象
4 S8 p7 G( ~\\" v+ ~6 q% Z2 m8 n
a.BType=luDynData_realarray; a.VType=Matrix; a.x=0; *(luVOID *)&(a.x)=(luVOID)pRealArray3;
, S% }/ N8 g! v! o2 }* X2 m; P- f
break;! u8 }: \# @) t6 z8 y6 j
case 46: //重载函数new9 g) [. M4 q: m# a, o
a=ExeOperator(mm,xx,hFor,theOperator,luDynData_realarray); //直接调用基本类型luDynData_realarray的new函数% o+ Z# ?4 k! m& J
if(a.VType==luDynData_realarray) a.VType=Matrix; //设置扩展类型为自定义的Matrix类型- V% z. f' r# Y' ]+ Z
break;9 c- G6 [ I: X4 `1 g3 N
case 49: //重载函数o8 S! g. C& v, c7 D! b- I* R( r
pMessage=(luMessage)SearchKey("\0\0\0\0",sizeof(luVOID),luPubKey_User);7 J; s1 Q0 D: y
if(!pMessage) break;
& \* Z7 N3 q& a/ s4 j% h
pRealArray1=(luRealArray *)SearchKey((char *)&(xx->x),sizeof(luVOID),luDynData_realarray);
. F$ r* X/ r/ T5 `) O8 B3 X
if(!pRealArray1) break; //对象句柄无效，不是实数数组
$ M. A$ B/ n1 m0 \
if(pRealArray1->DimLen!=2) break; //不是二维实数数组（矩阵）
0 a( U1 Y% i3 `
pa=pRealArray1->Array;3 G Y/ [, l# m! X
m=pRealArray1->Dim[0]; n=pRealArray1->Dim[1]; k=0;, w$ o; Y0 j/ K8 {6 v
for(i=0; i<m; i++) //输出矩阵1 T7 m# l; m+ ?0 h$ |+ x% |
{
% D! Q l9 G4 g& s/ W; k
pMessage(L"\r\n"); k+=2;! J. U% r# R2 e; w
for(j=0; j<n; j++)
' h' _& {! X- E; z3 l
{\\" p, }( f\\" w: H( R/ ]# M
_gcvt_s(chNum,pa[i*n+j],16);
( m( B5 w' `1 H8 k2 m! @: B
for(u=0;chNum[u];u++) {wchNum[u]=chNum[u]; k++;}: F1 z\\" C9 t% m! m% E
wchNum[u]='\0';\\" ^/ ]9 X# @+ P% `5 C+ T
pMessage(wchNum); pMessage(L" "); k+=2;9 u. C. c/ r3 ]3 _
}- m1 S7 j+ Y2 U) s$ l
}' p. L+ \ G9 K c. V
pMessage(L"\r\n"); k+=2;
! t& U\\" g% T4 f5 }6 q' z t
a.BType=luStaData_int64; a.VType=luStaData_int64; a.x=k; //按函数o的要求，返回输出的字符总数
! F\\" P. s4 {$ z
break;6 |3 b( Z, S* O3 e4 p\\" q: y+ u
default:' ~+ w& ~# B7 R6 v% a0 b' k! C5 W
break; l* Z Z/ Y% o- Q$ y& h3 V' y- N6 a
}& K: z4 O0 G) D6 v& ^
return a;
1 k8 H8 z/ D8 U/ G- H' Z9 V
}& j4 y* h6 C* p/ i# H4 C5 X
void main(void)\\" Y% Z3 D7 r) ^: z
{
2 N3 q( q/ J- N9 n j; A! D; M
void *hFor; //表达式句柄& n& |' P0 L: n/ Y0 Z; D
luINT nPara; //存放表达式的自变量个数- i+ k# Z9 Y2 [) y, Q; J0 ?, j
LuData *pPara; //存放输入自变量的数组指针% ]& w9 I$ y0 z Z( R! ~
luINT ErrBegin,ErrEnd; //表达式编译出错的初始位置和结束位置
; ^3 m* b+ V% W6 k# i# G$ Z
int ErrCode; //错误代码
/ h* f. `* p& M
void *v;
( n J( L5 o. M& g: }/ P+ K1 n
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 ~1 S; k4 w$ \5 z
//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. @ P; p$ E
LuData Val;
/ a2 o6 j4 z# |$ z. g
if(!InitLu()) return; //初始化Lu4 G6 F- P+ O P+ U, E
while(LockKey(Matrix,DelMatrix,OpMatrix)){Matrix++;} //锁定一个键，用于存储矩阵扩展类型
2 B, ^\\" F/ |$ u) w( b
& E w- @. R e$ f' v5 F
Val.BType=luStaData_int64; Val.VType=luStaData_int64; Val.x=Matrix; //定义整数常量5 @9 q\\" g4 s; ~' ~, T/ V5 e
SetConst(L"matrix",&Val); //设置整数常量
/ O. m! g- j( t' R3 r L( Z
InsertKey("\0\0\0\0",4,luPubKey_User,LuMessage,NULL,NULL,1,v); //使Lu运行时可输出函数信息8 K! s& O* v) Z. V+ E
wcout.imbue(locale("chs")); //设置输出的locale为中文# y9 n, U' [' Q! `
- P% X0 o5 t7 Y6 `$ e) @3 W
ErrCode=LuCom(ForStr,0,0,0,hFor,nPara,pPara,ErrBegin,ErrEnd); //编译表达式
. T% E: T3 e, a* z
if(ErrCode)& {7 @0 i7 c8 D& v
{7 Z- F' o3 v+ H6 b; }6 J2 _
wcout<<L"表达式有错误！错误代码："<<ErrCode<<endl;
2 s5 A# C9 x% h
}- p$ Z& a0 |* J- w3 g
else
# B. S, W: G2 @5 l) P
{
9 P0 b5 ^) j5 u9 \\\" Z+ k& A
LuCal(hFor,pPara); //计算表达式的值2 q0 d0 N5 R/ q# |3 Q; \) {4 u
}
6 ]4 r, A7 {% s9 a |% v \
LockKey(Matrix,NULL,OpMatrix);//解锁键Matrix，本例中，该函数可以不用
. d Y5 h5 O' g1 J
FreeLu(); //释放Lu
0 ]1 R& ^- |# [- Z
}

#include <windows.h> 
$ e8 b1 d8 j3 r1 d  ]1 c# ^5 @4 {
#include <iostream>& K; L9 ]  ]+ P# [5 w1 G

#include <math.h> 
8 ^' v, d\\" }( w6 M6 W; a
#include "lu32.h"' d% G8 f0 ~# @' M) ^; e0 Z

\\" ]! v# f- n3 I5 i5 D- J
#pragma comment( lib, "lu32.lib" )0 u( [5 S7 J8 ?8 X6 |; `# Z7 U

R! l) Q* e& d: s# u/ [) o* o1 u0 Q
using namespace std;4 A- B8 j( L! D' K

0 h% H# z$ ]8 `- N7 U

luKEY Matrix=-1000;        //标识矩阵类型，最终的Matrix由LockKey决定\\" k5 Z8 P! u1 ], w4 h0 D: L* ^5 F

) B1 D* Z+ V0 M, U, w4 _8 }, N! N

void _stdcall LuMessage(wchar_t *pch)//输出动态库信息，该函数注册到Lu，由Lu二级函数调用 ) a7 n( m8 F) r2 z\\" h3 y; y% O. o  H

{8 B4 W2 S; [( i

wcout<<pch; 
# F/ Y6 C1 M; r
} 
# B9 W9 h1 l+ A; i0 I
void _stdcall DelMatrix(void *me)        //用于LockKey函数，因为是基于系统内置实数数组创建矩阵，故该函数什么也不做& E- E) n! E\\" a* y- {

{4 t3 u( r\\" \6 Q

} 
2 t6 l& F: P$ H7 n; t% V
LuData _stdcall OpMatrix(luINT mm,LuData *xx,void *hFor,int theOperator)        //运算符重载函数，用于LockKey函数3 x' g. ~$ ]/ f; `1 }; a

{: \/ U7 _/ `7 {& n

LuData a;\\" A$ n\\" j8 c. b! A\\" |% `

luRealArray *pRealArray1,*pRealArray2,*pRealArray3; 
, k+ b7 c& q+ g5 G% o( s4 N
        luVOID i,j,k,m,n,u,v;, ?+ @* N8 [\\" Y' N3 z

double *pa,*pb,*pc;1 [' b4 U# V* I

luMessage pMessage; 
. h( @$ U, h& S* K, T- ~+ H
        wchar_t wchNum[32]; 
/ _8 P8 R9 T8 J5 Y$ D' R! r
        char chNum[32];& ]* q1 C7 \5 h, C4 _9 }* m

a.BType=luStaData_nil; a.VType=luStaData_nil; a.x=0;/ g3 M; U: {1 R* j/ L7 ?, P) v- |

switch(theOperator) 
/ I7 r: S: V' N& z
        {8 \; e) T) M! }

case 2:        //重载运算符* 
/ |: e4 U. I2 m* T6 s1 X% |6 g* @
                pRealArray1=(luRealArray *)SearchKey((char *)&(xx->x),sizeof(luVOID),luDynData_realarray);; o1 \3 D\\" A8 v4 }7 ]  M

pRealArray2=(luRealArray *)SearchKey((char *)&((xx+1)->x),sizeof(luVOID),luDynData_realarray); 
# X: \3 R+ j: C% I8 i$ ?
                if(!pRealArray1 || !pRealArray2) break;        //对象句柄无效，不是实数数组 
! A/ u+ F  E; F1 d\\" ~+ @
                if(pRealArray1->DimLen!=2 || pRealArray2->DimLen!=2) break;        //不是二维实数数组（矩阵）( y\\" y# Q( o% e1 R0 \; R

if(pRealArray1->Dim[1]!=pRealArray2->Dim[0]) break;        //维数不匹配 
. T' Z* A\\" i# w+ x
                pRealArray3=(luRealArray *)NewSysObj(luDynData_realarray,pRealArray1->Dim[0]*pRealArray2->Dim[1],2);        //创建矩阵对象 
# A, s/ _- s5 U) S! e
                if(!pRealArray3) break; 
- P9 M& e; P1 L4 W
                pRealArray3->Dim[0]=pRealArray1->Dim[0]; pRealArray3->Dim[1]=pRealArray2->Dim[1];        //设置矩阵维数大小9 n6 j: x! V- {$ H* b5 i

pa=pRealArray1->Array; pb=pRealArray2->Array; pc=pRealArray3->Array;; B7 T6 A' K% P1 ^/ N9 E( e

m=pRealArray1->Dim[0]; n=pRealArray1->Dim[1]; k=pRealArray2->Dim[1]; 
9 P# J9 I/ f' S\\" B5 E
                for(i=0; i<m; i++)        //矩阵乘0 J% X' w) }4 c0 t, c$ S7 @

{0 w, `4 s& d4 L! i: }2 H1 @! Z

for(j=0; j<k; j++) 
, [4 Z( m- b8 j% ]2 l
                        {, H) _6 q. ]8 u

u=i*k+j; pc[u]=0.0; 
( b% i  g+ s: s
                                for (v=0; v<n; v++) 
! Y5 q0 {: @  w, h  e6 [( l' [
                                {7 e\\" h( A; h- {) z2 Y

pc[u]=pc[u]+pa[i*n+v]*pb[v*k+j]; 
2 I, o: S: O0 j0 I& K3 u; R
                                } 
5 R1 m, Y$ B6 ~2 j0 ?5 B% B
                        } 
\\" y- _. l6 z. y$ b/ {( ^5 t
                }* |  \+ ~# _- d9 H4 A( m

FunReObj(hFor);        //告诉Lu，返回一个动态对象+ N+ Z+ J+ o' T. X3 c1 z- ]/ e

a.BType=luDynData_realarray; a.VType=Matrix; a.x=0; *(luVOID *)&(a.x)=(luVOID)pRealArray3; 
  V; v1 \  i+ M% B
                break;/ ]$ _/ @7 m2 E: h: ~/ U

case 25:        //重载运算符.*& ]0 g! |0 t) l0 w1 C8 [4 c! F5 Y  s

pRealArray1=(luRealArray *)SearchKey((char *)&(xx->x),sizeof(luVOID),luDynData_realarray);\\" v: @& h5 M+ U1 \$ U4 G8 k

pRealArray2=(luRealArray *)SearchKey((char *)&((xx+1)->x),sizeof(luVOID),luDynData_realarray);  d% P+ I, \\\" ?& _2 P5 s: |

if(!pRealArray1 || !pRealArray2) break;        //对象句柄无效，不是实数数组 
# S6 m: i/ ~: c8 V
                if(pRealArray1->DimLen!=2 || pRealArray2->DimLen!=2) break;        //不是二维实数数组（矩阵）; b( v8 v\\" ]9 C2 K

if(pRealArray1->Dim[0]!=pRealArray2->Dim[0] || pRealArray1->Dim[1]!=pRealArray2->Dim[1]) break;        //维数不相同* R  [. g\\" @! y- Z

pRealArray3=(luRealArray *)NewSysObj(luDynData_realarray,pRealArray1->ArrayLen,2);        //创建矩阵对象 
) k1 N+ d+ M: j& ]+ n
                if(!pRealArray3) break; 
! b$ R1 s. V0 V. C1 _) P
                pRealArray3->Dim[0]=pRealArray1->Dim[0]; pRealArray3->Dim[1]=pRealArray1->Dim[1];        //设置矩阵维数大小 
6 i3 \% w* a+ F  M, F4 W
                for(i=0;i<pRealArray1->ArrayLen;i++) pRealArray3->Array[i]=pRealArray1->Array[i]*pRealArray2->Array[i];//矩阵点乘 
* P. p0 e+ V8 W4 \* n
                FunReObj(hFor);        //告诉Lu，返回一个动态对象 
4 S8 p7 G( ~\\" v+ ~6 q% Z2 m8 n
                a.BType=luDynData_realarray; a.VType=Matrix; a.x=0; *(luVOID *)&(a.x)=(luVOID)pRealArray3; 
, S% }/ N8 g! v! o2 }* X2 m; P- f
                break;! u8 }: \# @) t6 z8 y6 j

case 46:        //重载函数new9 g) [. M4 q: m# a, o

a=ExeOperator(mm,xx,hFor,theOperator,luDynData_realarray);        //直接调用基本类型luDynData_realarray的new函数% o+ Z# ?4 k! m& J

if(a.VType==luDynData_realarray) a.VType=Matrix;        //设置扩展类型为自定义的Matrix类型- V% z. f' r# Y' ]+ Z

break;9 c- G6 [  I: X4 `1 g3 N

case 49:        //重载函数o8 S! g. C& v, c7 D! b- I* R( r

pMessage=(luMessage)SearchKey("\0\0\0\0",sizeof(luVOID),luPubKey_User);7 J; s1 Q0 D: y

if(!pMessage) break; 
& \* Z7 N3 q& a/ s4 j% h
                pRealArray1=(luRealArray *)SearchKey((char *)&(xx->x),sizeof(luVOID),luDynData_realarray); 
. F$ r* X/ r/ T5 `) O8 B3 X
                if(!pRealArray1) break;        //对象句柄无效，不是实数数组 
$ M. A$ B/ n1 m0 \
                if(pRealArray1->DimLen!=2) break;        //不是二维实数数组（矩阵） 
0 a( U1 Y% i3 `
                pa=pRealArray1->Array;3 G  Y/ [, l# m! X

m=pRealArray1->Dim[0]; n=pRealArray1->Dim[1]; k=0;, w$ o; Y0 j/ K8 {6 v

for(i=0; i<m; i++)        //输出矩阵1 T7 m# l; m+ ?0 h$ |+ x% |

{ 
% D! Q  l9 G4 g& s/ W; k
                        pMessage(L"\r\n"); k+=2;! J. U% r# R2 e; w

for(j=0; j<n; j++) 
' h' _& {! X- E; z3 l
                        {\\" p, }( f\\" w: H( R/ ]# M

_gcvt_s(chNum,pa[i*n+j],16); 
( m( B5 w' `1 H8 k2 m! @: B
                                for(u=0;chNum[u];u++) {wchNum[u]=chNum[u]; k++;}: F1 z\\" C9 t% m! m% E

wchNum[u]='\0';\\" ^/ ]9 X# @+ P% `5 C+ T

pMessage(wchNum); pMessage(L"  "); k+=2;9 u. C. c/ r3 ]3 _

}- m1 S7 j+ Y2 U) s$ l

}' p. L+ \  G9 K  c. V

pMessage(L"\r\n"); k+=2; 
! t& U\\" g% T4 f5 }6 q' z  t
                a.BType=luStaData_int64; a.VType=luStaData_int64; a.x=k;        //按函数o的要求，返回输出的字符总数 
! F\\" P. s4 {$ z
                break;6 |3 b( Z, S* O3 e4 p\\" q: y+ u

default:' ~+ w& ~# B7 R6 v% a0 b' k! C5 W

break;  l* Z  Z/ Y% o- Q$ y& h3 V' y- N6 a

}& K: z4 O0 G) D6 v& ^

return a; 
1 k8 H8 z/ D8 U/ G- H' Z9 V
}& j4 y* h6 C* p/ i# H4 C5 X

void main(void)\\" Y% Z3 D7 r) ^: z

{ 
2 N3 q( q/ J- N9 n  j; A! D; M
        void *hFor;                //表达式句柄& n& |' P0 L: n/ Y0 Z; D

luINT nPara;                //存放表达式的自变量个数- i+ k# Z9 Y2 [) y, Q; J0 ?, j

LuData *pPara;                //存放输入自变量的数组指针% ]& w9 I$ y0 z  Z( R! ~

luINT ErrBegin,ErrEnd;        //表达式编译出错的初始位置和结束位置 
; ^3 m* b+ V% W6 k# i# G$ Z
        int ErrCode;                //错误代码 
/ h* f. `* p& M
        void *v; 
( n  J( L5 o. M& g: }/ P+ K1 n
        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 ~1 S; k4 w$ \5 z
        //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. @  P; p$ E
        LuData Val; 
/ a2 o6 j4 z# |$ z. g
        if(!InitLu()) return;        //初始化Lu4 G6 F- P+ O  P+ U, E

while(LockKey(Matrix,DelMatrix,OpMatrix)){Matrix++;}        //锁定一个键，用于存储矩阵扩展类型 
2 B, ^\\" F/ |$ u) w( b
 
& E  w- @. R  e$ f' v5 F
        Val.BType=luStaData_int64; Val.VType=luStaData_int64; Val.x=Matrix;        //定义整数常量5 @9 q\\" g4 s; ~' ~, T/ V5 e

SetConst(L"matrix",&Val);        //设置整数常量 
/ O. m! g- j( t' R3 r  L( Z
        InsertKey("\0\0\0\0",4,luPubKey_User,LuMessage,NULL,NULL,1,v); //使Lu运行时可输出函数信息8 K! s& O* v) Z. V+ E

wcout.imbue(locale("chs"));        //设置输出的locale为中文# y9 n, U' [' Q! `

- P% X0 o5 t7 Y6 `$ e) @3 W

ErrCode=LuCom(ForStr,0,0,0,hFor,nPara,pPara,ErrBegin,ErrEnd); //编译表达式 
. T% E: T3 e, a* z
        if(ErrCode)& {7 @0 i7 c8 D& v

{7 Z- F' o3 v+ H6 b; }6 J2 _

wcout<<L"表达式有错误！错误代码："<<ErrCode<<endl; 
2 s5 A# C9 x% h
        }- p$ Z& a0 |* J- w3 g

else 
# B. S, W: G2 @5 l) P
        { 
9 P0 b5 ^) j5 u9 \\\" Z+ k& A
                LuCal(hFor,pPara);        //计算表达式的值2 q0 d0 N5 R/ q# |3 Q; \) {4 u

} 
6 ]4 r, A7 {% s9 a  |% v  \
        LockKey(Matrix,NULL,OpMatrix);//解锁键Matrix，本例中，该函数可以不用 
. d  Y5 h5 O' g1 J
        FreeLu();                        //释放Lu 
0 ]1 R& ^- |# [- Z
}

习题：

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

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

main(:a,b,c,d,t,i)=
# z9 `0 y, }- x, p7 K; F
a=new[matrix,2,2,data:1.,2.,2.,1.],
8 ~/ K% _+ a( `, P9 c
b=new[matrix,2,2,data:2.,1.,1.,2.],
. l/ X9 J' F\" K: T# [
c=new[matrix,2,2,data:2/3.,-1/3.,-1/3.,2/3.],
3 B# h' H\" V& k0 e+ w0 x
t=clock(),% N. q0 e- U# W) A8 J
d=a*b, i=0, while{i<1000000, d=d*c*b, i++},
. K' `9 U* u7 U- 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\"}";//字符串表达式

复制代码

结果：