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

查看: 8515|回复: 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>$ ^1 i9 }, n& ?& J
#include <iostream># T# c9 s. C: N2 v+ K
#include <math.h>
) g6 a* d$ L- d! ]% x
#include "lu32.h"& ^2 c( n- } t3 m
( b; B: Y) g% F8 C7 @! r7 }
#pragma comment( lib, "lu32.lib" )
1 m* O0 Q1 I6 f# n( F6 q
! y8 i/ p7 C4 p' ]6 ^1 E
using namespace std;
$ `/ J; c% K' ?
1 i+ e) N\\" P8 `% R
luKEY Matrix=-1000; //标识矩阵类型，最终的Matrix由LockKey决定1 ^& H8 t, k. [- T7 @, ^
; m( L/ B: [4 A% `1 q8 q7 W
void _stdcall LuMessage(wchar_t *pch)//输出动态库信息，该函数注册到Lu，由Lu二级函数调用
: x+ [: v0 m3 a! B m' A4 X
{
! v3 Q' d+ k6 s: R- Y
wcout<<pch;
8 N7 K( u+ F5 x9 U, i0 b
}
1 @: y# S4 T; V# S
void _stdcall DelMatrix(void *me) //用于LockKey函数，因为是基于系统内置实数数组创建矩阵，故该函数什么也不做
7 u% @$ e2 b# h# y3 x% W# B
{
# e2 [1 v! X% Y% @# [, l4 R6 Y: G1 }- p
}- p0 d' w# e9 H- o: |4 o* t
LuData _stdcall OpMatrix(luINT mm,LuData *xx,void *hFor,int theOperator) //运算符重载函数，用于LockKey函数
) L5 \# R. [8 T$ p\\" V
{0 q. B6 s9 L9 X
LuData a;, g3 m6 X8 F- _. k
luRealArray *pRealArray1,*pRealArray2,*pRealArray3;9 V+ [, H5 T9 a3 v- [+ x1 P
luVOID i,j,k,m,n,u,v;
# ~/ M5 l: z: V1 S, ^. q
double *pa,*pb,*pc;, }# N) W( a& x\\" U* g
luMessage pMessage;- H( o( e |5 T. K
wchar_t wchNum[32];
- O: v) C. E7 `8 q
char chNum[32];
+ {0 U) w8 Y* L( I& S
a.BType=luStaData_nil; a.VType=luStaData_nil; a.x=0;1 H; A2 c- m8 X2 `6 t% Y
switch(theOperator)
& U# U- g7 ]. l9 _5 e# p
{
; ^- l# ]/ v7 @) Z6 O* W
case 2: //重载运算符*
\\" G\\" g/ J- y4 ^/ c
pRealArray1=(luRealArray *)SearchKey((char *)&(xx->x),sizeof(luVOID),luDynData_realarray);
\\" D, E5 K1 g6 A
pRealArray2=(luRealArray *)SearchKey((char *)&((xx+1)->x),sizeof(luVOID),luDynData_realarray);\\" {7 E A2 r. ?! i0 X+ a8 S7 i
if(!pRealArray1 || !pRealArray2) break; //对象句柄无效，不是实数数组
' y; M+ U/ J- ~1 ^: _\\" ~9 {
if(pRealArray1->DimLen!=2 || pRealArray2->DimLen!=2) break; //不是二维实数数组（矩阵）
4 B\\" e3 X\\" E; g5 b1 h6 e! f
if(pRealArray1->Dim[1]!=pRealArray2->Dim[0]) break; //维数不匹配
( W4 N. r Z* c$ J$ w9 J: h
pRealArray3=(luRealArray *)NewSysObj(luDynData_realarray,pRealArray1->Dim[0]*pRealArray2->Dim[1],2); //创建矩阵对象
) G; u' T, ~! ^: t- Q
if(!pRealArray3) break;
* U C; _\\" J% N5 q
pRealArray3->Dim[0]=pRealArray1->Dim[0]; pRealArray3->Dim[1]=pRealArray2->Dim[1]; //设置矩阵维数大小8 A. a3 [/ X. H- V# `
pa=pRealArray1->Array; pb=pRealArray2->Array; pc=pRealArray3->Array;\\" n: r# ?- H4 ]& H1 b' U$ O# ^9 X
m=pRealArray1->Dim[0]; n=pRealArray1->Dim[1]; k=pRealArray2->Dim[1];2 B; v1 R/ x: t\\" I8 V- }% h* d; L
for(i=0; i<m; i++) //矩阵乘
* m! X- ?* p# N1 Q
{
2 u9 E3 m- E h/ p
for(j=0; j<k; j++) r, e6 W }$ d
{# P3 j* j. s0 H6 ^
u=i*k+j; pc[u]=0.0;
, R: a) n3 N! [* a
for (v=0; v<n; v++)* {; U3 D% C7 g1 G5 S) ?
{: ]7 G: c1 U, k$ b4 s4 d
pc[u]=pc[u]+pa[i*n+v]*pb[v*k+j];* q2 q1 P( I# P. g1 _& A
}
1 |. g3 J- E) \# ?0 K
}
8 J8 p3 \$ h0 c2 N& d6 h: c$ h
}; \6 ^, y6 b$ Q( `; N
FunReObj(hFor); //告诉Lu，返回一个动态对象
7 m# a) m) A2 ^; G
a.BType=luDynData_realarray; a.VType=Matrix; a.x=0; *(luVOID *)&(a.x)=(luVOID)pRealArray3;* K2 N% R0 v# g; [/ Q5 z
break;6 Z G' z+ {\\" i/ m! ]8 ^
case 25: //重载运算符.*\\" e( c t5 i2 ^! K: S' X) Z
pRealArray1=(luRealArray *)SearchKey((char *)&(xx->x),sizeof(luVOID),luDynData_realarray);8 [1 s' ^ U* V8 {
pRealArray2=(luRealArray *)SearchKey((char *)&((xx+1)->x),sizeof(luVOID),luDynData_realarray);
- R0 q, Z# G U/ p6 @
if(!pRealArray1 || !pRealArray2) break; //对象句柄无效，不是实数数组$ ` H; `8 N# L+ {9 A# S# \7 A
if(pRealArray1->DimLen!=2 || pRealArray2->DimLen!=2) break; //不是二维实数数组（矩阵）: G7 q& ?1 W- o; u- y. O
if(pRealArray1->Dim[0]!=pRealArray2->Dim[0] || pRealArray1->Dim[1]!=pRealArray2->Dim[1]) break; //维数不相同
9 ?& i$ N0 b$ M! S
pRealArray3=(luRealArray *)NewSysObj(luDynData_realarray,pRealArray1->ArrayLen,2); //创建矩阵对象
% ?3 {0 x6 @8 I
if(!pRealArray3) break;' l! C' k, K/ Y( T, J( y! R
pRealArray3->Dim[0]=pRealArray1->Dim[0]; pRealArray3->Dim[1]=pRealArray1->Dim[1]; //设置矩阵维数大小
; ]% O& Z8 v- a( D; _4 j# a
for(i=0;i<pRealArray1->ArrayLen;i++) pRealArray3->Array[i]=pRealArray1->Array[i]*pRealArray2->Array[i];//矩阵点乘5 K1 F* h, U6 ]& v3 r) c
FunReObj(hFor); //告诉Lu，返回一个动态对象- A$ U- r) F2 D\\" j3 s
a.BType=luDynData_realarray; a.VType=Matrix; a.x=0; *(luVOID *)&(a.x)=(luVOID)pRealArray3;- {& g- k& }7 x4 W0 e2 A+ F
break;
# w L( e% j, x* E6 B
case 46: //重载函数new
+ H- {* Y# w3 j
a=ExeOperator(mm,xx,hFor,theOperator,luDynData_realarray); //直接调用基本类型luDynData_realarray的new函数1 p$ D2 G6 e0 n! N, D+ Q( q
if(a.VType==luDynData_realarray) a.VType=Matrix; //设置扩展类型为自定义的Matrix类型
/ F* v3 w( @; o+ p. p0 x, Y0 |) e
break;
\\" _; P' ~: N O: D3 s* r
case 49: //重载函数o
) v; o, r6 G) t$ @
pMessage=(luMessage)SearchKey("\0\0\0\0",sizeof(luVOID),luPubKey_User);
! H! p- o+ y7 [7 [3 B
if(!pMessage) break;
, g5 h( M4 Z/ V p* ^* @1 h8 d5 t8 f
pRealArray1=(luRealArray *)SearchKey((char *)&(xx->x),sizeof(luVOID),luDynData_realarray); S- T\\" C3 t/ {3 E/ N: P+ \
if(!pRealArray1) break; //对象句柄无效，不是实数数组% X& C, U+ S, k3 b2 `3 C
if(pRealArray1->DimLen!=2) break; //不是二维实数数组（矩阵）
; G9 ?& Q$ B: R$ r3 P% u) K$ z
pa=pRealArray1->Array;' ^, C K8 C0 V4 J5 X. t, _+ z. ]
m=pRealArray1->Dim[0]; n=pRealArray1->Dim[1]; k=0;/ M, p% g- C% S) y4 Y
for(i=0; i<m; i++) //输出矩阵' p1 r3 ~. c4 @0 d- @\\" J
{
v. W3 h' X# |/ d+ ?
pMessage(L"\r\n"); k+=2;& c\\" T5 R( b! J& |
for(j=0; j<n; j++)0 [) A+ n% }3 W) X7 r( H; L
{
6 ~+ o- A! O3 m# A- G' X, y
_gcvt_s(chNum,pa[i*n+j],16);1 J) i2 j8 M4 i( C, Z1 N7 S5 D
for(u=0;chNum[u];u++) {wchNum[u]=chNum[u]; k++;}
4 } U9 U8 K/ R/ p$ g9 S' e
wchNum[u]='\0';' r* x, Z# ~1 i
pMessage(wchNum); pMessage(L" "); k+=2;& b) C& g: B0 b; m; E( R2 r
}
/ T9 u/ J; N. u- h8 r2 O
}
8 l' _% B9 p! L7 o+ E
pMessage(L"\r\n"); k+=2;, R6 |/ w5 @$ ?6 S5 I G- O4 Q
a.BType=luStaData_int64; a.VType=luStaData_int64; a.x=k; //按函数o的要求，返回输出的字符总数
! F6 W z# r* W4 K
break;
& s9 S\\" L8 P\\" T
default:( r9 b: i3 u/ a8 I& I6 }& Y
break;; M6 O8 S8 F9 G* V& O
}
& O) l# r' u& w2 o# r7 x1 p
return a;
$ B5 a, A7 U- W% ~+ H) ?) h' \& W5 L9 Z
}9 f l. |) G5 `9 J6 h( l. Q& S
void main(void)# j+ j: o& T8 A) s2 s5 i3 G6 j
{
) F1 G- L. |4 o4 `- I
void *hFor; //表达式句柄
) [3 S6 u7 I. W) v
luINT nPara; //存放表达式的自变量个数
+ }( @! l; e8 ?) r6 b
LuData *pPara; //存放输入自变量的数组指针
9 V2 P: r$ \& f. G: g+ H7 i# m- r7 \
luINT ErrBegin,ErrEnd; //表达式编译出错的初始位置和结束位置
+ n, h5 C; Y8 Q\\" ]
int ErrCode; //错误代码
( p7 E. }9 E\\" [0 f! `
void *v;
- R\\" |\\" p\\" n p% f( G9 t& o
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.]}";//字符串表达式，矩阵乘/ \4 L7 \& ?9 o6 ~, n6 [$ @7 x
//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.]}";//字符串表达式，矩阵点乘6 N# ]\\" G* S4 F. ~+ f }2 h
LuData Val;
\\" j) g. E0 U* m! p2 A
if(!InitLu()) return; //初始化Lu
5 K' j1 y* A* I. N\\" ?
while(LockKey(Matrix,DelMatrix,OpMatrix)){Matrix++;} //锁定一个键，用于存储矩阵扩展类型. V3 p9 f1 t% s\\" |/ q3 u
- Y8 o5 Y! T- O1 z% ^! U% l
Val.BType=luStaData_int64; Val.VType=luStaData_int64; Val.x=Matrix; //定义整数常量
$ P! i$ O1 e3 B% A5 [4 F
SetConst(L"matrix",&Val); //设置整数常量
5 ~\\" K/ R6 j3 u1 U/ U6 w! s
InsertKey("\0\0\0\0",4,luPubKey_User,LuMessage,NULL,NULL,1,v); //使Lu运行时可输出函数信息9 K- N, G r9 `' M$ q$ V) l1 e
wcout.imbue(locale("chs")); //设置输出的locale为中文. y' {! i+ V3 i* u3 p }
1 `' ~7 O: t4 f+ G+ G5 u1 s
ErrCode=LuCom(ForStr,0,0,0,hFor,nPara,pPara,ErrBegin,ErrEnd); //编译表达式
( L/ v- u- y% q) X8 Y# Q
if(ErrCode)\\" U5 m9 g* s5 c7 W, j
{
! r' ?) n9 L7 q c6 _
wcout<<L"表达式有错误！错误代码："<<ErrCode<<endl;8 X8 l, K ?\\" E+ G5 ~
}( M- e# }9 [) n
else& p) q S% H2 m# z( |4 |
{
* o& d+ `1 E) A1 ]: M) P
LuCal(hFor,pPara); //计算表达式的值
% K( c' |% W/ r) F) m
}% k+ i* l/ ^, P M% d; `9 A
LockKey(Matrix,NULL,OpMatrix);//解锁键Matrix，本例中，该函数可以不用. y+ E7 Z, t$ v5 g
FreeLu(); //释放Lu; _) C+ I$ J& l8 z' a
}

#include <windows.h>$ ^1 i9 }, n& ?& J

#include <iostream># T# c9 s. C: N2 v+ K

#include <math.h> 
) g6 a* d$ L- d! ]% x
#include "lu32.h"& ^2 c( n- }  t3 m

( b; B: Y) g% F8 C7 @! r7 }
#pragma comment( lib, "lu32.lib" ) 
1 m* O0 Q1 I6 f# n( F6 q
 
! y8 i/ p7 C4 p' ]6 ^1 E
using namespace std; 
$ `/ J; c% K' ?
1 i+ e) N\\" P8 `% R

luKEY Matrix=-1000;        //标识矩阵类型，最终的Matrix由LockKey决定1 ^& H8 t, k. [- T7 @, ^

; m( L/ B: [4 A% `1 q8 q7 W
void _stdcall LuMessage(wchar_t *pch)//输出动态库信息，该函数注册到Lu，由Lu二级函数调用 
: x+ [: v0 m3 a! B  m' A4 X
{ 
! v3 Q' d+ k6 s: R- Y
        wcout<<pch; 
8 N7 K( u+ F5 x9 U, i0 b
} 
1 @: y# S4 T; V# S
void _stdcall DelMatrix(void *me)        //用于LockKey函数，因为是基于系统内置实数数组创建矩阵，故该函数什么也不做 
7 u% @$ e2 b# h# y3 x% W# B
{ 
# e2 [1 v! X% Y% @# [, l4 R6 Y: G1 }- p
}- p0 d' w# e9 H- o: |4 o* t

LuData _stdcall OpMatrix(luINT mm,LuData *xx,void *hFor,int theOperator)        //运算符重载函数，用于LockKey函数 
) L5 \# R. [8 T$ p\\" V
{0 q. B6 s9 L9 X

LuData a;, g3 m6 X8 F- _. k

luRealArray *pRealArray1,*pRealArray2,*pRealArray3;9 V+ [, H5 T9 a3 v- [+ x1 P

luVOID i,j,k,m,n,u,v; 
# ~/ M5 l: z: V1 S, ^. q
        double *pa,*pb,*pc;, }# N) W( a& x\\" U* g

luMessage pMessage;- H( o( e  |5 T. K

wchar_t wchNum[32]; 
- O: v) C. E7 `8 q
        char chNum[32]; 
+ {0 U) w8 Y* L( I& S
        a.BType=luStaData_nil; a.VType=luStaData_nil; a.x=0;1 H; A2 c- m8 X2 `6 t% Y

switch(theOperator) 
& U# U- g7 ]. l9 _5 e# p
        { 
; ^- l# ]/ v7 @) Z6 O* W
        case 2:        //重载运算符* 
\\" G\\" g/ J- y4 ^/ c
                pRealArray1=(luRealArray *)SearchKey((char *)&(xx->x),sizeof(luVOID),luDynData_realarray); 
\\" D, E5 K1 g6 A
                pRealArray2=(luRealArray *)SearchKey((char *)&((xx+1)->x),sizeof(luVOID),luDynData_realarray);\\" {7 E  A2 r. ?! i0 X+ a8 S7 i

if(!pRealArray1 || !pRealArray2) break;        //对象句柄无效，不是实数数组 
' y; M+ U/ J- ~1 ^: _\\" ~9 {
                if(pRealArray1->DimLen!=2 || pRealArray2->DimLen!=2) break;        //不是二维实数数组（矩阵） 
4 B\\" e3 X\\" E; g5 b1 h6 e! f
                if(pRealArray1->Dim[1]!=pRealArray2->Dim[0]) break;        //维数不匹配 
( W4 N. r  Z* c$ J$ w9 J: h
                pRealArray3=(luRealArray *)NewSysObj(luDynData_realarray,pRealArray1->Dim[0]*pRealArray2->Dim[1],2);        //创建矩阵对象 
) G; u' T, ~! ^: t- Q
                if(!pRealArray3) break; 
* U  C; _\\" J% N5 q
                pRealArray3->Dim[0]=pRealArray1->Dim[0]; pRealArray3->Dim[1]=pRealArray2->Dim[1];        //设置矩阵维数大小8 A. a3 [/ X. H- V# `

pa=pRealArray1->Array; pb=pRealArray2->Array; pc=pRealArray3->Array;\\" n: r# ?- H4 ]& H1 b' U$ O# ^9 X

m=pRealArray1->Dim[0]; n=pRealArray1->Dim[1]; k=pRealArray2->Dim[1];2 B; v1 R/ x: t\\" I8 V- }% h* d; L

for(i=0; i<m; i++)        //矩阵乘 
* m! X- ?* p# N1 Q
                { 
2 u9 E3 m- E  h/ p
                        for(j=0; j<k; j++)  r, e6 W  }$ d

{# P3 j* j. s0 H6 ^

u=i*k+j; pc[u]=0.0; 
, R: a) n3 N! [* a
                                for (v=0; v<n; v++)* {; U3 D% C7 g1 G5 S) ?

{: ]7 G: c1 U, k$ b4 s4 d

pc[u]=pc[u]+pa[i*n+v]*pb[v*k+j];* q2 q1 P( I# P. g1 _& A

} 
1 |. g3 J- E) \# ?0 K
                        } 
8 J8 p3 \$ h0 c2 N& d6 h: c$ h
                }; \6 ^, y6 b$ Q( `; N

FunReObj(hFor);        //告诉Lu，返回一个动态对象 
7 m# a) m) A2 ^; G
                a.BType=luDynData_realarray; a.VType=Matrix; a.x=0; *(luVOID *)&(a.x)=(luVOID)pRealArray3;* K2 N% R0 v# g; [/ Q5 z

break;6 Z  G' z+ {\\" i/ m! ]8 ^

case 25:        //重载运算符.*\\" e( c  t5 i2 ^! K: S' X) Z

pRealArray1=(luRealArray *)SearchKey((char *)&(xx->x),sizeof(luVOID),luDynData_realarray);8 [1 s' ^  U* V8 {

pRealArray2=(luRealArray *)SearchKey((char *)&((xx+1)->x),sizeof(luVOID),luDynData_realarray); 
- R0 q, Z# G  U/ p6 @
                if(!pRealArray1 || !pRealArray2) break;        //对象句柄无效，不是实数数组$ `  H; `8 N# L+ {9 A# S# \7 A

if(pRealArray1->DimLen!=2 || pRealArray2->DimLen!=2) break;        //不是二维实数数组（矩阵）: G7 q& ?1 W- o; u- y. O

if(pRealArray1->Dim[0]!=pRealArray2->Dim[0] || pRealArray1->Dim[1]!=pRealArray2->Dim[1]) break;        //维数不相同 
9 ?& i$ N0 b$ M! S
                pRealArray3=(luRealArray *)NewSysObj(luDynData_realarray,pRealArray1->ArrayLen,2);        //创建矩阵对象 
% ?3 {0 x6 @8 I
                if(!pRealArray3) break;' l! C' k, K/ Y( T, J( y! R

pRealArray3->Dim[0]=pRealArray1->Dim[0]; pRealArray3->Dim[1]=pRealArray1->Dim[1];        //设置矩阵维数大小 
; ]% O& Z8 v- a( D; _4 j# a
                for(i=0;i<pRealArray1->ArrayLen;i++) pRealArray3->Array[i]=pRealArray1->Array[i]*pRealArray2->Array[i];//矩阵点乘5 K1 F* h, U6 ]& v3 r) c

FunReObj(hFor);        //告诉Lu，返回一个动态对象- A$ U- r) F2 D\\" j3 s

a.BType=luDynData_realarray; a.VType=Matrix; a.x=0; *(luVOID *)&(a.x)=(luVOID)pRealArray3;- {& g- k& }7 x4 W0 e2 A+ F

break; 
# w  L( e% j, x* E6 B
        case 46:        //重载函数new 
+ H- {* Y# w3 j
                a=ExeOperator(mm,xx,hFor,theOperator,luDynData_realarray);        //直接调用基本类型luDynData_realarray的new函数1 p$ D2 G6 e0 n! N, D+ Q( q

if(a.VType==luDynData_realarray) a.VType=Matrix;        //设置扩展类型为自定义的Matrix类型 
/ F* v3 w( @; o+ p. p0 x, Y0 |) e
                break; 
\\" _; P' ~: N  O: D3 s* r
        case 49:        //重载函数o 
) v; o, r6 G) t$ @
                pMessage=(luMessage)SearchKey("\0\0\0\0",sizeof(luVOID),luPubKey_User); 
! H! p- o+ y7 [7 [3 B
                if(!pMessage) break; 
, g5 h( M4 Z/ V  p* ^* @1 h8 d5 t8 f
                pRealArray1=(luRealArray *)SearchKey((char *)&(xx->x),sizeof(luVOID),luDynData_realarray);  S- T\\" C3 t/ {3 E/ N: P+ \

if(!pRealArray1) break;        //对象句柄无效，不是实数数组% X& C, U+ S, k3 b2 `3 C

if(pRealArray1->DimLen!=2) break;        //不是二维实数数组（矩阵） 
; G9 ?& Q$ B: R$ r3 P% u) K$ z
                pa=pRealArray1->Array;' ^, C  K8 C0 V4 J5 X. t, _+ z. ]

m=pRealArray1->Dim[0]; n=pRealArray1->Dim[1]; k=0;/ M, p% g- C% S) y4 Y

for(i=0; i<m; i++)        //输出矩阵' p1 r3 ~. c4 @0 d- @\\" J

{ 
  v. W3 h' X# |/ d+ ?
                        pMessage(L"\r\n"); k+=2;& c\\" T5 R( b! J& |

for(j=0; j<n; j++)0 [) A+ n% }3 W) X7 r( H; L

{ 
6 ~+ o- A! O3 m# A- G' X, y
                                _gcvt_s(chNum,pa[i*n+j],16);1 J) i2 j8 M4 i( C, Z1 N7 S5 D

for(u=0;chNum[u];u++) {wchNum[u]=chNum[u]; k++;} 
4 }  U9 U8 K/ R/ p$ g9 S' e
                                wchNum[u]='\0';' r* x, Z# ~1 i

pMessage(wchNum); pMessage(L"  "); k+=2;& b) C& g: B0 b; m; E( R2 r

} 
/ T9 u/ J; N. u- h8 r2 O
                } 
8 l' _% B9 p! L7 o+ E
                pMessage(L"\r\n"); k+=2;, R6 |/ w5 @$ ?6 S5 I  G- O4 Q

a.BType=luStaData_int64; a.VType=luStaData_int64; a.x=k;        //按函数o的要求，返回输出的字符总数 
! F6 W  z# r* W4 K
                break; 
& s9 S\\" L8 P\\" T
        default:( r9 b: i3 u/ a8 I& I6 }& Y

break;; M6 O8 S8 F9 G* V& O

} 
& O) l# r' u& w2 o# r7 x1 p
        return a; 
$ B5 a, A7 U- W% ~+ H) ?) h' \& W5 L9 Z
}9 f  l. |) G5 `9 J6 h( l. Q& S

void main(void)# j+ j: o& T8 A) s2 s5 i3 G6 j

{ 
) F1 G- L. |4 o4 `- I
        void *hFor;                //表达式句柄 
) [3 S6 u7 I. W) v
        luINT nPara;                //存放表达式的自变量个数 
+ }( @! l; e8 ?) r6 b
        LuData *pPara;                //存放输入自变量的数组指针 
9 V2 P: r$ \& f. G: g+ H7 i# m- r7 \
        luINT ErrBegin,ErrEnd;        //表达式编译出错的初始位置和结束位置 
+ n, h5 C; Y8 Q\\" ]
        int ErrCode;                //错误代码 
( p7 E. }9 E\\" [0 f! `
        void *v; 
- R\\" |\\" p\\" n  p% f( G9 t& o
        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.]}";//字符串表达式，矩阵乘/ \4 L7 \& ?9 o6 ~, n6 [$ @7 x

//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.]}";//字符串表达式，矩阵点乘6 N# ]\\" G* S4 F. ~+ f  }2 h

LuData Val; 
\\" j) g. E0 U* m! p2 A
        if(!InitLu()) return;        //初始化Lu 
5 K' j1 y* A* I. N\\" ?
        while(LockKey(Matrix,DelMatrix,OpMatrix)){Matrix++;}        //锁定一个键，用于存储矩阵扩展类型. V3 p9 f1 t% s\\" |/ q3 u

- Y8 o5 Y! T- O1 z% ^! U% l

Val.BType=luStaData_int64; Val.VType=luStaData_int64; Val.x=Matrix;        //定义整数常量 
$ P! i$ O1 e3 B% A5 [4 F
        SetConst(L"matrix",&Val);        //设置整数常量 
5 ~\\" K/ R6 j3 u1 U/ U6 w! s
        InsertKey("\0\0\0\0",4,luPubKey_User,LuMessage,NULL,NULL,1,v); //使Lu运行时可输出函数信息9 K- N, G  r9 `' M$ q$ V) l1 e

wcout.imbue(locale("chs"));        //设置输出的locale为中文. y' {! i+ V3 i* u3 p  }

1 `' ~7 O: t4 f+ G+ G5 u1 s

ErrCode=LuCom(ForStr,0,0,0,hFor,nPara,pPara,ErrBegin,ErrEnd); //编译表达式 
( L/ v- u- y% q) X8 Y# Q
        if(ErrCode)\\" U5 m9 g* s5 c7 W, j

{ 
! r' ?) n9 L7 q  c6 _
                wcout<<L"表达式有错误！错误代码："<<ErrCode<<endl;8 X8 l, K  ?\\" E+ G5 ~

}( M- e# }9 [) n

else& p) q  S% H2 m# z( |4 |

{ 
* o& d+ `1 E) A1 ]: M) P
                LuCal(hFor,pPara);        //计算表达式的值 
% K( c' |% W/ r) F) m
        }% k+ i* l/ ^, P  M% d; `9 A

LockKey(Matrix,NULL,OpMatrix);//解锁键Matrix，本例中，该函数可以不用. y+ E7 Z, t$ v5 g

FreeLu();                        //释放Lu; _) C+ I$ J& l8 z' a

}

习题：

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

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

main(:a,b,c,d,t,i)=
' o6 `/ y# a4 ^. }
a=new[matrix,2,2,data:1.,2.,2.,1.],6 F2 v\" ?' Z2 f( z% W
b=new[matrix,2,2,data:2.,1.,1.,2.],
# ?/ D4 L0 G5 ]0 m c, @( J
c=new[matrix,2,2,data:2/3.,-1/3.,-1/3.,2/3.],
% v7 q# M\" w. b/ u5 c. b
t=clock(),1 y\" M% D+ C! `. C4 b
d=a*b, i=0, while{i<1000000, d=d*c*b, i++},7 j/ x1 q' ]# S\" ^3 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\"}";//字符串表达式

复制代码

结果：