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

查看: 8898|回复: 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>! _3 f4 F6 i8 N4 e5 J8 D
#include <iostream>& ^6 s\\" K* q! f$ Y. l8 s! Y. d
#include <math.h>: D% ~ p+ I( i% J' E0 |
#include "lu32.h"+ b\\" M% p9 I\\" ?* M5 ]4 K0 \
2 b+ r S+ k9 [) j
#pragma comment( lib, "lu32.lib" )- t7 i0 J8 U6 y2 w( m
3 k/ o4 M+ T ~! M7 L, c- r0 m
using namespace std;% U$ g) Z! k/ o& ]# m) v5 `: V
3 A b5 W% N/ ^- b8 {$ e) W! d) z
luKEY Matrix=-1000; //标识矩阵类型，最终的Matrix由LockKey决定. ^* ~- r4 b& k
, ?3 `/ c$ Z3 w0 ~
void _stdcall LuMessage(wchar_t *pch)//输出动态库信息，该函数注册到Lu，由Lu二级函数调用 0 O) q% k* L$ ~2 \
{
: L) x' E) f1 U
wcout<<pch;$ h+ |1 t$ L9 N9 x8 ^2 x
}: H5 g1 w! [1 s& U' c) |2 o+ b
void _stdcall DelMatrix(void *me) //用于LockKey函数，因为是基于系统内置实数数组创建矩阵，故该函数什么也不做
\\" J\\" F6 n$ x6 \2 a6 j
{
, D) ?1 c' a0 O: k; ]4 L# e0 i
}
# G- K. S* c- F- L' f\\" K% d
LuData _stdcall OpMatrix(luINT mm,LuData *xx,void *hFor,int theOperator) //运算符重载函数，用于LockKey函数! _8 y) N, W2 ?) X* ?* A q
{
! w! r6 V\\" ~) O9 _+ |; c2 [
LuData a;
6 o# a) v% w) v, P- `' u- ^ p
luRealArray *pRealArray1,*pRealArray2,*pRealArray3;\\" a* Z; r5 x9 W# I6 d' ]2 o7 u
luVOID i,j,k,m,n,u,v;- v; Y7 c- x. T) N
double *pa,*pb,*pc;+ e f2 {$ ^+ x6 M( J8 [
luMessage pMessage;* g) D$ c+ t& T# H
wchar_t wchNum[32];
: W$ Q( B$ [7 x% @6 N
char chNum[32];
7 P9 r, y, Z' ^\\" Q+ s- y; a
a.BType=luStaData_nil; a.VType=luStaData_nil; a.x=0;, [3 g% _( f& _1 M1 G; E
switch(theOperator)
$ G' _/ Q/ |- ~* l1 r' M
{
( a% j0 P. H+ H, a6 @+ v
case 2: //重载运算符*
4 [. f4 l5 C- [3 K
pRealArray1=(luRealArray *)SearchKey((char *)&(xx->x),sizeof(luVOID),luDynData_realarray);1 {# z0 C& S% `
pRealArray2=(luRealArray *)SearchKey((char *)&((xx+1)->x),sizeof(luVOID),luDynData_realarray);\\" R; w7 W6 F+ N0 g. N
if(!pRealArray1 || !pRealArray2) break; //对象句柄无效，不是实数数组
/ K6 ^\\" s7 F* Y( b* c8 g) T
if(pRealArray1->DimLen!=2 || pRealArray2->DimLen!=2) break; //不是二维实数数组（矩阵）
6 w j' h, S0 e3 u3 z
if(pRealArray1->Dim[1]!=pRealArray2->Dim[0]) break; //维数不匹配
& P7 ~+ T1 ~9 x% ]) c+ E( S
pRealArray3=(luRealArray *)NewSysObj(luDynData_realarray,pRealArray1->Dim[0]*pRealArray2->Dim[1],2); //创建矩阵对象+ u6 c. j9 |7 s\\" k' ~0 _9 q
if(!pRealArray3) break;
: J+ g9 W7 z$ H1 L8 K. U2 S+ e, U, D
pRealArray3->Dim[0]=pRealArray1->Dim[0]; pRealArray3->Dim[1]=pRealArray2->Dim[1]; //设置矩阵维数大小
. W0 ^$ x7 P) o: K
pa=pRealArray1->Array; pb=pRealArray2->Array; pc=pRealArray3->Array;/ N1 F @6 ^7 V
m=pRealArray1->Dim[0]; n=pRealArray1->Dim[1]; k=pRealArray2->Dim[1];
\\" `( Z1 ^) q0 c5 \- t
for(i=0; i<m; i++) //矩阵乘( u0 n5 N R; L7 k( q3 P
{
- Z$ Z4 p! U2 W' S$ j
for(j=0; j<k; j++)
\\" [, b {. O/ Y& u
{, _ X/ z( f+ a1 A
u=i*k+j; pc[u]=0.0;
3 d' ?9 T1 G. g) N5 T! Q+ f7 P
for (v=0; v<n; v++)4 ?2 O0 k* C5 k, {- s. ~
{- F; T$ d2 C% [2 O/ v2 @2 E& p+ C
pc[u]=pc[u]+pa[i*n+v]*pb[v*k+j];
, D b% R0 o; ]: D6 \/ J
}1 O% r! j+ ~ S! u6 [: I
}7 |( ~$ I0 r) T
}
& I7 B) A+ k, O* d
FunReObj(hFor); //告诉Lu，返回一个动态对象
5 ^& f7 w6 {6 S/ p$ P
a.BType=luDynData_realarray; a.VType=Matrix; a.x=0; *(luVOID *)&(a.x)=(luVOID)pRealArray3; x; K- J( h5 G8 g$ W7 x
break;. V) j6 W3 V4 d8 D1 g
case 25: //重载运算符.*
/ ]4 ^$ [' O' N
pRealArray1=(luRealArray *)SearchKey((char *)&(xx->x),sizeof(luVOID),luDynData_realarray);
( J8 l- O6 A\\" {8 n; ^9 y, r# a$ f1 S
pRealArray2=(luRealArray *)SearchKey((char *)&((xx+1)->x),sizeof(luVOID),luDynData_realarray);
8 a( p3 e0 [2 t( ^( K
if(!pRealArray1 || !pRealArray2) break; //对象句柄无效，不是实数数组1 _# H& W$ ~/ N0 c6 J
if(pRealArray1->DimLen!=2 || pRealArray2->DimLen!=2) break; //不是二维实数数组（矩阵）4 h: Z1 C+ s, ~9 P5 \8 K* T
if(pRealArray1->Dim[0]!=pRealArray2->Dim[0] || pRealArray1->Dim[1]!=pRealArray2->Dim[1]) break; //维数不相同
) |5 A* R) g' r
pRealArray3=(luRealArray *)NewSysObj(luDynData_realarray,pRealArray1->ArrayLen,2); //创建矩阵对象
& y5 Q6 d4 W. F8 J1 _4 _9 G& R5 k
if(!pRealArray3) break;
! F+ U( P+ ]8 `. P* t# L% R6 A- `; w/ `
pRealArray3->Dim[0]=pRealArray1->Dim[0]; pRealArray3->Dim[1]=pRealArray1->Dim[1]; //设置矩阵维数大小
4 K6 A& L5 h- ]2 Z+ z
for(i=0;i<pRealArray1->ArrayLen;i++) pRealArray3->Array[i]=pRealArray1->Array[i]*pRealArray2->Array[i];//矩阵点乘
$ Z\\" r; B* N5 ?5 O9 U
FunReObj(hFor); //告诉Lu，返回一个动态对象. q\\" L1 X5 t5 `3 g6 L
a.BType=luDynData_realarray; a.VType=Matrix; a.x=0; *(luVOID *)&(a.x)=(luVOID)pRealArray3;
- s$ F& K+ N/ T# `5 E. p1 H% o; C3 w* h
break;
% Y( d5 c0 r3 G) _: c' I1 X\\" ?9 J
case 46: //重载函数new+ \% C2 l& k7 r. Q
a=ExeOperator(mm,xx,hFor,theOperator,luDynData_realarray); //直接调用基本类型luDynData_realarray的new函数
. b' }! X: D* c- L9 |6 B' m
if(a.VType==luDynData_realarray) a.VType=Matrix; //设置扩展类型为自定义的Matrix类型
& C! _% T4 i! S4 }6 v: h
break;9 e ~) Y7 C( m4 n! e1 G
case 49: //重载函数o4 |' l, u% V! i5 h
pMessage=(luMessage)SearchKey("\0\0\0\0",sizeof(luVOID),luPubKey_User);
2 A8 U6 D- h- G! v# f/ U, o1 L
if(!pMessage) break;/ P8 y8 w: J: c. G! l
pRealArray1=(luRealArray *)SearchKey((char *)&(xx->x),sizeof(luVOID),luDynData_realarray);
' i$ [ }) G# |7 H! _+ S6 U
if(!pRealArray1) break; //对象句柄无效，不是实数数组
. d5 o) Q/ L% i8 B$ g* Q( F h1 N
if(pRealArray1->DimLen!=2) break; //不是二维实数数组（矩阵）
% {\\" m9 w4 T6 G- Q0 C. h\\" d. |
pa=pRealArray1->Array;
5 o1 X5 K# P. U4 v$ e- z+ b\\" U\\" m
m=pRealArray1->Dim[0]; n=pRealArray1->Dim[1]; k=0;
\\" I7 F8 e' ?% \' q) b$ B
for(i=0; i<m; i++) //输出矩阵
\\" w/ |- o0 K\\" m( N\\" G: _6 e
{\\" b+ o; U1 s- {( ~7 U4 L
pMessage(L"\r\n"); k+=2;, F1 i i2 T$ E4 g; z
for(j=0; j<n; j++)1 }% M T* O1 T7 g
{
* t: ]% r3 p& G6 s l. [- b
_gcvt_s(chNum,pa[i*n+j],16);
2 Q2 d* l+ T. H1 j5 w0 M' g9 D
for(u=0;chNum[u];u++) {wchNum[u]=chNum[u]; k++;}
8 B$ E) o7 ]( b
wchNum[u]='\0';
3 S8 }0 V* S, X2 [: Q
pMessage(wchNum); pMessage(L" "); k+=2;
% T+ E2 ?9 x3 g+ d5 F/ E
}) `7 u; t+ S9 K/ y
}
7 n8 S X4 g( G
pMessage(L"\r\n"); k+=2;# |\\" e) @2 z( Q8 u$ L; ?
a.BType=luStaData_int64; a.VType=luStaData_int64; a.x=k; //按函数o的要求，返回输出的字符总数
) s! l; g( y1 w$ F
break;
default:3 _; J9 E4 X% G0 l) @
break;) M; J9 y+ ~: t
}1 C C! k1 J3 I8 e- W/ |
return a;
2 C( s$ t4 |. r1 X\\" q2 p3 Q
}3 h- [\\" v1 ?4 y1 c\\" o
void main(void)
$ V' S* f+ Z! p+ j4 q6 E
{
3 u8 r( h6 R6 ]- @) F3 q/ e
void *hFor; //表达式句柄: r# C @. }0 v0 z# C
luINT nPara; //存放表达式的自变量个数
$ ^. E0 a. X h) U( @
LuData *pPara; //存放输入自变量的数组指针% F; q4 }/ {! _& ]+ Q! A
luINT ErrBegin,ErrEnd; //表达式编译出错的初始位置和结束位置4 \- U1 {. K6 W+ m8 b- A6 O7 I
int ErrCode; //错误代码
, C. c* R b5 Z7 R4 I
void *v; Q) Z6 |2 V3 V- u, G! |: R
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.]}";//字符串表达式，矩阵乘
; u ^) c$ q8 W8 F( a; u2 |% M
//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.]}";//字符串表达式，矩阵点乘
$ Q3 |- L' G5 Z
LuData Val;
+ x4 Q0 x3 n# R' r
if(!InitLu()) return; //初始化Lu
( k4 X- }6 i5 p7 Q9 p( A3 G# ^2 P
while(LockKey(Matrix,DelMatrix,OpMatrix)){Matrix++;} //锁定一个键，用于存储矩阵扩展类型! A0 ^; n0 y& `' A( T; r4 E' i+ ]) n
/ L5 E+ O4 X, x6 {\\" n; O8 G
Val.BType=luStaData_int64; Val.VType=luStaData_int64; Val.x=Matrix; //定义整数常量2 Q! j) m- R( u4 I r
SetConst(L"matrix",&Val); //设置整数常量( e1 G+ x# N. Y) ]
InsertKey("\0\0\0\0",4,luPubKey_User,LuMessage,NULL,NULL,1,v); //使Lu运行时可输出函数信息5 g: z( N$ K0 x) G9 X
wcout.imbue(locale("chs")); //设置输出的locale为中文
- b5 T! s- c7 S5 m ~. Z
& e: [: ~. y9 e( G* d# z/ e4 ~
ErrCode=LuCom(ForStr,0,0,0,hFor,nPara,pPara,ErrBegin,ErrEnd); //编译表达式6 r$ ~9 O\\" ?5 g5 _0 p# e
if(ErrCode)
! o; i/ ]- v2 J# H6 t
{
# ^+ n' i1 b1 i\\" C
wcout<<L"表达式有错误！错误代码："<<ErrCode<<endl;& @8 z. E- c* t1 @% i
}& G8 i& X7 y% C! v( `/ y
else
/ e2 s8 y0 d6 O
{8 U3 N( w2 ~5 q8 ^) U# q6 z! M
LuCal(hFor,pPara); //计算表达式的值
. |* ?5 h4 i+ v
}) @8 X! n& T; [+ l
LockKey(Matrix,NULL,OpMatrix);//解锁键Matrix，本例中，该函数可以不用\\" T% H3 w/ D5 Q! r# ~1 \, m\\" X
FreeLu(); //释放Lu# I u% D. w8 c\\" r
}

#include <windows.h>! _3 f4 F6 i8 N4 e5 J8 D

#include <iostream>& ^6 s\\" K* q! f$ Y. l8 s! Y. d

#include <math.h>: D% ~  p+ I( i% J' E0 |

#include "lu32.h"+ b\\" M% p9 I\\" ?* M5 ]4 K0 \

2 b+ r  S+ k9 [) j

#pragma comment( lib, "lu32.lib" )- t7 i0 J8 U6 y2 w( m

3 k/ o4 M+ T  ~! M7 L, c- r0 m

using namespace std;% U$ g) Z! k/ o& ]# m) v5 `: V

3 A  b5 W% N/ ^- b8 {$ e) W! d) z
luKEY Matrix=-1000;        //标识矩阵类型，最终的Matrix由LockKey决定. ^* ~- r4 b& k

, ?3 `/ c$ Z3 w0 ~
void _stdcall LuMessage(wchar_t *pch)//输出动态库信息，该函数注册到Lu，由Lu二级函数调用 0 O) q% k* L$ ~2 \

{ 
: L) x' E) f1 U
        wcout<<pch;$ h+ |1 t$ L9 N9 x8 ^2 x

}: H5 g1 w! [1 s& U' c) |2 o+ b

void _stdcall DelMatrix(void *me)        //用于LockKey函数，因为是基于系统内置实数数组创建矩阵，故该函数什么也不做 
\\" J\\" F6 n$ x6 \2 a6 j
{ 
, D) ?1 c' a0 O: k; ]4 L# e0 i
} 
# G- K. S* c- F- L' f\\" K% d
LuData _stdcall OpMatrix(luINT mm,LuData *xx,void *hFor,int theOperator)        //运算符重载函数，用于LockKey函数! _8 y) N, W2 ?) X* ?* A  q

{ 
! w! r6 V\\" ~) O9 _+ |; c2 [
        LuData a; 
6 o# a) v% w) v, P- `' u- ^  p
        luRealArray *pRealArray1,*pRealArray2,*pRealArray3;\\" a* Z; r5 x9 W# I6 d' ]2 o7 u

luVOID i,j,k,m,n,u,v;- v; Y7 c- x. T) N

double *pa,*pb,*pc;+ e  f2 {$ ^+ x6 M( J8 [

luMessage pMessage;* g) D$ c+ t& T# H

wchar_t wchNum[32]; 
: W$ Q( B$ [7 x% @6 N
        char chNum[32]; 
7 P9 r, y, Z' ^\\" Q+ s- y; a
        a.BType=luStaData_nil; a.VType=luStaData_nil; a.x=0;, [3 g% _( f& _1 M1 G; E

switch(theOperator) 
$ G' _/ Q/ |- ~* l1 r' M
        { 
( a% j0 P. H+ H, a6 @+ v
        case 2:        //重载运算符* 
4 [. f4 l5 C- [3 K
                pRealArray1=(luRealArray *)SearchKey((char *)&(xx->x),sizeof(luVOID),luDynData_realarray);1 {# z0 C& S% `

pRealArray2=(luRealArray *)SearchKey((char *)&((xx+1)->x),sizeof(luVOID),luDynData_realarray);\\" R; w7 W6 F+ N0 g. N

if(!pRealArray1 || !pRealArray2) break;        //对象句柄无效，不是实数数组 
/ K6 ^\\" s7 F* Y( b* c8 g) T
                if(pRealArray1->DimLen!=2 || pRealArray2->DimLen!=2) break;        //不是二维实数数组（矩阵） 
6 w  j' h, S0 e3 u3 z
                if(pRealArray1->Dim[1]!=pRealArray2->Dim[0]) break;        //维数不匹配 
& P7 ~+ T1 ~9 x% ]) c+ E( S
                pRealArray3=(luRealArray *)NewSysObj(luDynData_realarray,pRealArray1->Dim[0]*pRealArray2->Dim[1],2);        //创建矩阵对象+ u6 c. j9 |7 s\\" k' ~0 _9 q

if(!pRealArray3) break; 
: J+ g9 W7 z$ H1 L8 K. U2 S+ e, U, D
                pRealArray3->Dim[0]=pRealArray1->Dim[0]; pRealArray3->Dim[1]=pRealArray2->Dim[1];        //设置矩阵维数大小 
. W0 ^$ x7 P) o: K
                pa=pRealArray1->Array; pb=pRealArray2->Array; pc=pRealArray3->Array;/ N1 F  @6 ^7 V

m=pRealArray1->Dim[0]; n=pRealArray1->Dim[1]; k=pRealArray2->Dim[1]; 
\\" `( Z1 ^) q0 c5 \- t
                for(i=0; i<m; i++)        //矩阵乘( u0 n5 N  R; L7 k( q3 P

{ 
- Z$ Z4 p! U2 W' S$ j
                        for(j=0; j<k; j++) 
\\" [, b  {. O/ Y& u
                        {, _  X/ z( f+ a1 A

u=i*k+j; pc[u]=0.0; 
3 d' ?9 T1 G. g) N5 T! Q+ f7 P
                                for (v=0; v<n; v++)4 ?2 O0 k* C5 k, {- s. ~

{- F; T$ d2 C% [2 O/ v2 @2 E& p+ C

pc[u]=pc[u]+pa[i*n+v]*pb[v*k+j]; 
, D  b% R0 o; ]: D6 \/ J
                                }1 O% r! j+ ~  S! u6 [: I

}7 |( ~$ I0 r) T

} 
& I7 B) A+ k, O* d
                FunReObj(hFor);        //告诉Lu，返回一个动态对象 
5 ^& f7 w6 {6 S/ p$ P
                a.BType=luDynData_realarray; a.VType=Matrix; a.x=0; *(luVOID *)&(a.x)=(luVOID)pRealArray3;  x; K- J( h5 G8 g$ W7 x

break;. V) j6 W3 V4 d8 D1 g

case 25:        //重载运算符.* 
/ ]4 ^$ [' O' N
                pRealArray1=(luRealArray *)SearchKey((char *)&(xx->x),sizeof(luVOID),luDynData_realarray); 
( J8 l- O6 A\\" {8 n; ^9 y, r# a$ f1 S
                pRealArray2=(luRealArray *)SearchKey((char *)&((xx+1)->x),sizeof(luVOID),luDynData_realarray); 
8 a( p3 e0 [2 t( ^( K
                if(!pRealArray1 || !pRealArray2) break;        //对象句柄无效，不是实数数组1 _# H& W$ ~/ N0 c6 J

if(pRealArray1->DimLen!=2 || pRealArray2->DimLen!=2) break;        //不是二维实数数组（矩阵）4 h: Z1 C+ s, ~9 P5 \8 K* T

if(pRealArray1->Dim[0]!=pRealArray2->Dim[0] || pRealArray1->Dim[1]!=pRealArray2->Dim[1]) break;        //维数不相同 
) |5 A* R) g' r
                pRealArray3=(luRealArray *)NewSysObj(luDynData_realarray,pRealArray1->ArrayLen,2);        //创建矩阵对象 
& y5 Q6 d4 W. F8 J1 _4 _9 G& R5 k
                if(!pRealArray3) break; 
! F+ U( P+ ]8 `. P* t# L% R6 A- `; w/ `
                pRealArray3->Dim[0]=pRealArray1->Dim[0]; pRealArray3->Dim[1]=pRealArray1->Dim[1];        //设置矩阵维数大小 
4 K6 A& L5 h- ]2 Z+ z
                for(i=0;i<pRealArray1->ArrayLen;i++) pRealArray3->Array[i]=pRealArray1->Array[i]*pRealArray2->Array[i];//矩阵点乘 
$ Z\\" r; B* N5 ?5 O9 U
                FunReObj(hFor);        //告诉Lu，返回一个动态对象. q\\" L1 X5 t5 `3 g6 L

a.BType=luDynData_realarray; a.VType=Matrix; a.x=0; *(luVOID *)&(a.x)=(luVOID)pRealArray3; 
- s$ F& K+ N/ T# `5 E. p1 H% o; C3 w* h
                break; 
% Y( d5 c0 r3 G) _: c' I1 X\\" ?9 J
        case 46:        //重载函数new+ \% C2 l& k7 r. Q

a=ExeOperator(mm,xx,hFor,theOperator,luDynData_realarray);        //直接调用基本类型luDynData_realarray的new函数 
. b' }! X: D* c- L9 |6 B' m
                if(a.VType==luDynData_realarray) a.VType=Matrix;        //设置扩展类型为自定义的Matrix类型 
& C! _% T4 i! S4 }6 v: h
                break;9 e  ~) Y7 C( m4 n! e1 G

case 49:        //重载函数o4 |' l, u% V! i5 h

pMessage=(luMessage)SearchKey("\0\0\0\0",sizeof(luVOID),luPubKey_User); 
2 A8 U6 D- h- G! v# f/ U, o1 L
                if(!pMessage) break;/ P8 y8 w: J: c. G! l

pRealArray1=(luRealArray *)SearchKey((char *)&(xx->x),sizeof(luVOID),luDynData_realarray); 
' i$ [  }) G# |7 H! _+ S6 U
                if(!pRealArray1) break;        //对象句柄无效，不是实数数组 
. d5 o) Q/ L% i8 B$ g* Q( F  h1 N
                if(pRealArray1->DimLen!=2) break;        //不是二维实数数组（矩阵） 
% {\\" m9 w4 T6 G- Q0 C. h\\" d. |
                pa=pRealArray1->Array; 
5 o1 X5 K# P. U4 v$ e- z+ b\\" U\\" m
                m=pRealArray1->Dim[0]; n=pRealArray1->Dim[1]; k=0; 
\\" I7 F8 e' ?% \' q) b$ B
                for(i=0; i<m; i++)        //输出矩阵 
\\" w/ |- o0 K\\" m( N\\" G: _6 e
                {\\" b+ o; U1 s- {( ~7 U4 L

pMessage(L"\r\n"); k+=2;, F1 i  i2 T$ E4 g; z

for(j=0; j<n; j++)1 }% M  T* O1 T7 g

{ 
* t: ]% r3 p& G6 s  l. [- b
                                _gcvt_s(chNum,pa[i*n+j],16); 
2 Q2 d* l+ T. H1 j5 w0 M' g9 D
                                for(u=0;chNum[u];u++) {wchNum[u]=chNum[u]; k++;} 
8 B$ E) o7 ]( b
                                wchNum[u]='\0'; 
3 S8 }0 V* S, X2 [: Q
                                pMessage(wchNum); pMessage(L"  "); k+=2; 
% T+ E2 ?9 x3 g+ d5 F/ E
                        }) `7 u; t+ S9 K/ y

} 
7 n8 S  X4 g( G
                pMessage(L"\r\n"); k+=2;# |\\" e) @2 z( Q8 u$ L; ?

a.BType=luStaData_int64; a.VType=luStaData_int64; a.x=k;        //按函数o的要求，返回输出的字符总数 
) s! l; g( y1 w$ F
                break; 
\\" [5 c1 ~1 ^0 Y* J/ ~. |\\" {6 S7 k* F
        default:3 _; J9 E4 X% G0 l) @

break;) M; J9 y+ ~: t

}1 C  C! k1 J3 I8 e- W/ |

return a; 
2 C( s$ t4 |. r1 X\\" q2 p3 Q
}3 h- [\\" v1 ?4 y1 c\\" o

void main(void) 
$ V' S* f+ Z! p+ j4 q6 E
{ 
3 u8 r( h6 R6 ]- @) F3 q/ e
        void *hFor;                //表达式句柄: r# C  @. }0 v0 z# C

luINT nPara;                //存放表达式的自变量个数 
$ ^. E0 a. X  h) U( @
        LuData *pPara;                //存放输入自变量的数组指针% F; q4 }/ {! _& ]+ Q! A

luINT ErrBegin,ErrEnd;        //表达式编译出错的初始位置和结束位置4 \- U1 {. K6 W+ m8 b- A6 O7 I

int ErrCode;                //错误代码 
, C. c* R  b5 Z7 R4 I
        void *v;  Q) Z6 |2 V3 V- u, G! |: R

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.]}";//字符串表达式，矩阵乘 
; u  ^) c$ q8 W8 F( a; u2 |% M
        //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.]}";//字符串表达式，矩阵点乘 
$ Q3 |- L' G5 Z
        LuData Val; 
+ x4 Q0 x3 n# R' r
        if(!InitLu()) return;        //初始化Lu 
( k4 X- }6 i5 p7 Q9 p( A3 G# ^2 P
        while(LockKey(Matrix,DelMatrix,OpMatrix)){Matrix++;}        //锁定一个键，用于存储矩阵扩展类型! A0 ^; n0 y& `' A( T; r4 E' i+ ]) n

/ L5 E+ O4 X, x6 {\\" n; O8 G
        Val.BType=luStaData_int64; Val.VType=luStaData_int64; Val.x=Matrix;        //定义整数常量2 Q! j) m- R( u4 I  r

SetConst(L"matrix",&Val);        //设置整数常量( e1 G+ x# N. Y) ]

InsertKey("\0\0\0\0",4,luPubKey_User,LuMessage,NULL,NULL,1,v); //使Lu运行时可输出函数信息5 g: z( N$ K0 x) G9 X

wcout.imbue(locale("chs"));        //设置输出的locale为中文 
- b5 T! s- c7 S5 m  ~. Z
   
& e: [: ~. y9 e( G* d# z/ e4 ~
        ErrCode=LuCom(ForStr,0,0,0,hFor,nPara,pPara,ErrBegin,ErrEnd); //编译表达式6 r$ ~9 O\\" ?5 g5 _0 p# e

if(ErrCode) 
! o; i/ ]- v2 J# H6 t
        { 
# ^+ n' i1 b1 i\\" C
                wcout<<L"表达式有错误！错误代码："<<ErrCode<<endl;& @8 z. E- c* t1 @% i

}& G8 i& X7 y% C! v( `/ y

else 
/ e2 s8 y0 d6 O
        {8 U3 N( w2 ~5 q8 ^) U# q6 z! M

LuCal(hFor,pPara);        //计算表达式的值 
. |* ?5 h4 i+ v
        }) @8 X! n& T; [+ l

LockKey(Matrix,NULL,OpMatrix);//解锁键Matrix，本例中，该函数可以不用\\" T% H3 w/ D5 Q! r# ~1 \, m\\" X

FreeLu();                        //释放Lu# I  u% D. w8 c\\" r

}

习题：

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

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

main(:a,b,c,d,t,i)=7 f\" e _. {+ ~4 z! f
a=new[matrix,2,2,data:1.,2.,2.,1.],' x1 E/ b+ ]2 L, x: W6 @
b=new[matrix,2,2,data:2.,1.,1.,2.],
1 H, O- [ \! a- u1 l& X) T
c=new[matrix,2,2,data:2/3.,-1/3.,-1/3.,2/3.],
: i# k S! U3 q6 B, C
t=clock(),) e& q7 b* j. [* p* e n( n
d=a*b, i=0, while{i<1000000, d=d*c*b, i++},
X# B; e0 H+ ]5 V
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\"}";//字符串表达式

复制代码

结果：