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

查看: 8735|回复: 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>
+ j% h\\" v; L+ n- D1 l9 u
#include <iostream>
8 U7 Q) [# L8 T7 n7 u
#include <math.h>
i# K1 [' W# [. O: h. O
#include "lu32.h"7 t; B* r! c8 g/ e* u
8 y/ c# y* e1 ]2 L( y) ^
#pragma comment( lib, "lu32.lib" )
; f! R2 M, V Z) T$ d4 Q\\" n9 v
* |1 w( u/ l! L( [( f
using namespace std;
& w\\" q, u+ m$ s' T4 _8 I: ?% [' ~
& e% Z4 n$ J8 E
luKEY Matrix=-1000; //标识矩阵类型，最终的Matrix由LockKey决定
$ ]8 T9 B x6 A0 l0 m
4 n) G\\" [# {1 I! [. E% T: H
void _stdcall LuMessage(wchar_t *pch)//输出动态库信息，该函数注册到Lu，由Lu二级函数调用 2 Q, e3 F0 q7 ~; r
{0 z# U$ O3 d0 z: n, _/ W# J8 k, R+ N
wcout<<pch;
8 A) Q' k3 g+ i$ ~
}( r. H) c$ s1 \5 c
void _stdcall DelMatrix(void *me) //用于LockKey函数，因为是基于系统内置实数数组创建矩阵，故该函数什么也不做/ ^* G\\" q6 t2 G& D+ i# p
{
+ U0 q6 G+ d; G2 e! F
}
* q8 x n4 W+ c7 g6 z j+ g0 y8 y
LuData _stdcall OpMatrix(luINT mm,LuData *xx,void *hFor,int theOperator) //运算符重载函数，用于LockKey函数. A! p8 @) S2 g\\" d& |( N' P\\" g/ J
{4 D3 B# G) y4 `( g
LuData a;
2 ?4 K: {, x# {, q$ N( f
luRealArray *pRealArray1,*pRealArray2,*pRealArray3;
- z8 `0 T2 t' C I
luVOID i,j,k,m,n,u,v;6 [! a; N' p- u) |8 V& r$ ^( b6 u
double *pa,*pb,*pc;
) l2 E) V3 G- S2 j' Y
luMessage pMessage;2 u6 H) x% y! @
wchar_t wchNum[32];
. s- f# \. d3 ^! `
char chNum[32];+ w9 s* ^/ `6 u
a.BType=luStaData_nil; a.VType=luStaData_nil; a.x=0;
# Q\\" P. d1 e' ] [% v+ e, R6 v
switch(theOperator)
4 S2 s. B\\" |% Z8 z) w9 `* }) k
{% H) Y1 j) S! B\\" }5 ]$ ]
case 2: //重载运算符*
: T1 y, ?7 s+ x, p9 k( R& M: G
pRealArray1=(luRealArray *)SearchKey((char *)&(xx->x),sizeof(luVOID),luDynData_realarray);* U. L' w, O$ t) U0 m9 t
pRealArray2=(luRealArray *)SearchKey((char *)&((xx+1)->x),sizeof(luVOID),luDynData_realarray);
4 D7 F+ j3 P% N' O% r: W
if(!pRealArray1 || !pRealArray2) break; //对象句柄无效，不是实数数组
* C. w: K' ^4 X- s; d
if(pRealArray1->DimLen!=2 || pRealArray2->DimLen!=2) break; //不是二维实数数组（矩阵）
. f1 @: r, H' y2 Y C) |
if(pRealArray1->Dim[1]!=pRealArray2->Dim[0]) break; //维数不匹配
0 R' {4 s8 K! o/ n, l1 t1 m
pRealArray3=(luRealArray *)NewSysObj(luDynData_realarray,pRealArray1->Dim[0]*pRealArray2->Dim[1],2); //创建矩阵对象, W/ O L: @; b! |# X7 ]
if(!pRealArray3) break;
1 m6 j6 _, L, q2 m5 H% l
pRealArray3->Dim[0]=pRealArray1->Dim[0]; pRealArray3->Dim[1]=pRealArray2->Dim[1]; //设置矩阵维数大小
: r) H- T D7 v: t# g8 X
pa=pRealArray1->Array; pb=pRealArray2->Array; pc=pRealArray3->Array;
# [1 C: S4 {* N9 D! M5 ^1 r
m=pRealArray1->Dim[0]; n=pRealArray1->Dim[1]; k=pRealArray2->Dim[1];% E0 |) t; |# v8 ?& y
for(i=0; i<m; i++) //矩阵乘/ _8 l+ _. z, n5 |7 g\\" {. I
{7 s- n$ b7 B7 d1 n' M% f
for(j=0; j<k; j++)4 }' ~( ~' C% I
{) G0 l3 |' C9 P8 v% Y- i
u=i*k+j; pc[u]=0.0;
4 W x1 h) K! p, }; @8 G0 {' M
for (v=0; v<n; v++)# }' m' e4 t u
{) a# ?1 l6 ~1 o* ?
pc[u]=pc[u]+pa[i*n+v]*pb[v*k+j];8 ?$ S T1 Y5 ?% N: y3 P
}
* h- k6 o s: S5 u
}; W6 k, W, S! c, N) @0 N: t& p
}5 L+ j$ j) ~2 ^6 {6 K. e0 A$ T
FunReObj(hFor); //告诉Lu，返回一个动态对象& J4 _! \% b) ?. i
a.BType=luDynData_realarray; a.VType=Matrix; a.x=0; *(luVOID *)&(a.x)=(luVOID)pRealArray3;) E2 k W# L# R
break;
\\" j. w. ], l9 ]. _, x
case 25: //重载运算符.*$ Y+ z/ y% W2 u; }* `
pRealArray1=(luRealArray *)SearchKey((char *)&(xx->x),sizeof(luVOID),luDynData_realarray);
, Z9 l4 r( |- U. D
pRealArray2=(luRealArray *)SearchKey((char *)&((xx+1)->x),sizeof(luVOID),luDynData_realarray); d# q5 r3 C* E( X
if(!pRealArray1 || !pRealArray2) break; //对象句柄无效，不是实数数组2 `; n2 h3 i# a, j1 S5 E: U9 r8 ]
if(pRealArray1->DimLen!=2 || pRealArray2->DimLen!=2) break; //不是二维实数数组（矩阵）% Z+ s I n* [. `
if(pRealArray1->Dim[0]!=pRealArray2->Dim[0] || pRealArray1->Dim[1]!=pRealArray2->Dim[1]) break; //维数不相同
& }: y: G4 ]; C% P
pRealArray3=(luRealArray *)NewSysObj(luDynData_realarray,pRealArray1->ArrayLen,2); //创建矩阵对象& T0 m: ^2 @. k! O
if(!pRealArray3) break;! W* [# ?2 P x. s5 }
pRealArray3->Dim[0]=pRealArray1->Dim[0]; pRealArray3->Dim[1]=pRealArray1->Dim[1]; //设置矩阵维数大小: M3 \. g+ R( ~5 @6 E
for(i=0;i<pRealArray1->ArrayLen;i++) pRealArray3->Array[i]=pRealArray1->Array[i]*pRealArray2->Array[i];//矩阵点乘
! S# _7 r4 A* h# |( P
FunReObj(hFor); //告诉Lu，返回一个动态对象: V9 W; o2 ^$ ^$ r
a.BType=luDynData_realarray; a.VType=Matrix; a.x=0; *(luVOID *)&(a.x)=(luVOID)pRealArray3;
2 Q' [+ l/ W) \3 i7 T. u4 j1 V
break;
/ C0 y) }3 V2 E! S; V
case 46: //重载函数new\\" [/ o; J D+ R3 V9 l
a=ExeOperator(mm,xx,hFor,theOperator,luDynData_realarray); //直接调用基本类型luDynData_realarray的new函数5 o! t0 X- j# y* E/ ^3 a. H$ Q! |
if(a.VType==luDynData_realarray) a.VType=Matrix; //设置扩展类型为自定义的Matrix类型
$ H\\" C3 w& l8 d$ q ?
break;
/ q' N% t\\" L$ K
case 49: //重载函数o) D2 L8 T( M0 n+ J: e8 l. p
pMessage=(luMessage)SearchKey("\0\0\0\0",sizeof(luVOID),luPubKey_User);
2 _4 M E' s# Z! w. S: E
if(!pMessage) break;
. V) t# i2 b& i
pRealArray1=(luRealArray *)SearchKey((char *)&(xx->x),sizeof(luVOID),luDynData_realarray);
; X4 S9 R, {' `% x
if(!pRealArray1) break; //对象句柄无效，不是实数数组+ b\\" l8 {9 P2 }+ R\\" A
if(pRealArray1->DimLen!=2) break; //不是二维实数数组（矩阵）
* ?- i _1 V5 Q, Z2 _
pa=pRealArray1->Array;% e\\" X% _: f+ o( t+ @
m=pRealArray1->Dim[0]; n=pRealArray1->Dim[1]; k=0;
$ p, I; r/ v5 Z# A\\" U
for(i=0; i<m; i++) //输出矩阵4 d- i9 k+ g) a
{) ?. v. P- w. P' {
pMessage(L"\r\n"); k+=2;7 y2 T, ~* a) k5 H; [
for(j=0; j<n; j++)4 p0 [$ d6 C: i
{
_* F\\" l5 D6 R4 V
_gcvt_s(chNum,pa[i*n+j],16);4 p3 V7 ^: l* S, E
for(u=0;chNum[u];u++) {wchNum[u]=chNum[u]; k++;}
' |9 ^' A P8 `\\" `7 v$ J
wchNum[u]='\0';
5 |, E6 \8 q5 s' y
pMessage(wchNum); pMessage(L" "); k+=2;3 |\\" s0 U( }. e0 T
}' _, M3 `1 [5 \/ d# u0 q: g* O1 ?
}
3 G9 ?, d4 o4 |0 s' O
pMessage(L"\r\n"); k+=2;
0 A2 B* \, T2 E/ l: Z8 @\\" @
a.BType=luStaData_int64; a.VType=luStaData_int64; a.x=k; //按函数o的要求，返回输出的字符总数
0 n9 J- k+ y5 Z P
break;
9 s0 |\\" a& y$ Q. ~\\" a t: |
default:/ J0 g; C. Z8 P& u+ `2 O\\" L3 w
break;
0 I1 w! F) u5 P ]+ [; W0 `
}6 k6 v+ b2 H% S
return a;, P% ]. b2 D7 B2 q7 G
}
2 z* v: H5 u\\" ] Y* L! q- }' ~
void main(void)- w8 c5 M- [* h; ~: t# p\\" ?
{/ s: q& c0 Y1 d8 F7 n6 y
void *hFor; //表达式句柄, Q2 ]2 N, G* @1 ^
luINT nPara; //存放表达式的自变量个数
' y% I- B$ F2 c0 ?: Y3 S
LuData *pPara; //存放输入自变量的数组指针( c\\" e0 e2 ]2 R* B
luINT ErrBegin,ErrEnd; //表达式编译出错的初始位置和结束位置. d& V: e1 G' S+ J
int ErrCode; //错误代码
9 o3 a% m# j\\" p: c
void *v;
# M+ \* `9 P& i# I2 ^& }( b0 [
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.]}";//字符串表达式，矩阵乘3 D0 a# ?+ w* A. k5 l) L
//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.]}";//字符串表达式，矩阵点乘
* X/ H k) S+ {6 k, E p
LuData Val;
. L4 ]\\" r( Y& r
if(!InitLu()) return; //初始化Lu
8 E6 `! T% S! [; r! @ ]
while(LockKey(Matrix,DelMatrix,OpMatrix)){Matrix++;} //锁定一个键，用于存储矩阵扩展类型
8 }! V, V$ i) x( q, ^; s
* K9 _; H. {& \% |4 o
Val.BType=luStaData_int64; Val.VType=luStaData_int64; Val.x=Matrix; //定义整数常量
\\" k% [1 j! g- {4 U3 D2 F% w) T
SetConst(L"matrix",&Val); //设置整数常量7 p0 B. d) j2 L0 `+ P
InsertKey("\0\0\0\0",4,luPubKey_User,LuMessage,NULL,NULL,1,v); //使Lu运行时可输出函数信息
$ b2 E) R1 _; R% d+ P3 F* O! h
wcout.imbue(locale("chs")); //设置输出的locale为中文
9 h\\" |2 b7 H( D1 _: I0 J7 X$ o8 v
/ ]4 C% L- B; P& `/ F
ErrCode=LuCom(ForStr,0,0,0,hFor,nPara,pPara,ErrBegin,ErrEnd); //编译表达式
8 |( e4 i* E: b( y. P. f
if(ErrCode)
4 @: a; K3 I2 k: Q9 P% R
{
7 i+ B0 |: u! ?- k( e4 d9 P
wcout<<L"表达式有错误！错误代码："<<ErrCode<<endl;
3 g; Q. v\\" y5 r) J5 }: m9 l
}
% V1 h7 a1 n: H; n3 V- B
else% U9 v6 a! `# y: U1 @
{
' F% ? F' i4 P8 F7 D% }- n
LuCal(hFor,pPara); //计算表达式的值
\\" l6 J E$ b; ~7 V, @) r1 j* b
}* _\\" J- v0 J7 W% |; O3 r# f( O
LockKey(Matrix,NULL,OpMatrix);//解锁键Matrix，本例中，该函数可以不用 i$ Q4 e/ g% ?; q
FreeLu(); //释放Lu' T9 k, `\\" q8 B
}

#include <windows.h> 
+ j% h\\" v; L+ n- D1 l9 u
#include <iostream> 
8 U7 Q) [# L8 T7 n7 u
#include <math.h> 
  i# K1 [' W# [. O: h. O
#include "lu32.h"7 t; B* r! c8 g/ e* u

8 y/ c# y* e1 ]2 L( y) ^

#pragma comment( lib, "lu32.lib" ) 
; f! R2 M, V  Z) T$ d4 Q\\" n9 v
 
* |1 w( u/ l! L( [( f
using namespace std; 
& w\\" q, u+ m$ s' T4 _8 I: ?% [' ~
& e% Z4 n$ J8 E

luKEY Matrix=-1000;        //标识矩阵类型，最终的Matrix由LockKey决定 
$ ]8 T9 B  x6 A0 l0 m
4 n) G\\" [# {1 I! [. E% T: H

void _stdcall LuMessage(wchar_t *pch)//输出动态库信息，该函数注册到Lu，由Lu二级函数调用 2 Q, e3 F0 q7 ~; r

{0 z# U$ O3 d0 z: n, _/ W# J8 k, R+ N

wcout<<pch; 
8 A) Q' k3 g+ i$ ~
}( r. H) c$ s1 \5 c

void _stdcall DelMatrix(void *me)        //用于LockKey函数，因为是基于系统内置实数数组创建矩阵，故该函数什么也不做/ ^* G\\" q6 t2 G& D+ i# p

{ 
+ U0 q6 G+ d; G2 e! F
} 
* q8 x  n4 W+ c7 g6 z  j+ g0 y8 y
LuData _stdcall OpMatrix(luINT mm,LuData *xx,void *hFor,int theOperator)        //运算符重载函数，用于LockKey函数. A! p8 @) S2 g\\" d& |( N' P\\" g/ J

{4 D3 B# G) y4 `( g

LuData a; 
2 ?4 K: {, x# {, q$ N( f
        luRealArray *pRealArray1,*pRealArray2,*pRealArray3; 
- z8 `0 T2 t' C  I
        luVOID i,j,k,m,n,u,v;6 [! a; N' p- u) |8 V& r$ ^( b6 u

double *pa,*pb,*pc; 
) l2 E) V3 G- S2 j' Y
        luMessage pMessage;2 u6 H) x% y! @

wchar_t wchNum[32]; 
. s- f# \. d3 ^! `
        char chNum[32];+ w9 s* ^/ `6 u

a.BType=luStaData_nil; a.VType=luStaData_nil; a.x=0; 
# Q\\" P. d1 e' ]  [% v+ e, R6 v
        switch(theOperator) 
4 S2 s. B\\" |% Z8 z) w9 `* }) k
        {% H) Y1 j) S! B\\" }5 ]$ ]

case 2:        //重载运算符* 
: T1 y, ?7 s+ x, p9 k( R& M: G
                pRealArray1=(luRealArray *)SearchKey((char *)&(xx->x),sizeof(luVOID),luDynData_realarray);* U. L' w, O$ t) U0 m9 t

pRealArray2=(luRealArray *)SearchKey((char *)&((xx+1)->x),sizeof(luVOID),luDynData_realarray); 
4 D7 F+ j3 P% N' O% r: W
                if(!pRealArray1 || !pRealArray2) break;        //对象句柄无效，不是实数数组 
* C. w: K' ^4 X- s; d
                if(pRealArray1->DimLen!=2 || pRealArray2->DimLen!=2) break;        //不是二维实数数组（矩阵） 
. f1 @: r, H' y2 Y  C) |
                if(pRealArray1->Dim[1]!=pRealArray2->Dim[0]) break;        //维数不匹配 
0 R' {4 s8 K! o/ n, l1 t1 m
                pRealArray3=(luRealArray *)NewSysObj(luDynData_realarray,pRealArray1->Dim[0]*pRealArray2->Dim[1],2);        //创建矩阵对象, W/ O  L: @; b! |# X7 ]

if(!pRealArray3) break; 
1 m6 j6 _, L, q2 m5 H% l
                pRealArray3->Dim[0]=pRealArray1->Dim[0]; pRealArray3->Dim[1]=pRealArray2->Dim[1];        //设置矩阵维数大小 
: r) H- T  D7 v: t# g8 X
                pa=pRealArray1->Array; pb=pRealArray2->Array; pc=pRealArray3->Array; 
# [1 C: S4 {* N9 D! M5 ^1 r
                m=pRealArray1->Dim[0]; n=pRealArray1->Dim[1]; k=pRealArray2->Dim[1];% E0 |) t; |# v8 ?& y

for(i=0; i<m; i++)        //矩阵乘/ _8 l+ _. z, n5 |7 g\\" {. I

{7 s- n$ b7 B7 d1 n' M% f

for(j=0; j<k; j++)4 }' ~( ~' C% I

{) G0 l3 |' C9 P8 v% Y- i

u=i*k+j; pc[u]=0.0; 
4 W  x1 h) K! p, }; @8 G0 {' M
                                for (v=0; v<n; v++)# }' m' e4 t  u

{) a# ?1 l6 ~1 o* ?

pc[u]=pc[u]+pa[i*n+v]*pb[v*k+j];8 ?$ S  T1 Y5 ?% N: y3 P

} 
* h- k6 o  s: S5 u
                        }; W6 k, W, S! c, N) @0 N: t& p

}5 L+ j$ j) ~2 ^6 {6 K. e0 A$ T

FunReObj(hFor);        //告诉Lu，返回一个动态对象& J4 _! \% b) ?. i

a.BType=luDynData_realarray; a.VType=Matrix; a.x=0; *(luVOID *)&(a.x)=(luVOID)pRealArray3;) E2 k  W# L# R

break; 
\\" j. w. ], l9 ]. _, x
        case 25:        //重载运算符.*$ Y+ z/ y% W2 u; }* `

pRealArray1=(luRealArray *)SearchKey((char *)&(xx->x),sizeof(luVOID),luDynData_realarray); 
, Z9 l4 r( |- U. D
                pRealArray2=(luRealArray *)SearchKey((char *)&((xx+1)->x),sizeof(luVOID),luDynData_realarray);  d# q5 r3 C* E( X

if(!pRealArray1 || !pRealArray2) break;        //对象句柄无效，不是实数数组2 `; n2 h3 i# a, j1 S5 E: U9 r8 ]

if(pRealArray1->DimLen!=2 || pRealArray2->DimLen!=2) break;        //不是二维实数数组（矩阵）% Z+ s  I  n* [. `

if(pRealArray1->Dim[0]!=pRealArray2->Dim[0] || pRealArray1->Dim[1]!=pRealArray2->Dim[1]) break;        //维数不相同 
& }: y: G4 ]; C% P
                pRealArray3=(luRealArray *)NewSysObj(luDynData_realarray,pRealArray1->ArrayLen,2);        //创建矩阵对象& T0 m: ^2 @. k! O

if(!pRealArray3) break;! W* [# ?2 P  x. s5 }

pRealArray3->Dim[0]=pRealArray1->Dim[0]; pRealArray3->Dim[1]=pRealArray1->Dim[1];        //设置矩阵维数大小: M3 \. g+ R( ~5 @6 E

for(i=0;i<pRealArray1->ArrayLen;i++) pRealArray3->Array[i]=pRealArray1->Array[i]*pRealArray2->Array[i];//矩阵点乘 
! S# _7 r4 A* h# |( P
                FunReObj(hFor);        //告诉Lu，返回一个动态对象: V9 W; o2 ^$ ^$ r

a.BType=luDynData_realarray; a.VType=Matrix; a.x=0; *(luVOID *)&(a.x)=(luVOID)pRealArray3; 
2 Q' [+ l/ W) \3 i7 T. u4 j1 V
                break; 
/ C0 y) }3 V2 E! S; V
        case 46:        //重载函数new\\" [/ o; J  D+ R3 V9 l

a=ExeOperator(mm,xx,hFor,theOperator,luDynData_realarray);        //直接调用基本类型luDynData_realarray的new函数5 o! t0 X- j# y* E/ ^3 a. H$ Q! |

if(a.VType==luDynData_realarray) a.VType=Matrix;        //设置扩展类型为自定义的Matrix类型 
$ H\\" C3 w& l8 d$ q  ?
                break; 
/ q' N% t\\" L$ K
        case 49:        //重载函数o) D2 L8 T( M0 n+ J: e8 l. p

pMessage=(luMessage)SearchKey("\0\0\0\0",sizeof(luVOID),luPubKey_User); 
2 _4 M  E' s# Z! w. S: E
                if(!pMessage) break; 
. V) t# i2 b& i
                pRealArray1=(luRealArray *)SearchKey((char *)&(xx->x),sizeof(luVOID),luDynData_realarray); 
; X4 S9 R, {' `% x
                if(!pRealArray1) break;        //对象句柄无效，不是实数数组+ b\\" l8 {9 P2 }+ R\\" A

if(pRealArray1->DimLen!=2) break;        //不是二维实数数组（矩阵） 
* ?- i  _1 V5 Q, Z2 _
                pa=pRealArray1->Array;% e\\" X% _: f+ o( t+ @

m=pRealArray1->Dim[0]; n=pRealArray1->Dim[1]; k=0; 
$ p, I; r/ v5 Z# A\\" U
                for(i=0; i<m; i++)        //输出矩阵4 d- i9 k+ g) a

{) ?. v. P- w. P' {

pMessage(L"\r\n"); k+=2;7 y2 T, ~* a) k5 H; [

for(j=0; j<n; j++)4 p0 [$ d6 C: i

{ 
  _* F\\" l5 D6 R4 V
                                _gcvt_s(chNum,pa[i*n+j],16);4 p3 V7 ^: l* S, E

for(u=0;chNum[u];u++) {wchNum[u]=chNum[u]; k++;} 
' |9 ^' A  P8 `\\" `7 v$ J
                                wchNum[u]='\0'; 
5 |, E6 \8 q5 s' y
                                pMessage(wchNum); pMessage(L"  "); k+=2;3 |\\" s0 U( }. e0 T

}' _, M3 `1 [5 \/ d# u0 q: g* O1 ?

} 
3 G9 ?, d4 o4 |0 s' O
                pMessage(L"\r\n"); k+=2; 
0 A2 B* \, T2 E/ l: Z8 @\\" @
                a.BType=luStaData_int64; a.VType=luStaData_int64; a.x=k;        //按函数o的要求，返回输出的字符总数 
0 n9 J- k+ y5 Z  P
                break; 
9 s0 |\\" a& y$ Q. ~\\" a  t: |
        default:/ J0 g; C. Z8 P& u+ `2 O\\" L3 w

break; 
0 I1 w! F) u5 P  ]+ [; W0 `
        }6 k6 v+ b2 H% S

return a;, P% ]. b2 D7 B2 q7 G

} 
2 z* v: H5 u\\" ]  Y* L! q- }' ~
void main(void)- w8 c5 M- [* h; ~: t# p\\" ?

{/ s: q& c0 Y1 d8 F7 n6 y

void *hFor;                //表达式句柄, Q2 ]2 N, G* @1 ^

luINT nPara;                //存放表达式的自变量个数 
' y% I- B$ F2 c0 ?: Y3 S
        LuData *pPara;                //存放输入自变量的数组指针( c\\" e0 e2 ]2 R* B

luINT ErrBegin,ErrEnd;        //表达式编译出错的初始位置和结束位置. d& V: e1 G' S+ J

int ErrCode;                //错误代码 
9 o3 a% m# j\\" p: c
        void *v; 
# M+ \* `9 P& i# I2 ^& }( b0 [
        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.]}";//字符串表达式，矩阵乘3 D0 a# ?+ w* A. k5 l) L

//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.]}";//字符串表达式，矩阵点乘 
* X/ H  k) S+ {6 k, E  p
        LuData Val; 
. L4 ]\\" r( Y& r
        if(!InitLu()) return;        //初始化Lu 
8 E6 `! T% S! [; r! @  ]
        while(LockKey(Matrix,DelMatrix,OpMatrix)){Matrix++;}        //锁定一个键，用于存储矩阵扩展类型 
8 }! V, V$ i) x( q, ^; s
* K9 _; H. {& \% |4 o

Val.BType=luStaData_int64; Val.VType=luStaData_int64; Val.x=Matrix;        //定义整数常量 
\\" k% [1 j! g- {4 U3 D2 F% w) T
        SetConst(L"matrix",&Val);        //设置整数常量7 p0 B. d) j2 L0 `+ P

InsertKey("\0\0\0\0",4,luPubKey_User,LuMessage,NULL,NULL,1,v); //使Lu运行时可输出函数信息 
$ b2 E) R1 _; R% d+ P3 F* O! h
        wcout.imbue(locale("chs"));        //设置输出的locale为中文 
9 h\\" |2 b7 H( D1 _: I0 J7 X$ o8 v
   
/ ]4 C% L- B; P& `/ F
        ErrCode=LuCom(ForStr,0,0,0,hFor,nPara,pPara,ErrBegin,ErrEnd); //编译表达式 
8 |( e4 i* E: b( y. P. f
        if(ErrCode) 
4 @: a; K3 I2 k: Q9 P% R
        { 
7 i+ B0 |: u! ?- k( e4 d9 P
                wcout<<L"表达式有错误！错误代码："<<ErrCode<<endl; 
3 g; Q. v\\" y5 r) J5 }: m9 l
        } 
% V1 h7 a1 n: H; n3 V- B
        else% U9 v6 a! `# y: U1 @

{ 
' F% ?  F' i4 P8 F7 D% }- n
                LuCal(hFor,pPara);        //计算表达式的值 
\\" l6 J  E$ b; ~7 V, @) r1 j* b
        }* _\\" J- v0 J7 W% |; O3 r# f( O

LockKey(Matrix,NULL,OpMatrix);//解锁键Matrix，本例中，该函数可以不用  i$ Q4 e/ g% ?; q

FreeLu();                        //释放Lu' T9 k, `\\" q8 B

}

习题：

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

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

main(:a,b,c,d,t,i)=4 t7 ^: L6 x3 q- `* f\" K* W
a=new[matrix,2,2,data:1.,2.,2.,1.],
( y% y! N' D+ a/ ~) K8 Q
b=new[matrix,2,2,data:2.,1.,1.,2.],( V6 I% h! q9 {2 ?
c=new[matrix,2,2,data:2/3.,-1/3.,-1/3.,2/3.],/ q' ?0 r8 `\" i: y
t=clock(),+ E8 }- e% f7 ]' t
d=a*b, i=0, while{i<1000000, d=d*c*b, i++},0 z% v5 y/ ]. T4 I, g7 S1 z0 r
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\"}";//字符串表达式

复制代码

结果：