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

查看: 8896|回复: 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>7 _ f\\" H; N9 j# B1 _, z
#include <iostream>
0 r$ Z- b# G; }
#include <math.h>
' {- l6 D2 |3 W
#include "lu32.h"0 y# p5 K\\" ]2 s6 F3 p
, F: Z4 J; }: g: C
#pragma comment( lib, "lu32.lib" )* f7 t& U( h: n7 W k: z. I
6 G1 D# J3 [. |
using namespace std;. @1 a h' `# w W; p+ O! }
. U9 |% A y+ |2 V
luKEY Matrix=-1000; //标识矩阵类型，最终的Matrix由LockKey决定# V/ ^6 h\\" b6 t% E' }
4 z( L1 z5 D7 Z5 M- T% f
void _stdcall LuMessage(wchar_t *pch)//输出动态库信息，该函数注册到Lu，由Lu二级函数调用 8 ?5 i5 ^# ~2 ~0 j\\" o
{
8 r% `7 R. K: c# [2 G- Z\\" O+ u
wcout<<pch;! x+ O% f* T3 L# p\\" v8 r. a
}* ?+ F/ w: V. Q
void _stdcall DelMatrix(void *me) //用于LockKey函数，因为是基于系统内置实数数组创建矩阵，故该函数什么也不做& @& V3 ]! s. v. G3 i% |; o- s
{6 I6 C5 T7 }( g# k/ L! c
}
\\" d' h% |; @, S\\" i5 F. w0 I
LuData _stdcall OpMatrix(luINT mm,LuData *xx,void *hFor,int theOperator) //运算符重载函数，用于LockKey函数
( b; [, r* G6 |1 s' w
{
% v8 Q+ `7 Q1 N& Y8 a/ k
LuData a;
3 D5 Y! ]; j7 r% `; w\\" c5 n
luRealArray *pRealArray1,*pRealArray2,*pRealArray3;/ g) l& w5 M, p
luVOID i,j,k,m,n,u,v;
J/ X8 j8 U N# f
double *pa,*pb,*pc;
6 Y, _9 {5 x' z2 C
luMessage pMessage;2 S) [) s+ |& @$ a
wchar_t wchNum[32];
1 D7 x4 P0 x: s& V( [
char chNum[32];
\\" Y, ~. q5 ?8 L/ `
a.BType=luStaData_nil; a.VType=luStaData_nil; a.x=0;/ G3 R; [7 _' ^+ T
switch(theOperator)% e7 q4 E1 a3 T/ s
{
: y8 ], |* d9 B* z r6 d
case 2: //重载运算符*
, B& s' ?$ ^ m7 w, x8 g
pRealArray1=(luRealArray *)SearchKey((char *)&(xx->x),sizeof(luVOID),luDynData_realarray);* _6 f\\" F; P( o+ Q
pRealArray2=(luRealArray *)SearchKey((char *)&((xx+1)->x),sizeof(luVOID),luDynData_realarray);; E! e\\" a2 C: E+ t
if(!pRealArray1 || !pRealArray2) break; //对象句柄无效，不是实数数组
$ C- f8 W$ O- Z+ U+ {3 z
if(pRealArray1->DimLen!=2 || pRealArray2->DimLen!=2) break; //不是二维实数数组（矩阵）9 N6 O. B; S! D- e
if(pRealArray1->Dim[1]!=pRealArray2->Dim[0]) break; //维数不匹配3 c; |& O8 ^: _8 R. J2 {1 q
pRealArray3=(luRealArray *)NewSysObj(luDynData_realarray,pRealArray1->Dim[0]*pRealArray2->Dim[1],2); //创建矩阵对象
- k% F( y }) ?& Q
if(!pRealArray3) break;
1 t5 h d5 g1 i
pRealArray3->Dim[0]=pRealArray1->Dim[0]; pRealArray3->Dim[1]=pRealArray2->Dim[1]; //设置矩阵维数大小! P& O% I1 m; E- d5 F2 w& F
pa=pRealArray1->Array; pb=pRealArray2->Array; pc=pRealArray3->Array;1 K2 R: @6 ~# i1 k0 K( Z
m=pRealArray1->Dim[0]; n=pRealArray1->Dim[1]; k=pRealArray2->Dim[1];0 g' u9 I0 _7 C# R8 p
for(i=0; i<m; i++) //矩阵乘
7 g( u- c1 k! J& y( Q
{9 E/ I' F\\" }# A7 V Y
for(j=0; j<k; j++)
7 G9 P; K- ?* c! ]' k
{
- ^5 r. p\\" d9 ~6 p
u=i*k+j; pc[u]=0.0;# w& a* H+ [' e$ ^8 n! `. Y
for (v=0; v<n; v++)6 e7 U: o9 z% {: H: y
{- e* i+ D. m7 M
pc[u]=pc[u]+pa[i*n+v]*pb[v*k+j];. t! L; e\\" w G
}* d6 M d3 d* f7 ^' V4 a
}6 }1 `7 E) j0 `' g
}8 v% E8 I) H. C8 x0 h h3 R
FunReObj(hFor); //告诉Lu，返回一个动态对象
2 ], K# L7 F) R\\" T) E5 N- [6 q9 Y
a.BType=luDynData_realarray; a.VType=Matrix; a.x=0; *(luVOID *)&(a.x)=(luVOID)pRealArray3;
. j9 A$ a8 E2 F$ ]# D
break;
# Y2 B$ y3 s9 @- P
case 25: //重载运算符.*
; K# E3 M- a0 f& o; w
pRealArray1=(luRealArray *)SearchKey((char *)&(xx->x),sizeof(luVOID),luDynData_realarray);0 h, t: X/ I\\" V# W/ U
pRealArray2=(luRealArray *)SearchKey((char *)&((xx+1)->x),sizeof(luVOID),luDynData_realarray);4 O; o! I) F* c\\" W# I
if(!pRealArray1 || !pRealArray2) break; //对象句柄无效，不是实数数组& M6 j q, X6 n
if(pRealArray1->DimLen!=2 || pRealArray2->DimLen!=2) break; //不是二维实数数组（矩阵）
2 D. d* ^- r6 w. b6 G9 G
if(pRealArray1->Dim[0]!=pRealArray2->Dim[0] || pRealArray1->Dim[1]!=pRealArray2->Dim[1]) break; //维数不相同
! `& {/ N. D. n
pRealArray3=(luRealArray *)NewSysObj(luDynData_realarray,pRealArray1->ArrayLen,2); //创建矩阵对象
\\" U5 d8 o. ]2 g5 O2 J. q; g
if(!pRealArray3) break;
$ \4 S! [& x4 c
pRealArray3->Dim[0]=pRealArray1->Dim[0]; pRealArray3->Dim[1]=pRealArray1->Dim[1]; //设置矩阵维数大小
. v1 h2 p$ }, @2 t t ^& J
for(i=0;i<pRealArray1->ArrayLen;i++) pRealArray3->Array[i]=pRealArray1->Array[i]*pRealArray2->Array[i];//矩阵点乘 R' t! c) n2 ?4 f6 Z
FunReObj(hFor); //告诉Lu，返回一个动态对象- s% S4 O& H `) _
a.BType=luDynData_realarray; a.VType=Matrix; a.x=0; *(luVOID *)&(a.x)=(luVOID)pRealArray3;6 J% Q\\" F; J' x) r7 N0 ]' ~
break;
5 c4 F/ M/ x$ g N7 X2 ^
case 46: //重载函数new
. ]/ W `( B5 W/ g* N. Q
a=ExeOperator(mm,xx,hFor,theOperator,luDynData_realarray); //直接调用基本类型luDynData_realarray的new函数
, D* o( `) `0 ?: V8 v8 T
if(a.VType==luDynData_realarray) a.VType=Matrix; //设置扩展类型为自定义的Matrix类型7 d2 l! H# t+ s$ ^4 C( g$ _) Q) E
break;
3 f\\" w/ ` u! Y9 E7 L( a* C! z
case 49: //重载函数o
pMessage=(luMessage)SearchKey("\0\0\0\0",sizeof(luVOID),luPubKey_User);
0 X9 y3 B, D* x7 x& ^
if(!pMessage) break;\\" j; O- v+ k2 r9 O
pRealArray1=(luRealArray *)SearchKey((char *)&(xx->x),sizeof(luVOID),luDynData_realarray);# C I8 x! N) e+ v; ~
if(!pRealArray1) break; //对象句柄无效，不是实数数组- y8 U2 `/ f5 N\\" e! W* w
if(pRealArray1->DimLen!=2) break; //不是二维实数数组（矩阵）
$ l, n. w; M; O+ z. N. j7 c* \
pa=pRealArray1->Array;
* L' }5 g( v* ?+ f! P; b
m=pRealArray1->Dim[0]; n=pRealArray1->Dim[1]; k=0;4 v\\" {1 X& K/ _! k
for(i=0; i<m; i++) //输出矩阵0 H9 A E5 U: w, r
{5 p b: k& [: q$ M
pMessage(L"\r\n"); k+=2;
0 ?) r6 ^. k+ T. _% i5 V
for(j=0; j<n; j++). q; q1 u. x7 G
{) m/ J\\" v2 J K2 Q( e9 r, t# M1 G- V
_gcvt_s(chNum,pa[i*n+j],16);
) N7 r# ^; K! ^* ~. k. K/ g
for(u=0;chNum[u];u++) {wchNum[u]=chNum[u]; k++;}
\\" ]$ u# W, F' @\\" } x6 S1 R: i' I
wchNum[u]='\0';
2 }: T* y' o6 r
pMessage(wchNum); pMessage(L" "); k+=2;$ R! D' s7 C/ w9 ~! X X& b
}
! G7 H\\" F. Q8 I+ I5 G2 a' _
}1 m# ~/ H+ H- A9 ~( T8 A& Z
pMessage(L"\r\n"); k+=2;
, B9 F0 K. W\\" L- b& h% C9 C1 X0 k
a.BType=luStaData_int64; a.VType=luStaData_int64; a.x=k; //按函数o的要求，返回输出的字符总数9 M' G8 s% R! |5 _! P0 Y( P/ x
break;* s# j4 Q' |) y2 z0 C7 X2 R; M
default:\\" L. {2 h- q+ k3 M: Y7 ?8 E6 r
break;
9 `! p6 L' m# r5 h. C
}
: E& f9 x G8 T) R4 z L
return a;* n) n* u$ R\\" D9 [9 T5 h\\" n0 l
}
3 c& o; w# Y6 K# _) B
void main(void): V! J, G: ?3 M# N7 u. k. p
{9 N# r0 N& A# y\\" V7 ~5 R
void *hFor; //表达式句柄( p, i9 [\\" S; Z2 f
luINT nPara; //存放表达式的自变量个数8 t5 S0 d9 {0 T\\" l1 e, N+ H. T
LuData *pPara; //存放输入自变量的数组指针
; z* @7 @0 Z4 {0 M0 i
luINT ErrBegin,ErrEnd; //表达式编译出错的初始位置和结束位置) W$ L P a5 H6 K# V: X2 N
int ErrCode; //错误代码
) r' E. A; w, e- N# t
void *v;: u$ Z/ d0 O3 g0 q2 l
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.]}";//字符串表达式，矩阵乘0 r$ C8 X8 ^% G# I
//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 [: _0 v+ L0 A
LuData Val;
. X5 P' s& u9 }9 L+ J3 o6 |
if(!InitLu()) return; //初始化Lu7 s0 a* C- p4 ]9 o
while(LockKey(Matrix,DelMatrix,OpMatrix)){Matrix++;} //锁定一个键，用于存储矩阵扩展类型
) X: {3 L/ j; I3 A7 ~. K, X. O
: x, Z, G' K5 X, a\\" q9 d2 D* y
Val.BType=luStaData_int64; Val.VType=luStaData_int64; Val.x=Matrix; //定义整数常量
U9 ?0 |8 d& D$ _* \* l$ F1 P3 d
SetConst(L"matrix",&Val); //设置整数常量
6 ]; s1 B6 F3 N
InsertKey("\0\0\0\0",4,luPubKey_User,LuMessage,NULL,NULL,1,v); //使Lu运行时可输出函数信息
6 r8 f# r\\" y1 b ?- I; z
wcout.imbue(locale("chs")); //设置输出的locale为中文1 h3 o, j! h8 ?& p
! S& c( l/ R( u* f! P8 g' w N
ErrCode=LuCom(ForStr,0,0,0,hFor,nPara,pPara,ErrBegin,ErrEnd); //编译表达式0 N, a0 _1 z\\" |5 K; Q\\" H& b# Z
if(ErrCode)
\\" g7 {) p. ~+ G
{
7 E x2 g$ E& U' S8 |: d. B6 a/ ^
wcout<<L"表达式有错误！错误代码："<<ErrCode<<endl;
* H# u0 c3 p; a& h! |0 D
}
* _8 d- F. t, q& W
else8 m* P9 }+ C# C* ~, U2 D4 A
{
* K/ D$ E, \3 W% U8 P0 @, Y
LuCal(hFor,pPara); //计算表达式的值
5 U8 O6 t, z. j9 I
}
1 O, t/ N+ D% s+ M
LockKey(Matrix,NULL,OpMatrix);//解锁键Matrix，本例中，该函数可以不用/ ?' T8 S' y6 N) H
FreeLu(); //释放Lu
( o& g# ^9 d& R6 c/ }- D; A
}

#include <windows.h>7 _  f\\" H; N9 j# B1 _, z

#include <iostream> 
0 r$ Z- b# G; }
#include <math.h> 
' {- l6 D2 |3 W
#include "lu32.h"0 y# p5 K\\" ]2 s6 F3 p

, F: Z4 J; }: g: C
#pragma comment( lib, "lu32.lib" )* f7 t& U( h: n7 W  k: z. I

6 G1 D# J3 [. |
using namespace std;. @1 a  h' `# w  W; p+ O! }

. U9 |% A  y+ |2 V
luKEY Matrix=-1000;        //标识矩阵类型，最终的Matrix由LockKey决定# V/ ^6 h\\" b6 t% E' }

4 z( L1 z5 D7 Z5 M- T% f
void _stdcall LuMessage(wchar_t *pch)//输出动态库信息，该函数注册到Lu，由Lu二级函数调用 8 ?5 i5 ^# ~2 ~0 j\\" o

{ 
8 r% `7 R. K: c# [2 G- Z\\" O+ u
        wcout<<pch;! x+ O% f* T3 L# p\\" v8 r. a

}* ?+ F/ w: V. Q

void _stdcall DelMatrix(void *me)        //用于LockKey函数，因为是基于系统内置实数数组创建矩阵，故该函数什么也不做& @& V3 ]! s. v. G3 i% |; o- s

{6 I6 C5 T7 }( g# k/ L! c

} 
\\" d' h% |; @, S\\" i5 F. w0 I
LuData _stdcall OpMatrix(luINT mm,LuData *xx,void *hFor,int theOperator)        //运算符重载函数，用于LockKey函数 
( b; [, r* G6 |1 s' w
{ 
% v8 Q+ `7 Q1 N& Y8 a/ k
        LuData a; 
3 D5 Y! ]; j7 r% `; w\\" c5 n
        luRealArray *pRealArray1,*pRealArray2,*pRealArray3;/ g) l& w5 M, p

luVOID i,j,k,m,n,u,v; 
  J/ X8 j8 U  N# f
        double *pa,*pb,*pc; 
6 Y, _9 {5 x' z2 C
        luMessage pMessage;2 S) [) s+ |& @$ a

wchar_t wchNum[32]; 
1 D7 x4 P0 x: s& V( [
        char chNum[32]; 
\\" Y, ~. q5 ?8 L/ `
        a.BType=luStaData_nil; a.VType=luStaData_nil; a.x=0;/ G3 R; [7 _' ^+ T

switch(theOperator)% e7 q4 E1 a3 T/ s

{ 
: y8 ], |* d9 B* z  r6 d
        case 2:        //重载运算符* 
, B& s' ?$ ^  m7 w, x8 g
                pRealArray1=(luRealArray *)SearchKey((char *)&(xx->x),sizeof(luVOID),luDynData_realarray);* _6 f\\" F; P( o+ Q

pRealArray2=(luRealArray *)SearchKey((char *)&((xx+1)->x),sizeof(luVOID),luDynData_realarray);; E! e\\" a2 C: E+ t

if(!pRealArray1 || !pRealArray2) break;        //对象句柄无效，不是实数数组 
$ C- f8 W$ O- Z+ U+ {3 z
                if(pRealArray1->DimLen!=2 || pRealArray2->DimLen!=2) break;        //不是二维实数数组（矩阵）9 N6 O. B; S! D- e

if(pRealArray1->Dim[1]!=pRealArray2->Dim[0]) break;        //维数不匹配3 c; |& O8 ^: _8 R. J2 {1 q

pRealArray3=(luRealArray *)NewSysObj(luDynData_realarray,pRealArray1->Dim[0]*pRealArray2->Dim[1],2);        //创建矩阵对象 
- k% F( y  }) ?& Q
                if(!pRealArray3) break; 
1 t5 h  d5 g1 i
                pRealArray3->Dim[0]=pRealArray1->Dim[0]; pRealArray3->Dim[1]=pRealArray2->Dim[1];        //设置矩阵维数大小! P& O% I1 m; E- d5 F2 w& F

pa=pRealArray1->Array; pb=pRealArray2->Array; pc=pRealArray3->Array;1 K2 R: @6 ~# i1 k0 K( Z

m=pRealArray1->Dim[0]; n=pRealArray1->Dim[1]; k=pRealArray2->Dim[1];0 g' u9 I0 _7 C# R8 p

for(i=0; i<m; i++)        //矩阵乘 
7 g( u- c1 k! J& y( Q
                {9 E/ I' F\\" }# A7 V  Y

for(j=0; j<k; j++) 
7 G9 P; K- ?* c! ]' k
                        { 
- ^5 r. p\\" d9 ~6 p
                                u=i*k+j; pc[u]=0.0;# w& a* H+ [' e$ ^8 n! `. Y

for (v=0; v<n; v++)6 e7 U: o9 z% {: H: y

{- e* i+ D. m7 M

pc[u]=pc[u]+pa[i*n+v]*pb[v*k+j];. t! L; e\\" w  G

}* d6 M  d3 d* f7 ^' V4 a

}6 }1 `7 E) j0 `' g

}8 v% E8 I) H. C8 x0 h  h3 R

FunReObj(hFor);        //告诉Lu，返回一个动态对象 
2 ], K# L7 F) R\\" T) E5 N- [6 q9 Y
                a.BType=luDynData_realarray; a.VType=Matrix; a.x=0; *(luVOID *)&(a.x)=(luVOID)pRealArray3; 
. j9 A$ a8 E2 F$ ]# D
                break; 
# Y2 B$ y3 s9 @- P
        case 25:        //重载运算符.* 
; K# E3 M- a0 f& o; w
                pRealArray1=(luRealArray *)SearchKey((char *)&(xx->x),sizeof(luVOID),luDynData_realarray);0 h, t: X/ I\\" V# W/ U

pRealArray2=(luRealArray *)SearchKey((char *)&((xx+1)->x),sizeof(luVOID),luDynData_realarray);4 O; o! I) F* c\\" W# I

if(!pRealArray1 || !pRealArray2) break;        //对象句柄无效，不是实数数组& M6 j  q, X6 n

if(pRealArray1->DimLen!=2 || pRealArray2->DimLen!=2) break;        //不是二维实数数组（矩阵） 
2 D. d* ^- r6 w. b6 G9 G
                if(pRealArray1->Dim[0]!=pRealArray2->Dim[0] || pRealArray1->Dim[1]!=pRealArray2->Dim[1]) break;        //维数不相同 
! `& {/ N. D. n
                pRealArray3=(luRealArray *)NewSysObj(luDynData_realarray,pRealArray1->ArrayLen,2);        //创建矩阵对象 
\\" U5 d8 o. ]2 g5 O2 J. q; g
                if(!pRealArray3) break; 
$ \4 S! [& x4 c
                pRealArray3->Dim[0]=pRealArray1->Dim[0]; pRealArray3->Dim[1]=pRealArray1->Dim[1];        //设置矩阵维数大小 
. v1 h2 p$ }, @2 t  t  ^& J
                for(i=0;i<pRealArray1->ArrayLen;i++) pRealArray3->Array[i]=pRealArray1->Array[i]*pRealArray2->Array[i];//矩阵点乘  R' t! c) n2 ?4 f6 Z

FunReObj(hFor);        //告诉Lu，返回一个动态对象- s% S4 O& H  `) _

a.BType=luDynData_realarray; a.VType=Matrix; a.x=0; *(luVOID *)&(a.x)=(luVOID)pRealArray3;6 J% Q\\" F; J' x) r7 N0 ]' ~

break; 
5 c4 F/ M/ x$ g  N7 X2 ^
        case 46:        //重载函数new 
. ]/ W  `( B5 W/ g* N. Q
                a=ExeOperator(mm,xx,hFor,theOperator,luDynData_realarray);        //直接调用基本类型luDynData_realarray的new函数 
, D* o( `) `0 ?: V8 v8 T
                if(a.VType==luDynData_realarray) a.VType=Matrix;        //设置扩展类型为自定义的Matrix类型7 d2 l! H# t+ s$ ^4 C( g$ _) Q) E

break; 
3 f\\" w/ `  u! Y9 E7 L( a* C! z
        case 49:        //重载函数o 
4 p$ A3 H6 g2 W\\" i\\" X* W0 k5 m: ^) b
                pMessage=(luMessage)SearchKey("\0\0\0\0",sizeof(luVOID),luPubKey_User); 
0 X9 y3 B, D* x7 x& ^
                if(!pMessage) break;\\" j; O- v+ k2 r9 O

pRealArray1=(luRealArray *)SearchKey((char *)&(xx->x),sizeof(luVOID),luDynData_realarray);# C  I8 x! N) e+ v; ~

if(!pRealArray1) break;        //对象句柄无效，不是实数数组- y8 U2 `/ f5 N\\" e! W* w

if(pRealArray1->DimLen!=2) break;        //不是二维实数数组（矩阵） 
$ l, n. w; M; O+ z. N. j7 c* \
                pa=pRealArray1->Array; 
* L' }5 g( v* ?+ f! P; b
                m=pRealArray1->Dim[0]; n=pRealArray1->Dim[1]; k=0;4 v\\" {1 X& K/ _! k

for(i=0; i<m; i++)        //输出矩阵0 H9 A  E5 U: w, r

{5 p  b: k& [: q$ M

pMessage(L"\r\n"); k+=2; 
0 ?) r6 ^. k+ T. _% i5 V
                        for(j=0; j<n; j++). q; q1 u. x7 G

{) m/ J\\" v2 J  K2 Q( e9 r, t# M1 G- V

_gcvt_s(chNum,pa[i*n+j],16); 
) N7 r# ^; K! ^* ~. k. K/ g
                                for(u=0;chNum[u];u++) {wchNum[u]=chNum[u]; k++;} 
\\" ]$ u# W, F' @\\" }  x6 S1 R: i' I
                                wchNum[u]='\0'; 
2 }: T* y' o6 r
                                pMessage(wchNum); pMessage(L"  "); k+=2;$ R! D' s7 C/ w9 ~! X  X& b

} 
! G7 H\\" F. Q8 I+ I5 G2 a' _
                }1 m# ~/ H+ H- A9 ~( T8 A& Z

pMessage(L"\r\n"); k+=2; 
, B9 F0 K. W\\" L- b& h% C9 C1 X0 k
                a.BType=luStaData_int64; a.VType=luStaData_int64; a.x=k;        //按函数o的要求，返回输出的字符总数9 M' G8 s% R! |5 _! P0 Y( P/ x

break;* s# j4 Q' |) y2 z0 C7 X2 R; M

default:\\" L. {2 h- q+ k3 M: Y7 ?8 E6 r

break; 
9 `! p6 L' m# r5 h. C
        } 
: E& f9 x  G8 T) R4 z  L
        return a;* n) n* u$ R\\" D9 [9 T5 h\\" n0 l

} 
3 c& o; w# Y6 K# _) B
void main(void): V! J, G: ?3 M# N7 u. k. p

{9 N# r0 N& A# y\\" V7 ~5 R

void *hFor;                //表达式句柄( p, i9 [\\" S; Z2 f

luINT nPara;                //存放表达式的自变量个数8 t5 S0 d9 {0 T\\" l1 e, N+ H. T

LuData *pPara;                //存放输入自变量的数组指针 
; z* @7 @0 Z4 {0 M0 i
        luINT ErrBegin,ErrEnd;        //表达式编译出错的初始位置和结束位置) W$ L  P  a5 H6 K# V: X2 N

int ErrCode;                //错误代码 
) r' E. A; w, e- N# t
        void *v;: u$ Z/ d0 O3 g0 q2 l

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.]}";//字符串表达式，矩阵乘0 r$ C8 X8 ^% G# I

//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 [: _0 v+ L0 A

LuData Val; 
. X5 P' s& u9 }9 L+ J3 o6 |
        if(!InitLu()) return;        //初始化Lu7 s0 a* C- p4 ]9 o

while(LockKey(Matrix,DelMatrix,OpMatrix)){Matrix++;}        //锁定一个键，用于存储矩阵扩展类型 
) X: {3 L/ j; I3 A7 ~. K, X. O
: x, Z, G' K5 X, a\\" q9 d2 D* y

Val.BType=luStaData_int64; Val.VType=luStaData_int64; Val.x=Matrix;        //定义整数常量 
  U9 ?0 |8 d& D$ _* \* l$ F1 P3 d
        SetConst(L"matrix",&Val);        //设置整数常量 
6 ]; s1 B6 F3 N
        InsertKey("\0\0\0\0",4,luPubKey_User,LuMessage,NULL,NULL,1,v); //使Lu运行时可输出函数信息 
6 r8 f# r\\" y1 b  ?- I; z
        wcout.imbue(locale("chs"));        //设置输出的locale为中文1 h3 o, j! h8 ?& p

! S& c( l/ R( u* f! P8 g' w  N
        ErrCode=LuCom(ForStr,0,0,0,hFor,nPara,pPara,ErrBegin,ErrEnd); //编译表达式0 N, a0 _1 z\\" |5 K; Q\\" H& b# Z

if(ErrCode) 
\\" g7 {) p. ~+ G
        { 
7 E  x2 g$ E& U' S8 |: d. B6 a/ ^
                wcout<<L"表达式有错误！错误代码："<<ErrCode<<endl; 
* H# u0 c3 p; a& h! |0 D
        } 
* _8 d- F. t, q& W
        else8 m* P9 }+ C# C* ~, U2 D4 A

{ 
* K/ D$ E, \3 W% U8 P0 @, Y
                LuCal(hFor,pPara);        //计算表达式的值 
5 U8 O6 t, z. j9 I
        } 
1 O, t/ N+ D% s+ M
        LockKey(Matrix,NULL,OpMatrix);//解锁键Matrix，本例中，该函数可以不用/ ?' T8 S' y6 N) H

FreeLu();                        //释放Lu 
( o& g# ^9 d& R6 c/ }- D; A
}

习题：

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

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

main(:a,b,c,d,t,i)=7 N# I; O. u$ d5 H\" X0 G
a=new[matrix,2,2,data:1.,2.,2.,1.],9 f5 X* U, g; V% E$ J\" E
b=new[matrix,2,2,data:2.,1.,1.,2.],
* d1 Z$ e2 ? ^3 i- G
c=new[matrix,2,2,data:2/3.,-1/3.,-1/3.,2/3.],# m! s. a2 @5 G* l) v
t=clock(),& j& c! o3 \' y a* a. N$ Z
d=a*b, i=0, while{i<1000000, d=d*c*b, i++},: |* K! o$ g: ]
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\"}";//字符串表达式

复制代码

结果：