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

查看: 7572|回复: 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>
! s( W; ^. o0 `/ s
#include <iostream>
# U$ A. ~9 S, P' R\\" t& q, O1 L
#include <math.h>
% s8 @) \0 Y/ b
#include "lu32.h"
, b3 h3 c7 F/ S* y- D
3 ^& h0 k& [! A\\" P& w* M% C
#pragma comment( lib, "lu32.lib" )! \5 A; D( v$ @
\\" Z7 z% V' s2 V0 u# I n+ b8 S
using namespace std;
$ v0 k4 M. ~( |# t
) c1 {\\" R U# Z
luKEY Matrix=-1000; //标识矩阵类型，最终的Matrix由LockKey决定3 f& B# W9 a, m I. v' z
( W& K4 t; \( L+ ^8 }0 Z. J7 s
void _stdcall LuMessage(wchar_t *pch)//输出动态库信息，该函数注册到Lu，由Lu二级函数调用
% ~. w# m M, j# J
{
+ `- U% F8 C1 d1 B& I
wcout<<pch;! } P& e3 r& i
}
s. Q; o' x s. W
void _stdcall DelMatrix(void *me) //用于LockKey函数，因为是基于系统内置实数数组创建矩阵，故该函数什么也不做' ~% C% k0 y( w7 P p
{- U ^ ^1 z0 n! A, q
}! l$ N4 |- w j+ t$ s# H
LuData _stdcall OpMatrix(luINT mm,LuData *xx,void *hFor,int theOperator) //运算符重载函数，用于LockKey函数# C- O( x& f2 X) Z, T# F/ c# R$ s
{
: W% `' p* b4 e- n* n\\" O5 J/ [
LuData a;- E4 x) g6 m+ l- ?1 y
luRealArray *pRealArray1,*pRealArray2,*pRealArray3;
T! \9 F3 K! t
luVOID i,j,k,m,n,u,v;) U; Y7 ]' q0 T4 u1 x8 E
double *pa,*pb,*pc;# |6 V% D0 k) T. o
luMessage pMessage;
/ _$ _5 E) P6 f# A
wchar_t wchNum[32];, F3 F3 G' j+ v% b- U& f% c
char chNum[32];
& ^1 K/ B1 {9 V+ [- ^: Z
a.BType=luStaData_nil; a.VType=luStaData_nil; a.x=0;+ I! T% C' u& v( J1 O& m
switch(theOperator)6 D. E* y( h, I1 y
{% ~0 B9 x* v' ]& \$ A: x% n7 [
case 2: //重载运算符*
& k# u: g; m/ k# b$ H7 W. G9 X3 @
pRealArray1=(luRealArray *)SearchKey((char *)&(xx->x),sizeof(luVOID),luDynData_realarray);5 W( K, a, {2 T8 g
pRealArray2=(luRealArray *)SearchKey((char *)&((xx+1)->x),sizeof(luVOID),luDynData_realarray);
4 p+ ?: P) B& r2 ~* e2 b8 t
if(!pRealArray1 || !pRealArray2) break; //对象句柄无效，不是实数数组
! u+ e$ ~) p' L5 E- Q
if(pRealArray1->DimLen!=2 || pRealArray2->DimLen!=2) break; //不是二维实数数组（矩阵）
& O4 s* G8 \$ z2 U/ j
if(pRealArray1->Dim[1]!=pRealArray2->Dim[0]) break; //维数不匹配) R) P& K2 }/ L# [2 D$ _
pRealArray3=(luRealArray *)NewSysObj(luDynData_realarray,pRealArray1->Dim[0]*pRealArray2->Dim[1],2); //创建矩阵对象
3 A; \& x9 Y1 d% v5 k. }
if(!pRealArray3) break;
* k# o; z4 H! w- ?
pRealArray3->Dim[0]=pRealArray1->Dim[0]; pRealArray3->Dim[1]=pRealArray2->Dim[1]; //设置矩阵维数大小6 L! a2 I6 U* m, U& u
pa=pRealArray1->Array; pb=pRealArray2->Array; pc=pRealArray3->Array;8 B7 V* l+ W$ ^# j, k
m=pRealArray1->Dim[0]; n=pRealArray1->Dim[1]; k=pRealArray2->Dim[1];) i( ~2 _- P6 m/ g
for(i=0; i<m; i++) //矩阵乘\\" y3 v% Z c$ J\\" H# i
{
. l# X4 k& J d. s; l3 y' m& y$ e
for(j=0; j<k; j++)6 H4 e' ~\\" K5 I' D2 L! u3 ]% O
{
\\" N8 J. F2 Y8 Z; H! ]
u=i*k+j; pc[u]=0.0;
, O. b; ]\\" U$ D3 A1 z5 {6 U
for (v=0; v<n; v++)
' b; i/ q' q/ W7 V% E- z
{! e* k4 V; h( ?2 \0 X! A4 k
pc[u]=pc[u]+pa[i*n+v]*pb[v*k+j];
7 ?( y' T4 m& U\\" H8 j( n5 [1 J. R
}1 | r, \! t5 `9 [\\" J0 n& U
}
9 \# W: ?- L1 l' \
}, U9 {& T+ V; R) t+ `! o\\" i) h
FunReObj(hFor); //告诉Lu，返回一个动态对象\\" Z8 X H/ b0 u
a.BType=luDynData_realarray; a.VType=Matrix; a.x=0; *(luVOID *)&(a.x)=(luVOID)pRealArray3;
8 L* I$ @5 o& g& J( |
break;
case 25: //重载运算符.*7 D7 |7 L) s8 ]) k/ W) |/ T) ]
pRealArray1=(luRealArray *)SearchKey((char *)&(xx->x),sizeof(luVOID),luDynData_realarray);6 e4 B# n6 [# w B
pRealArray2=(luRealArray *)SearchKey((char *)&((xx+1)->x),sizeof(luVOID),luDynData_realarray);\\" h# {8 x* [% K8 d* Z
if(!pRealArray1 || !pRealArray2) break; //对象句柄无效，不是实数数组
; a& v W/ m3 v/ L
if(pRealArray1->DimLen!=2 || pRealArray2->DimLen!=2) break; //不是二维实数数组（矩阵）3 T: U- Q: c( ?\\" y3 W% W
if(pRealArray1->Dim[0]!=pRealArray2->Dim[0] || pRealArray1->Dim[1]!=pRealArray2->Dim[1]) break; //维数不相同* p% l; D# n2 ^
pRealArray3=(luRealArray *)NewSysObj(luDynData_realarray,pRealArray1->ArrayLen,2); //创建矩阵对象
1 K E# b. D0 L: T8 D$ q2 E
if(!pRealArray3) break;
pRealArray3->Dim[0]=pRealArray1->Dim[0]; pRealArray3->Dim[1]=pRealArray1->Dim[1]; //设置矩阵维数大小; K! A5 ]* V- {# c1 g8 k
for(i=0;i<pRealArray1->ArrayLen;i++) pRealArray3->Array[i]=pRealArray1->Array[i]*pRealArray2->Array[i];//矩阵点乘\\" J) q; I9 W$ ^& q! z
FunReObj(hFor); //告诉Lu，返回一个动态对象6 y$ K) `& a! v' V
a.BType=luDynData_realarray; a.VType=Matrix; a.x=0; *(luVOID *)&(a.x)=(luVOID)pRealArray3;
+ y; H( S2 C% _7 Z- F+ M5 o
break;
; L) G' g8 a8 ?! W
case 46: //重载函数new
( J3 ] Q5 T2 V. ^2 t a
a=ExeOperator(mm,xx,hFor,theOperator,luDynData_realarray); //直接调用基本类型luDynData_realarray的new函数
2 Y5 P9 f6 I$ n) U
if(a.VType==luDynData_realarray) a.VType=Matrix; //设置扩展类型为自定义的Matrix类型
, C8 `( Y' ^7 S# E
break;; e8 H\\" I% d( u, r3 ~9 Z; ?) q+ ^' ?( {( \! D
case 49: //重载函数o
1 F( O. f9 d\\" D, }2 p9 H\\" W% M8 Z
pMessage=(luMessage)SearchKey("\0\0\0\0",sizeof(luVOID),luPubKey_User);
; J0 l9 |9 @9 Y
if(!pMessage) break;
M* G- g: V C8 k4 b( q3 g0 S5 H
pRealArray1=(luRealArray *)SearchKey((char *)&(xx->x),sizeof(luVOID),luDynData_realarray);
) @9 N- D! E( x
if(!pRealArray1) break; //对象句柄无效，不是实数数组
f9 e1 v: V3 J& J* N& O
if(pRealArray1->DimLen!=2) break; //不是二维实数数组（矩阵）
2 h* n' S\\" k, V! A+ b* ^2 a& v
pa=pRealArray1->Array;1 x( _( ~' B- V* J
m=pRealArray1->Dim[0]; n=pRealArray1->Dim[1]; k=0;
2 U* y+ l% @9 `6 Q# w& O( W Z2 q, [
for(i=0; i<m; i++) //输出矩阵1 W5 e9 Z& k3 l8 b
{
8 m6 U% l8 I: t, Q; B8 ~: p5 \
pMessage(L"\r\n"); k+=2;
6 b, g# ^2 ?- a+ T\\" ]
for(j=0; j<n; j++)
a3 O% Y( ^7 x& [4 T\\" X+ c\\" R
{
4 {6 \9 f9 \3 |. t( P& c
_gcvt_s(chNum,pa[i*n+j],16);5 E& Y/ B+ q* @5 j
for(u=0;chNum[u];u++) {wchNum[u]=chNum[u]; k++;}
, N: t6 N9 N/ n\\" Z( J( \
wchNum[u]='\0';
, i; K% I. j7 w6 G
pMessage(wchNum); pMessage(L" "); k+=2;+ n6 @3 {3 D9 L
}
s1 j9 g! T. Y/ g; k0 G- G
}
* u/ @0 H8 U2 N( I' q1 V, A
pMessage(L"\r\n"); k+=2;
1 Z8 Q' f/ e. n# E& ]
a.BType=luStaData_int64; a.VType=luStaData_int64; a.x=k; //按函数o的要求，返回输出的字符总数( z# h; E) l9 F* j
break;7 E! ^\\" p2 K6 G) [ W0 E
default:. ]3 {' q& W: [
break;
' Q+ m | n y; R# U# B
}
+ q- @% e; V* V& |
return a;
% b; J5 M. Z6 e) Q2 D) \. e
}
- N: K: L& I5 r4 u6 {; N\\" ?
void main(void)- ]3 \\\" _+ z$ v\\" y& \' H7 C
{
! s8 L/ ? m3 D9 f
void *hFor; //表达式句柄3 L: l* w/ @3 C, r3 o0 W
luINT nPara; //存放表达式的自变量个数
: i ~2 a w/ a( H8 a
LuData *pPara; //存放输入自变量的数组指针\\" n9 q* U1 x0 G7 z3 X8 l( R
luINT ErrBegin,ErrEnd; //表达式编译出错的初始位置和结束位置
# f2 z6 ~+ p, ^3 [! z2 {7 k
int ErrCode; //错误代码
: ]9 J2 T& e- P: q F9 G* `
void *v;) F3 _* U5 ~# |0 g' ?& k7 ^& n
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.]}";//字符串表达式，矩阵乘
/ D$ A1 | N4 I8 ^ q, @
//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.]}";//字符串表达式，矩阵点乘
$ @, M. y' U. q5 m% A
LuData Val;) C% v& j5 C, h w2 t' M: x4 g
if(!InitLu()) return; //初始化Lu
, X0 O! ?0 v' u2 n. O; ?
while(LockKey(Matrix,DelMatrix,OpMatrix)){Matrix++;} //锁定一个键，用于存储矩阵扩展类型
9 o3 J: s! G: c+ I, ~9 `9 L( ]\\" v/ \
+ f' L7 c# J+ \- z
Val.BType=luStaData_int64; Val.VType=luStaData_int64; Val.x=Matrix; //定义整数常量
4 i. C2 a% Y5 y2 E( g. t0 g
SetConst(L"matrix",&Val); //设置整数常量7 ]$ E% d4 D& Q
InsertKey("\0\0\0\0",4,luPubKey_User,LuMessage,NULL,NULL,1,v); //使Lu运行时可输出函数信息* m ?) j9 O& P( h& o
wcout.imbue(locale("chs")); //设置输出的locale为中文
- k( e8 B0 O! q1 ]0 l
) ^/ |$ r9 N$ M3 N+ h
ErrCode=LuCom(ForStr,0,0,0,hFor,nPara,pPara,ErrBegin,ErrEnd); //编译表达式
# [& a' c5 f6 `3 w+ Y. k5 K
if(ErrCode)
, g. b( j, L9 o
{
+ u1 O5 {( @. m7 q+ K4 z
wcout<<L"表达式有错误！错误代码："<<ErrCode<<endl;' y* O7 F; P! a4 _
}
4 g9 G' @: w8 X; Z3 y; _) o/ f
else; b' j( j* L$ P6 D\\" C+ ^
{
3 C9 s- c/ M3 c% Y2 e/ r7 t
LuCal(hFor,pPara); //计算表达式的值
9 }8 }# q& c/ `
}# U% N/ H# p. T/ V) W
LockKey(Matrix,NULL,OpMatrix);//解锁键Matrix，本例中，该函数可以不用
! ~& m7 V- N# f\\" N
FreeLu(); //释放Lu+ S, q: O1 h9 Q9 q, f- n
}

#include <windows.h> 
! s( W; ^. o0 `/ s
#include <iostream> 
# U$ A. ~9 S, P' R\\" t& q, O1 L
#include <math.h> 
% s8 @) \0 Y/ b
#include "lu32.h" 
, b3 h3 c7 F/ S* y- D
 
3 ^& h0 k& [! A\\" P& w* M% C
#pragma comment( lib, "lu32.lib" )! \5 A; D( v$ @

\\" Z7 z% V' s2 V0 u# I  n+ b8 S
using namespace std; 
$ v0 k4 M. ~( |# t
) c1 {\\" R  U# Z

luKEY Matrix=-1000;        //标识矩阵类型，最终的Matrix由LockKey决定3 f& B# W9 a, m  I. v' z

( W& K4 t; \( L+ ^8 }0 Z. J7 s
void _stdcall LuMessage(wchar_t *pch)//输出动态库信息，该函数注册到Lu，由Lu二级函数调用 
% ~. w# m  M, j# J
{ 
+ `- U% F8 C1 d1 B& I
        wcout<<pch;! }  P& e3 r& i

} 
  s. Q; o' x  s. W
void _stdcall DelMatrix(void *me)        //用于LockKey函数，因为是基于系统内置实数数组创建矩阵，故该函数什么也不做' ~% C% k0 y( w7 P  p

{- U  ^  ^1 z0 n! A, q

}! l$ N4 |- w  j+ t$ s# H

LuData _stdcall OpMatrix(luINT mm,LuData *xx,void *hFor,int theOperator)        //运算符重载函数，用于LockKey函数# C- O( x& f2 X) Z, T# F/ c# R$ s

{ 
: W% `' p* b4 e- n* n\\" O5 J/ [
        LuData a;- E4 x) g6 m+ l- ?1 y

luRealArray *pRealArray1,*pRealArray2,*pRealArray3; 
  T! \9 F3 K! t
        luVOID i,j,k,m,n,u,v;) U; Y7 ]' q0 T4 u1 x8 E

double *pa,*pb,*pc;# |6 V% D0 k) T. o

luMessage pMessage; 
/ _$ _5 E) P6 f# A
        wchar_t wchNum[32];, F3 F3 G' j+ v% b- U& f% c

char chNum[32]; 
& ^1 K/ B1 {9 V+ [- ^: Z
        a.BType=luStaData_nil; a.VType=luStaData_nil; a.x=0;+ I! T% C' u& v( J1 O& m

switch(theOperator)6 D. E* y( h, I1 y

{% ~0 B9 x* v' ]& \$ A: x% n7 [

case 2:        //重载运算符* 
& k# u: g; m/ k# b$ H7 W. G9 X3 @
                pRealArray1=(luRealArray *)SearchKey((char *)&(xx->x),sizeof(luVOID),luDynData_realarray);5 W( K, a, {2 T8 g

pRealArray2=(luRealArray *)SearchKey((char *)&((xx+1)->x),sizeof(luVOID),luDynData_realarray); 
4 p+ ?: P) B& r2 ~* e2 b8 t
                if(!pRealArray1 || !pRealArray2) break;        //对象句柄无效，不是实数数组 
! u+ e$ ~) p' L5 E- Q
                if(pRealArray1->DimLen!=2 || pRealArray2->DimLen!=2) break;        //不是二维实数数组（矩阵） 
& O4 s* G8 \$ z2 U/ j
                if(pRealArray1->Dim[1]!=pRealArray2->Dim[0]) break;        //维数不匹配) R) P& K2 }/ L# [2 D$ _

pRealArray3=(luRealArray *)NewSysObj(luDynData_realarray,pRealArray1->Dim[0]*pRealArray2->Dim[1],2);        //创建矩阵对象 
3 A; \& x9 Y1 d% v5 k. }
                if(!pRealArray3) break; 
* k# o; z4 H! w- ?
                pRealArray3->Dim[0]=pRealArray1->Dim[0]; pRealArray3->Dim[1]=pRealArray2->Dim[1];        //设置矩阵维数大小6 L! a2 I6 U* m, U& u

pa=pRealArray1->Array; pb=pRealArray2->Array; pc=pRealArray3->Array;8 B7 V* l+ W$ ^# j, k

m=pRealArray1->Dim[0]; n=pRealArray1->Dim[1]; k=pRealArray2->Dim[1];) i( ~2 _- P6 m/ g

for(i=0; i<m; i++)        //矩阵乘\\" y3 v% Z  c$ J\\" H# i

{ 
. l# X4 k& J  d. s; l3 y' m& y$ e
                        for(j=0; j<k; j++)6 H4 e' ~\\" K5 I' D2 L! u3 ]% O

{ 
\\" N8 J. F2 Y8 Z; H! ]
                                u=i*k+j; pc[u]=0.0; 
, O. b; ]\\" U$ D3 A1 z5 {6 U
                                for (v=0; v<n; v++) 
' b; i/ q' q/ W7 V% E- z
                                {! e* k4 V; h( ?2 \0 X! A4 k

pc[u]=pc[u]+pa[i*n+v]*pb[v*k+j]; 
7 ?( y' T4 m& U\\" H8 j( n5 [1 J. R
                                }1 |  r, \! t5 `9 [\\" J0 n& U

} 
9 \# W: ?- L1 l' \
                }, U9 {& T+ V; R) t+ `! o\\" i) h

FunReObj(hFor);        //告诉Lu，返回一个动态对象\\" Z8 X  H/ b0 u

a.BType=luDynData_realarray; a.VType=Matrix; a.x=0; *(luVOID *)&(a.x)=(luVOID)pRealArray3; 
8 L* I$ @5 o& g& J( |
                break; 
$ c$ l& K/ X5 l1 Q! L+ T4 K  ]- E\\" ?
        case 25:        //重载运算符.*7 D7 |7 L) s8 ]) k/ W) |/ T) ]

pRealArray1=(luRealArray *)SearchKey((char *)&(xx->x),sizeof(luVOID),luDynData_realarray);6 e4 B# n6 [# w  B

pRealArray2=(luRealArray *)SearchKey((char *)&((xx+1)->x),sizeof(luVOID),luDynData_realarray);\\" h# {8 x* [% K8 d* Z

if(!pRealArray1 || !pRealArray2) break;        //对象句柄无效，不是实数数组 
; a& v  W/ m3 v/ L
                if(pRealArray1->DimLen!=2 || pRealArray2->DimLen!=2) break;        //不是二维实数数组（矩阵）3 T: U- Q: c( ?\\" y3 W% W

if(pRealArray1->Dim[0]!=pRealArray2->Dim[0] || pRealArray1->Dim[1]!=pRealArray2->Dim[1]) break;        //维数不相同* p% l; D# n2 ^

pRealArray3=(luRealArray *)NewSysObj(luDynData_realarray,pRealArray1->ArrayLen,2);        //创建矩阵对象 
1 K  E# b. D0 L: T8 D$ q2 E
                if(!pRealArray3) break; 
- H$ D1 n% H& P\\" m6 u! N. }. _, |* M- J
                pRealArray3->Dim[0]=pRealArray1->Dim[0]; pRealArray3->Dim[1]=pRealArray1->Dim[1];        //设置矩阵维数大小; K! A5 ]* V- {# c1 g8 k

for(i=0;i<pRealArray1->ArrayLen;i++) pRealArray3->Array[i]=pRealArray1->Array[i]*pRealArray2->Array[i];//矩阵点乘\\" J) q; I9 W$ ^& q! z

FunReObj(hFor);        //告诉Lu，返回一个动态对象6 y$ K) `& a! v' V

a.BType=luDynData_realarray; a.VType=Matrix; a.x=0; *(luVOID *)&(a.x)=(luVOID)pRealArray3; 
+ y; H( S2 C% _7 Z- F+ M5 o
                break; 
; L) G' g8 a8 ?! W
        case 46:        //重载函数new 
( J3 ]  Q5 T2 V. ^2 t  a
                a=ExeOperator(mm,xx,hFor,theOperator,luDynData_realarray);        //直接调用基本类型luDynData_realarray的new函数 
2 Y5 P9 f6 I$ n) U
                if(a.VType==luDynData_realarray) a.VType=Matrix;        //设置扩展类型为自定义的Matrix类型 
, C8 `( Y' ^7 S# E
                break;; e8 H\\" I% d( u, r3 ~9 Z; ?) q+ ^' ?( {( \! D

case 49:        //重载函数o 
1 F( O. f9 d\\" D, }2 p9 H\\" W% M8 Z
                pMessage=(luMessage)SearchKey("\0\0\0\0",sizeof(luVOID),luPubKey_User); 
; J0 l9 |9 @9 Y
                if(!pMessage) break; 
  M* G- g: V  C8 k4 b( q3 g0 S5 H
                pRealArray1=(luRealArray *)SearchKey((char *)&(xx->x),sizeof(luVOID),luDynData_realarray); 
) @9 N- D! E( x
                if(!pRealArray1) break;        //对象句柄无效，不是实数数组 
  f9 e1 v: V3 J& J* N& O
                if(pRealArray1->DimLen!=2) break;        //不是二维实数数组（矩阵） 
2 h* n' S\\" k, V! A+ b* ^2 a& v
                pa=pRealArray1->Array;1 x( _( ~' B- V* J

m=pRealArray1->Dim[0]; n=pRealArray1->Dim[1]; k=0; 
2 U* y+ l% @9 `6 Q# w& O( W  Z2 q, [
                for(i=0; i<m; i++)        //输出矩阵1 W5 e9 Z& k3 l8 b

{ 
8 m6 U% l8 I: t, Q; B8 ~: p5 \
                        pMessage(L"\r\n"); k+=2; 
6 b, g# ^2 ?- a+ T\\" ]
                        for(j=0; j<n; j++) 
  a3 O% Y( ^7 x& [4 T\\" X+ c\\" R
                        { 
4 {6 \9 f9 \3 |. t( P& c
                                _gcvt_s(chNum,pa[i*n+j],16);5 E& Y/ B+ q* @5 j

for(u=0;chNum[u];u++) {wchNum[u]=chNum[u]; k++;} 
, N: t6 N9 N/ n\\" Z( J( \
                                wchNum[u]='\0'; 
, i; K% I. j7 w6 G
                                pMessage(wchNum); pMessage(L"  "); k+=2;+ n6 @3 {3 D9 L

} 
  s1 j9 g! T. Y/ g; k0 G- G
                } 
* u/ @0 H8 U2 N( I' q1 V, A
                pMessage(L"\r\n"); k+=2; 
1 Z8 Q' f/ e. n# E& ]
                a.BType=luStaData_int64; a.VType=luStaData_int64; a.x=k;        //按函数o的要求，返回输出的字符总数( z# h; E) l9 F* j

break;7 E! ^\\" p2 K6 G) [  W0 E

default:. ]3 {' q& W: [

break; 
' Q+ m  |  n  y; R# U# B
        } 
+ q- @% e; V* V& |
        return a; 
% b; J5 M. Z6 e) Q2 D) \. e
} 
- N: K: L& I5 r4 u6 {; N\\" ?
void main(void)- ]3 \\\" _+ z$ v\\" y& \' H7 C

{ 
! s8 L/ ?  m3 D9 f
        void *hFor;                //表达式句柄3 L: l* w/ @3 C, r3 o0 W

luINT nPara;                //存放表达式的自变量个数 
: i  ~2 a  w/ a( H8 a
        LuData *pPara;                //存放输入自变量的数组指针\\" n9 q* U1 x0 G7 z3 X8 l( R

luINT ErrBegin,ErrEnd;        //表达式编译出错的初始位置和结束位置 
# f2 z6 ~+ p, ^3 [! z2 {7 k
        int ErrCode;                //错误代码 
: ]9 J2 T& e- P: q  F9 G* `
        void *v;) F3 _* U5 ~# |0 g' ?& k7 ^& n

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.]}";//字符串表达式，矩阵乘 
/ D$ A1 |  N4 I8 ^  q, @
        //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.]}";//字符串表达式，矩阵点乘 
$ @, M. y' U. q5 m% A
        LuData Val;) C% v& j5 C, h  w2 t' M: x4 g

if(!InitLu()) return;        //初始化Lu 
, X0 O! ?0 v' u2 n. O; ?
        while(LockKey(Matrix,DelMatrix,OpMatrix)){Matrix++;}        //锁定一个键，用于存储矩阵扩展类型 
9 o3 J: s! G: c+ I, ~9 `9 L( ]\\" v/ \
 
+ f' L7 c# J+ \- z
        Val.BType=luStaData_int64; Val.VType=luStaData_int64; Val.x=Matrix;        //定义整数常量 
4 i. C2 a% Y5 y2 E( g. t0 g
        SetConst(L"matrix",&Val);        //设置整数常量7 ]$ E% d4 D& Q

InsertKey("\0\0\0\0",4,luPubKey_User,LuMessage,NULL,NULL,1,v); //使Lu运行时可输出函数信息* m  ?) j9 O& P( h& o

wcout.imbue(locale("chs"));        //设置输出的locale为中文 
- k( e8 B0 O! q1 ]0 l
   
) ^/ |$ r9 N$ M3 N+ h
        ErrCode=LuCom(ForStr,0,0,0,hFor,nPara,pPara,ErrBegin,ErrEnd); //编译表达式 
# [& a' c5 f6 `3 w+ Y. k5 K
        if(ErrCode) 
, g. b( j, L9 o
        { 
+ u1 O5 {( @. m7 q+ K4 z
                wcout<<L"表达式有错误！错误代码："<<ErrCode<<endl;' y* O7 F; P! a4 _

} 
4 g9 G' @: w8 X; Z3 y; _) o/ f
        else; b' j( j* L$ P6 D\\" C+ ^

{ 
3 C9 s- c/ M3 c% Y2 e/ r7 t
                LuCal(hFor,pPara);        //计算表达式的值 
9 }8 }# q& c/ `
        }# U% N/ H# p. T/ V) W

LockKey(Matrix,NULL,OpMatrix);//解锁键Matrix，本例中，该函数可以不用 
! ~& m7 V- N# f\\" N
        FreeLu();                        //释放Lu+ S, q: O1 h9 Q9 q, f- n

}

习题：

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

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

main(:a,b,c,d,t,i)=
3 A, S4 z! Y9 t8 G) d4 [
a=new[matrix,2,2,data:1.,2.,2.,1.],
4 w) p0 J& I( F- P0 @* R
b=new[matrix,2,2,data:2.,1.,1.,2.],
x: Q: Y* ]' I: X
c=new[matrix,2,2,data:2/3.,-1/3.,-1/3.,2/3.],5 }6 d5 F; G+ T) K
t=clock(),
& g2 a( ?+ ]* x! \
d=a*b, i=0, while{i<1000000, d=d*c*b, i++},
. u1 d/ C- @5 ?- }/ P/ C/ z3 @
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\"}";//字符串表达式

复制代码

结果：