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

查看: 8673|回复: 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>
: t6 W7 ` U2 x: D
#include <iostream>) C: i4 m2 i! A
#include <math.h>
/ S+ p# N; w3 r+ I\\" F: B8 N' L g
#include "lu32.h"
7 z6 O9 u& Y6 P& \' _; {
\\" k3 s. [\\" L$ C; M3 ~7 Z1 K
#pragma comment( lib, "lu32.lib" )% K/ r W2 m' i# k L
8 l% a/ j( O( [3 ~$ R. Y! |; G
using namespace std;( ^3 V# e. {\\" o\\" L, G! e
7 `- n2 Z5 e& \
luKEY Matrix=-1000; //标识矩阵类型，最终的Matrix由LockKey决定
& J# o# s4 V4 {1 d6 N, f
+ w: y& g0 w9 i) r. t
void _stdcall LuMessage(wchar_t *pch)//输出动态库信息，该函数注册到Lu，由Lu二级函数调用 9 K* y: G/ V( P1 W' M
{6 Y u1 ~7 n: X5 O\\" Z\\" {$ K y
wcout<<pch;
, A- ^5 B+ @+ y h! @8 M9 B
}3 X' c\\" ?& _% S' r6 |. r
void _stdcall DelMatrix(void *me) //用于LockKey函数，因为是基于系统内置实数数组创建矩阵，故该函数什么也不做! h6 ]7 I6 E8 p s+ o- Z1 {4 e$ i) I
{* N* q& \, w/ Z- _
}
! J b6 t+ I' m% L
LuData _stdcall OpMatrix(luINT mm,LuData *xx,void *hFor,int theOperator) //运算符重载函数，用于LockKey函数
/ b7 B0 ` q9 F M' h
{
$ f9 X. B7 N; b2 I# f
LuData a;, n& k; F: a( P4 `$ h, n
luRealArray *pRealArray1,*pRealArray2,*pRealArray3;
$ G- X- ], a: z2 r( ^
luVOID i,j,k,m,n,u,v;
0 ^9 f/ K+ ]: m% |, u- x2 @& E# C
double *pa,*pb,*pc;
: I4 g s0 n$ M7 F, ^& L
luMessage pMessage;
; g: |, p+ {: o: W
wchar_t wchNum[32];, r# g- Y\\" }$ H) k0 N7 N
char chNum[32];, ?7 F: Q8 I: c
a.BType=luStaData_nil; a.VType=luStaData_nil; a.x=0;, A0 Z- d, }2 J
switch(theOperator)
8 m' {' O1 A& K
{, y+ M) U3 ~; e2 a; ?
case 2: //重载运算符*
3 s! f1 \( f\\" l* @4 C) ^
pRealArray1=(luRealArray *)SearchKey((char *)&(xx->x),sizeof(luVOID),luDynData_realarray);+ \7 k. x, o: r0 \$ w$ L9 Y\\" ], a
pRealArray2=(luRealArray *)SearchKey((char *)&((xx+1)->x),sizeof(luVOID),luDynData_realarray);
' M* W& O( a! n: j
if(!pRealArray1 || !pRealArray2) break; //对象句柄无效，不是实数数组! S# E6 v/ Q( p1 x
if(pRealArray1->DimLen!=2 || pRealArray2->DimLen!=2) break; //不是二维实数数组（矩阵）
n$ E- x\\" x m5 `
if(pRealArray1->Dim[1]!=pRealArray2->Dim[0]) break; //维数不匹配/ n9 C/ A9 D$ x3 z7 `
pRealArray3=(luRealArray *)NewSysObj(luDynData_realarray,pRealArray1->Dim[0]*pRealArray2->Dim[1],2); //创建矩阵对象/ I# C4 z\\" Y% E8 {/ C7 B
if(!pRealArray3) break;) I9 M Z/ a/ ]( d( X, Q% P
pRealArray3->Dim[0]=pRealArray1->Dim[0]; pRealArray3->Dim[1]=pRealArray2->Dim[1]; //设置矩阵维数大小
3 U3 j# v5 @# g$ A$ m
pa=pRealArray1->Array; pb=pRealArray2->Array; pc=pRealArray3->Array;
9 J0 J: y1 @5 Q, ]
m=pRealArray1->Dim[0]; n=pRealArray1->Dim[1]; k=pRealArray2->Dim[1];% ?6 z% t( x$ u3 N1 z
for(i=0; i<m; i++) //矩阵乘
( s8 J4 _+ r! I0 R/ U/ H
{2 N) {& V; d! P& p
for(j=0; j<k; j++)\\" S* l1 z0 M5 r2 c; t
{: P, u8 V; m2 Y9 ^6 e3 a& m( K) Q( r
u=i*k+j; pc[u]=0.0;
/ U$ r; S: W8 F6 O4 x1 I/ m\\" @
for (v=0; v<n; v++)
/ j: E7 |: ^2 T
{
b, W* ~$ O! ^& W- b
pc[u]=pc[u]+pa[i*n+v]*pb[v*k+j];
1 _9 F4 r7 @6 ]! j) \5 {
}
\\" Q* W+ y7 t7 d7 e3 r
}' d/ @/ J: e7 C! }2 C4 o\\" [
}# e8 [8 Y( C, N6 d# N\\" `/ l
FunReObj(hFor); //告诉Lu，返回一个动态对象9 h- f, I- P) r; U
a.BType=luDynData_realarray; a.VType=Matrix; a.x=0; *(luVOID *)&(a.x)=(luVOID)pRealArray3;7 k5 w4 a; @( A* i- K- E# q9 k
break;9 g% D1 r$ p Y9 O* u4 b
case 25: //重载运算符.*' Q2 Y; j$ L3 z& @, P. M- J
pRealArray1=(luRealArray *)SearchKey((char *)&(xx->x),sizeof(luVOID),luDynData_realarray); k0 j% [3 u9 k$ e9 U
pRealArray2=(luRealArray *)SearchKey((char *)&((xx+1)->x),sizeof(luVOID),luDynData_realarray);- q% L6 {/ D\\" t( W1 n4 ^
if(!pRealArray1 || !pRealArray2) break; //对象句柄无效，不是实数数组' m; n. [, f8 f4 H
if(pRealArray1->DimLen!=2 || pRealArray2->DimLen!=2) break; //不是二维实数数组（矩阵）
* U/ O& p; @' l7 ^0 {+ |1 \0 G
if(pRealArray1->Dim[0]!=pRealArray2->Dim[0] || pRealArray1->Dim[1]!=pRealArray2->Dim[1]) break; //维数不相同& R$ \# @2 g$ d( H
pRealArray3=(luRealArray *)NewSysObj(luDynData_realarray,pRealArray1->ArrayLen,2); //创建矩阵对象
8 L) P( `; {( N6 { G' A8 c% y5 ~
if(!pRealArray3) break;
\\" j4 F; M) w% N% x
pRealArray3->Dim[0]=pRealArray1->Dim[0]; pRealArray3->Dim[1]=pRealArray1->Dim[1]; //设置矩阵维数大小; a& H: b\\" o* N6 u/ \
for(i=0;i<pRealArray1->ArrayLen;i++) pRealArray3->Array[i]=pRealArray1->Array[i]*pRealArray2->Array[i];//矩阵点乘
# x/ C# o\\" v8 R
FunReObj(hFor); //告诉Lu，返回一个动态对象
K. @3 L\\" r N' @9 J; q& N7 ^
a.BType=luDynData_realarray; a.VType=Matrix; a.x=0; *(luVOID *)&(a.x)=(luVOID)pRealArray3;
+ T* p# d# @1 W3 b& L5 q
break;1 n& _* O! V\\" V# s
case 46: //重载函数new) b0 `$ q* r* P8 `' [
a=ExeOperator(mm,xx,hFor,theOperator,luDynData_realarray); //直接调用基本类型luDynData_realarray的new函数\\" S7 l$ j1 I0 h4 }. s- J
if(a.VType==luDynData_realarray) a.VType=Matrix; //设置扩展类型为自定义的Matrix类型# |6 R8 a% i8 ~3 s$ q
break;! C; M$ u. e9 S, @8 {; W& S0 @
case 49: //重载函数o
! O( V$ o( R5 {2 m$ u+ ^4 p
pMessage=(luMessage)SearchKey("\0\0\0\0",sizeof(luVOID),luPubKey_User);\\" {1 h# Y+ M7 `8 h1 m) t
if(!pMessage) break;
9 t. }, G' H! F$ @
pRealArray1=(luRealArray *)SearchKey((char *)&(xx->x),sizeof(luVOID),luDynData_realarray);
\\" e+ }5 }\\" D' |$ I, W
if(!pRealArray1) break; //对象句柄无效，不是实数数组
/ s2 c1 o' Y1 ` `
if(pRealArray1->DimLen!=2) break; //不是二维实数数组（矩阵）4 b4 |% N- B7 j
pa=pRealArray1->Array;4 @; q0 e' f4 G2 F2 e; I
m=pRealArray1->Dim[0]; n=pRealArray1->Dim[1]; k=0;
- W/ N$ }) u- P3 ~' K6 m
for(i=0; i<m; i++) //输出矩阵
\\" f- Z. f6 `4 l\\" Y5 x, R1 W
{, O8 ]+ v$ S! Y: o
pMessage(L"\r\n"); k+=2;% c) E& e7 b8 N e+ v5 Y
for(j=0; j<n; j++)$ U\\" S- w4 X6 L3 L4 x w E- h- _
{
3 q) U: c3 \3 N5 E
_gcvt_s(chNum,pa[i*n+j],16);
2 ]9 A- {& I& C6 N- G6 X; M\\" H
for(u=0;chNum[u];u++) {wchNum[u]=chNum[u]; k++;}5 Z1 n* I; i8 N7 ?
wchNum[u]='\0';
/ l+ ?- S$ w! F5 Z
pMessage(wchNum); pMessage(L" "); k+=2;
. w; G# F; c0 w6 A, M\\" p
}( v1 l% e) `6 [6 f7 E
}
( v) Z' J9 n' @8 V5 }
pMessage(L"\r\n"); k+=2;: v- E. N\\" c( _- u& N' e# O8 Z
a.BType=luStaData_int64; a.VType=luStaData_int64; a.x=k; //按函数o的要求，返回输出的字符总数$ i _/ E7 y- q# M
break;5 K6 k- ^7 ^; g3 b5 M4 v( ~& A
default:
* v% s: Q( p' }; z, \8 L0 m; m
break;
$ r7 ^2 C+ n7 h) j! @
}\\" E w* \% u; e6 D+ q' R
return a;- k% @7 j6 \, @\\" F* [% H4 _3 @4 M
}
2 S- ^9 @/ r- h1 N$ z
void main(void)
& W( _: T2 O6 _5 c
{4 o7 D( A+ c3 Y' I+ I. j' E
void *hFor; //表达式句柄+ \7 [5 a4 v5 C9 a7 k; V
luINT nPara; //存放表达式的自变量个数- A/ S. Z. F8 }) F
LuData *pPara; //存放输入自变量的数组指针, P3 v9 A: D% a
luINT ErrBegin,ErrEnd; //表达式编译出错的初始位置和结束位置
* o9 C# x8 r! n+ k
int ErrCode; //错误代码
& b* l. a0 }% ~! ]
void *v;
) l+ Q8 v6 Y, m1 h/ _( h5 X% m
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 g0 S2 L8 z2 H8 [
//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.]}";//字符串表达式，矩阵点乘
2 T3 R/ c1 b4 y' @; a
LuData Val;
) q' E6 y7 A! V) m2 s
if(!InitLu()) return; //初始化Lu
; s( o& {% ]& o0 |. X4 u
while(LockKey(Matrix,DelMatrix,OpMatrix)){Matrix++;} //锁定一个键，用于存储矩阵扩展类型
+ n9 T8 ]2 A7 R
3 Z! V( K( A% N4 ~7 J
Val.BType=luStaData_int64; Val.VType=luStaData_int64; Val.x=Matrix; //定义整数常量
: h. P Q. i2 A* X
SetConst(L"matrix",&Val); //设置整数常量, [! k( b( c; A! X9 L5 U
InsertKey("\0\0\0\0",4,luPubKey_User,LuMessage,NULL,NULL,1,v); //使Lu运行时可输出函数信息
, {' o6 ]( v- Z/ C8 `
wcout.imbue(locale("chs")); //设置输出的locale为中文
; }, u\\" d4 ]4 X) c/ {! h
$ W\\" G: P\\" u# s! B3 i+ a) B* N
ErrCode=LuCom(ForStr,0,0,0,hFor,nPara,pPara,ErrBegin,ErrEnd); //编译表达式& I. T: O: ?2 p/ U0 ?
if(ErrCode)7 l f8 v9 n7 I) c$ w
{
5 a) @! X% V4 [
wcout<<L"表达式有错误！错误代码："<<ErrCode<<endl;\\" L* r; v* R, W- t
}
, l0 Q4 k+ Q\\" R$ u# q4 I
else
\\" S. o' D, L. l0 Y\\" I
{' ?9 ~ |, |; F* M, _( V' a
LuCal(hFor,pPara); //计算表达式的值! \, b& `7 h! R3 }) ?
}
/ ~# `- H. {\\" ] y
LockKey(Matrix,NULL,OpMatrix);//解锁键Matrix，本例中，该函数可以不用8 _6 v- z1 Q# s
FreeLu(); //释放Lu6 V) p+ Y7 a- o
}

#include <windows.h> 
: t6 W7 `  U2 x: D
#include <iostream>) C: i4 m2 i! A

#include <math.h> 
/ S+ p# N; w3 r+ I\\" F: B8 N' L  g
#include "lu32.h" 
7 z6 O9 u& Y6 P& \' _; {
 
\\" k3 s. [\\" L$ C; M3 ~7 Z1 K
#pragma comment( lib, "lu32.lib" )% K/ r  W2 m' i# k  L

8 l% a/ j( O( [3 ~$ R. Y! |; G

using namespace std;( ^3 V# e. {\\" o\\" L, G! e

7 `- n2 Z5 e& \
luKEY Matrix=-1000;        //标识矩阵类型，最终的Matrix由LockKey决定 
& J# o# s4 V4 {1 d6 N, f
+ w: y& g0 w9 i) r. t

void _stdcall LuMessage(wchar_t *pch)//输出动态库信息，该函数注册到Lu，由Lu二级函数调用 9 K* y: G/ V( P1 W' M

{6 Y  u1 ~7 n: X5 O\\" Z\\" {$ K  y

wcout<<pch; 
, A- ^5 B+ @+ y  h! @8 M9 B
}3 X' c\\" ?& _% S' r6 |. r

void _stdcall DelMatrix(void *me)        //用于LockKey函数，因为是基于系统内置实数数组创建矩阵，故该函数什么也不做! h6 ]7 I6 E8 p  s+ o- Z1 {4 e$ i) I

{* N* q& \, w/ Z- _

} 
! J  b6 t+ I' m% L
LuData _stdcall OpMatrix(luINT mm,LuData *xx,void *hFor,int theOperator)        //运算符重载函数，用于LockKey函数 
/ b7 B0 `  q9 F  M' h
{ 
$ f9 X. B7 N; b2 I# f
        LuData a;, n& k; F: a( P4 `$ h, n

luRealArray *pRealArray1,*pRealArray2,*pRealArray3; 
$ G- X- ], a: z2 r( ^
        luVOID i,j,k,m,n,u,v; 
0 ^9 f/ K+ ]: m% |, u- x2 @& E# C
        double *pa,*pb,*pc; 
: I4 g  s0 n$ M7 F, ^& L
        luMessage pMessage; 
; g: |, p+ {: o: W
        wchar_t wchNum[32];, r# g- Y\\" }$ H) k0 N7 N

char chNum[32];, ?7 F: Q8 I: c

a.BType=luStaData_nil; a.VType=luStaData_nil; a.x=0;, A0 Z- d, }2 J

switch(theOperator) 
8 m' {' O1 A& K
        {, y+ M) U3 ~; e2 a; ?

case 2:        //重载运算符* 
3 s! f1 \( f\\" l* @4 C) ^
                pRealArray1=(luRealArray *)SearchKey((char *)&(xx->x),sizeof(luVOID),luDynData_realarray);+ \7 k. x, o: r0 \$ w$ L9 Y\\" ], a

pRealArray2=(luRealArray *)SearchKey((char *)&((xx+1)->x),sizeof(luVOID),luDynData_realarray); 
' M* W& O( a! n: j
                if(!pRealArray1 || !pRealArray2) break;        //对象句柄无效，不是实数数组! S# E6 v/ Q( p1 x

if(pRealArray1->DimLen!=2 || pRealArray2->DimLen!=2) break;        //不是二维实数数组（矩阵） 
  n$ E- x\\" x  m5 `
                if(pRealArray1->Dim[1]!=pRealArray2->Dim[0]) break;        //维数不匹配/ n9 C/ A9 D$ x3 z7 `

pRealArray3=(luRealArray *)NewSysObj(luDynData_realarray,pRealArray1->Dim[0]*pRealArray2->Dim[1],2);        //创建矩阵对象/ I# C4 z\\" Y% E8 {/ C7 B

if(!pRealArray3) break;) I9 M  Z/ a/ ]( d( X, Q% P

pRealArray3->Dim[0]=pRealArray1->Dim[0]; pRealArray3->Dim[1]=pRealArray2->Dim[1];        //设置矩阵维数大小 
3 U3 j# v5 @# g$ A$ m
                pa=pRealArray1->Array; pb=pRealArray2->Array; pc=pRealArray3->Array; 
9 J0 J: y1 @5 Q, ]
                m=pRealArray1->Dim[0]; n=pRealArray1->Dim[1]; k=pRealArray2->Dim[1];% ?6 z% t( x$ u3 N1 z

for(i=0; i<m; i++)        //矩阵乘 
( s8 J4 _+ r! I0 R/ U/ H
                {2 N) {& V; d! P& p

for(j=0; j<k; j++)\\" S* l1 z0 M5 r2 c; t

{: P, u8 V; m2 Y9 ^6 e3 a& m( K) Q( r

u=i*k+j; pc[u]=0.0; 
/ U$ r; S: W8 F6 O4 x1 I/ m\\" @
                                for (v=0; v<n; v++) 
/ j: E7 |: ^2 T
                                { 
  b, W* ~$ O! ^& W- b
                                        pc[u]=pc[u]+pa[i*n+v]*pb[v*k+j]; 
1 _9 F4 r7 @6 ]! j) \5 {
                                } 
\\" Q* W+ y7 t7 d7 e3 r
                        }' d/ @/ J: e7 C! }2 C4 o\\" [

}# e8 [8 Y( C, N6 d# N\\" `/ l

FunReObj(hFor);        //告诉Lu，返回一个动态对象9 h- f, I- P) r; U

a.BType=luDynData_realarray; a.VType=Matrix; a.x=0; *(luVOID *)&(a.x)=(luVOID)pRealArray3;7 k5 w4 a; @( A* i- K- E# q9 k

break;9 g% D1 r$ p  Y9 O* u4 b

case 25:        //重载运算符.*' Q2 Y; j$ L3 z& @, P. M- J

pRealArray1=(luRealArray *)SearchKey((char *)&(xx->x),sizeof(luVOID),luDynData_realarray);  k0 j% [3 u9 k$ e9 U

pRealArray2=(luRealArray *)SearchKey((char *)&((xx+1)->x),sizeof(luVOID),luDynData_realarray);- q% L6 {/ D\\" t( W1 n4 ^

if(!pRealArray1 || !pRealArray2) break;        //对象句柄无效，不是实数数组' m; n. [, f8 f4 H

if(pRealArray1->DimLen!=2 || pRealArray2->DimLen!=2) break;        //不是二维实数数组（矩阵） 
* U/ O& p; @' l7 ^0 {+ |1 \0 G
                if(pRealArray1->Dim[0]!=pRealArray2->Dim[0] || pRealArray1->Dim[1]!=pRealArray2->Dim[1]) break;        //维数不相同& R$ \# @2 g$ d( H

pRealArray3=(luRealArray *)NewSysObj(luDynData_realarray,pRealArray1->ArrayLen,2);        //创建矩阵对象 
8 L) P( `; {( N6 {  G' A8 c% y5 ~
                if(!pRealArray3) break; 
\\" j4 F; M) w% N% x
                pRealArray3->Dim[0]=pRealArray1->Dim[0]; pRealArray3->Dim[1]=pRealArray1->Dim[1];        //设置矩阵维数大小; a& H: b\\" o* N6 u/ \

for(i=0;i<pRealArray1->ArrayLen;i++) pRealArray3->Array[i]=pRealArray1->Array[i]*pRealArray2->Array[i];//矩阵点乘 
# x/ C# o\\" v8 R
                FunReObj(hFor);        //告诉Lu，返回一个动态对象 
  K. @3 L\\" r  N' @9 J; q& N7 ^
                a.BType=luDynData_realarray; a.VType=Matrix; a.x=0; *(luVOID *)&(a.x)=(luVOID)pRealArray3; 
+ T* p# d# @1 W3 b& L5 q
                break;1 n& _* O! V\\" V# s

case 46:        //重载函数new) b0 `$ q* r* P8 `' [

a=ExeOperator(mm,xx,hFor,theOperator,luDynData_realarray);        //直接调用基本类型luDynData_realarray的new函数\\" S7 l$ j1 I0 h4 }. s- J

if(a.VType==luDynData_realarray) a.VType=Matrix;        //设置扩展类型为自定义的Matrix类型# |6 R8 a% i8 ~3 s$ q

break;! C; M$ u. e9 S, @8 {; W& S0 @

case 49:        //重载函数o 
! O( V$ o( R5 {2 m$ u+ ^4 p
                pMessage=(luMessage)SearchKey("\0\0\0\0",sizeof(luVOID),luPubKey_User);\\" {1 h# Y+ M7 `8 h1 m) t

if(!pMessage) break; 
9 t. }, G' H! F$ @
                pRealArray1=(luRealArray *)SearchKey((char *)&(xx->x),sizeof(luVOID),luDynData_realarray); 
\\" e+ }5 }\\" D' |$ I, W
                if(!pRealArray1) break;        //对象句柄无效，不是实数数组 
/ s2 c1 o' Y1 `  `
                if(pRealArray1->DimLen!=2) break;        //不是二维实数数组（矩阵）4 b4 |% N- B7 j

pa=pRealArray1->Array;4 @; q0 e' f4 G2 F2 e; I

m=pRealArray1->Dim[0]; n=pRealArray1->Dim[1]; k=0; 
- W/ N$ }) u- P3 ~' K6 m
                for(i=0; i<m; i++)        //输出矩阵 
\\" f- Z. f6 `4 l\\" Y5 x, R1 W
                {, O8 ]+ v$ S! Y: o

pMessage(L"\r\n"); k+=2;% c) E& e7 b8 N  e+ v5 Y

for(j=0; j<n; j++)$ U\\" S- w4 X6 L3 L4 x  w  E- h- _

{ 
3 q) U: c3 \3 N5 E
                                _gcvt_s(chNum,pa[i*n+j],16); 
2 ]9 A- {& I& C6 N- G6 X; M\\" H
                                for(u=0;chNum[u];u++) {wchNum[u]=chNum[u]; k++;}5 Z1 n* I; i8 N7 ?

wchNum[u]='\0'; 
/ l+ ?- S$ w! F5 Z
                                pMessage(wchNum); pMessage(L"  "); k+=2; 
. w; G# F; c0 w6 A, M\\" p
                        }( v1 l% e) `6 [6 f7 E

} 
( v) Z' J9 n' @8 V5 }
                pMessage(L"\r\n"); k+=2;: v- E. N\\" c( _- u& N' e# O8 Z

a.BType=luStaData_int64; a.VType=luStaData_int64; a.x=k;        //按函数o的要求，返回输出的字符总数$ i  _/ E7 y- q# M

break;5 K6 k- ^7 ^; g3 b5 M4 v( ~& A

default: 
* v% s: Q( p' }; z, \8 L0 m; m
                break; 
$ r7 ^2 C+ n7 h) j! @
        }\\" E  w* \% u; e6 D+ q' R

return a;- k% @7 j6 \, @\\" F* [% H4 _3 @4 M

} 
2 S- ^9 @/ r- h1 N$ z
void main(void) 
& W( _: T2 O6 _5 c
{4 o7 D( A+ c3 Y' I+ I. j' E

void *hFor;                //表达式句柄+ \7 [5 a4 v5 C9 a7 k; V

luINT nPara;                //存放表达式的自变量个数- A/ S. Z. F8 }) F

LuData *pPara;                //存放输入自变量的数组指针, P3 v9 A: D% a

luINT ErrBegin,ErrEnd;        //表达式编译出错的初始位置和结束位置 
* o9 C# x8 r! n+ k
        int ErrCode;                //错误代码 
& b* l. a0 }% ~! ]
        void *v; 
) l+ Q8 v6 Y, m1 h/ _( h5 X% m
        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 g0 S2 L8 z2 H8 [
        //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.]}";//字符串表达式，矩阵点乘 
2 T3 R/ c1 b4 y' @; a
        LuData Val; 
) q' E6 y7 A! V) m2 s
        if(!InitLu()) return;        //初始化Lu 
; s( o& {% ]& o0 |. X4 u
        while(LockKey(Matrix,DelMatrix,OpMatrix)){Matrix++;}        //锁定一个键，用于存储矩阵扩展类型 
+ n9 T8 ]2 A7 R
 
3 Z! V( K( A% N4 ~7 J
        Val.BType=luStaData_int64; Val.VType=luStaData_int64; Val.x=Matrix;        //定义整数常量 
: h. P  Q. i2 A* X
        SetConst(L"matrix",&Val);        //设置整数常量, [! k( b( c; A! X9 L5 U

InsertKey("\0\0\0\0",4,luPubKey_User,LuMessage,NULL,NULL,1,v); //使Lu运行时可输出函数信息 
, {' o6 ]( v- Z/ C8 `
        wcout.imbue(locale("chs"));        //设置输出的locale为中文 
; }, u\\" d4 ]4 X) c/ {! h
   
$ W\\" G: P\\" u# s! B3 i+ a) B* N
        ErrCode=LuCom(ForStr,0,0,0,hFor,nPara,pPara,ErrBegin,ErrEnd); //编译表达式& I. T: O: ?2 p/ U0 ?

if(ErrCode)7 l  f8 v9 n7 I) c$ w

{ 
5 a) @! X% V4 [
                wcout<<L"表达式有错误！错误代码："<<ErrCode<<endl;\\" L* r; v* R, W- t

} 
, l0 Q4 k+ Q\\" R$ u# q4 I
        else 
\\" S. o' D, L. l0 Y\\" I
        {' ?9 ~  |, |; F* M, _( V' a

LuCal(hFor,pPara);        //计算表达式的值! \, b& `7 h! R3 }) ?

} 
/ ~# `- H. {\\" ]  y
        LockKey(Matrix,NULL,OpMatrix);//解锁键Matrix，本例中，该函数可以不用8 _6 v- z1 Q# s

FreeLu();                        //释放Lu6 V) p+ Y7 a- o

}

习题：

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

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

main(:a,b,c,d,t,i)=
\" t9 @6 o/ B/ {' O; p' ^5 d _3 D
a=new[matrix,2,2,data:1.,2.,2.,1.],
7 h! R; k% H# t+ [+ m. ?3 j
b=new[matrix,2,2,data:2.,1.,1.,2.],: T# y+ V9 o. l/ L Z
c=new[matrix,2,2,data:2/3.,-1/3.,-1/3.,2/3.],+ N: \- l. e0 I/ ~5 t4 f\" Y
t=clock(),) |9 ]6 P! I. f2 v7 G1 _
d=a*b, i=0, while{i<1000000, d=d*c*b, i++},# s) `0 F( u0 d8 H- T# k
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\"}";//字符串表达式

复制代码

结果：