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

查看: 8669|回复: 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>. u8 t% w; Z: F2 }* q7 \: H
#include <iostream>6 c3 H* p/ _* U0 d2 L+ ~
#include <math.h>8 i/ J7 w! k# [3 E$ ]: P$ V
#include "lu32.h"4 M7 T6 F6 R- ?+ X
) v% T/ z7 p# F
#pragma comment( lib, "lu32.lib" )& o/ l b$ G6 X! l0 }- O1 _
( \& E1 E0 w1 l/ D* n
using namespace std;) u; ^- M6 P8 E) W
P( P$ a; {+ V7 B
luKEY Matrix=-1000; //标识矩阵类型，最终的Matrix由LockKey决定: Y; [2 m2 x+ Q
7 B/ j3 k. V4 ~: u* D
void _stdcall LuMessage(wchar_t *pch)//输出动态库信息，该函数注册到Lu，由Lu二级函数调用
- h. e4 S7 ?% a3 M- Y0 @\\" v7 m
{
( Y5 p/ p Z' Y# q( e5 i( ?
wcout<<pch;
/ v' V9 r. E1 H' i% i
}
( D' r9 s8 h7 n% M) G
void _stdcall DelMatrix(void *me) //用于LockKey函数，因为是基于系统内置实数数组创建矩阵，故该函数什么也不做; g+ g! s* l6 M A; b
{9 V' F/ i# e! o) J\\" |
}
' ^. t$ f% {0 m8 M/ I% D
LuData _stdcall OpMatrix(luINT mm,LuData *xx,void *hFor,int theOperator) //运算符重载函数，用于LockKey函数
2 C' W! k f4 L4 F
{
) j- K, b% M3 r* z: G1 U r
LuData a;
' ? w C, Q) }. b
luRealArray *pRealArray1,*pRealArray2,*pRealArray3;0 `. @3 E, \ ?4 B
luVOID i,j,k,m,n,u,v;# {' |5 `7 k$ {; h8 s0 g/ S7 U6 g
double *pa,*pb,*pc;' m+ t: K/ O' s t/ J, J* a
luMessage pMessage;4 a, `6 Q* T& X7 R
wchar_t wchNum[32];
0 S7 f1 H C* Q6 j) D
char chNum[32];+ D9 }# U$ [$ ^7 b2 U0 F( L: e
a.BType=luStaData_nil; a.VType=luStaData_nil; a.x=0;
0 ?3 B9 \& e; }/ \5 D( r
switch(theOperator)
) N$ J* L& |, Y9 O( D, j% i. D
{
7 ~0 c/ @. F0 E9 p# Q5 {1 t! M\\" H
case 2: //重载运算符*
: T, j F3 ]: n: s6 v3 d) x
pRealArray1=(luRealArray *)SearchKey((char *)&(xx->x),sizeof(luVOID),luDynData_realarray);
& k7 D$ J2 c0 Y7 V
pRealArray2=(luRealArray *)SearchKey((char *)&((xx+1)->x),sizeof(luVOID),luDynData_realarray);
6 ]' j1 B4 C4 X& y& ^# S
if(!pRealArray1 || !pRealArray2) break; //对象句柄无效，不是实数数组) i$ D5 T6 i: h+ d* d8 l
if(pRealArray1->DimLen!=2 || pRealArray2->DimLen!=2) break; //不是二维实数数组（矩阵）: h6 q( y! i1 P3 f
if(pRealArray1->Dim[1]!=pRealArray2->Dim[0]) break; //维数不匹配
- t$ [! J, }3 ^* D7 Q\\" e5 V, g* e
pRealArray3=(luRealArray *)NewSysObj(luDynData_realarray,pRealArray1->Dim[0]*pRealArray2->Dim[1],2); //创建矩阵对象7 o, g6 d; @- E
if(!pRealArray3) break;: b# }* Y+ x5 r# q, }, `
pRealArray3->Dim[0]=pRealArray1->Dim[0]; pRealArray3->Dim[1]=pRealArray2->Dim[1]; //设置矩阵维数大小\\" w# t2 J0 \2 L$ }! Q0 X
pa=pRealArray1->Array; pb=pRealArray2->Array; pc=pRealArray3->Array;, b, e# M7 h1 z2 D+ y/ }
m=pRealArray1->Dim[0]; n=pRealArray1->Dim[1]; k=pRealArray2->Dim[1];. U7 r! |: U) n
for(i=0; i<m; i++) //矩阵乘
( Z6 ]2 ~! u% C: X
{+ z' b7 T8 f, N
for(j=0; j<k; j++)
# t. S8 f# \% p2 t1 e5 t2 f
{
2 n# x# _: m! Q
u=i*k+j; pc[u]=0.0;: I C9 C! \) J& k- k& @
for (v=0; v<n; v++)
5 `* [. f% S4 S3 w: D
{
2 T' H1 R8 \6 S# Q$ @! m
pc[u]=pc[u]+pa[i*n+v]*pb[v*k+j];
}0 Z1 o) H \$ Z/ v+ C* d
}
}: Y* K6 g0 f: `\\" ~# I- C
}
0 v$ H# S6 o# p7 `\\" g/ R/ R( i
FunReObj(hFor); //告诉Lu，返回一个动态对象, y2 T/ a/ K C* t; ~/ V\\" _) i
a.BType=luDynData_realarray; a.VType=Matrix; a.x=0; *(luVOID *)&(a.x)=(luVOID)pRealArray3;
1 C. W\\" }! p\\" Z: w
break;
7 ^2 E5 R r% L) b0 {4 [9 a
case 25: //重载运算符.*1 Q: z$ }9 C$ e9 g8 y# U. Z\\" r% x, Q
pRealArray1=(luRealArray *)SearchKey((char *)&(xx->x),sizeof(luVOID),luDynData_realarray);+ H9 ]) ?\\" I7 A9 e( D0 D
pRealArray2=(luRealArray *)SearchKey((char *)&((xx+1)->x),sizeof(luVOID),luDynData_realarray);) n: ]8 L* ?* \) V) m4 n
if(!pRealArray1 || !pRealArray2) break; //对象句柄无效，不是实数数组: ?6 g7 J* S$ e/ W
if(pRealArray1->DimLen!=2 || pRealArray2->DimLen!=2) break; //不是二维实数数组（矩阵）. e& F, H; o+ N! h# N
if(pRealArray1->Dim[0]!=pRealArray2->Dim[0] || pRealArray1->Dim[1]!=pRealArray2->Dim[1]) break; //维数不相同
# ~/ X# v3 j3 o
pRealArray3=(luRealArray *)NewSysObj(luDynData_realarray,pRealArray1->ArrayLen,2); //创建矩阵对象
' L5 @0 p& ~: p
if(!pRealArray3) break;; J) [: }2 x6 P! j+ {1 j
pRealArray3->Dim[0]=pRealArray1->Dim[0]; pRealArray3->Dim[1]=pRealArray1->Dim[1]; //设置矩阵维数大小# M6 l' a- Y5 S3 Y- e2 s
for(i=0;i<pRealArray1->ArrayLen;i++) pRealArray3->Array[i]=pRealArray1->Array[i]*pRealArray2->Array[i];//矩阵点乘; |0 a9 }9 z9 P. x+ E7 W\\" j3 G
FunReObj(hFor); //告诉Lu，返回一个动态对象
# v0 c: z# _0 V% }5 v$ D
a.BType=luDynData_realarray; a.VType=Matrix; a.x=0; *(luVOID *)&(a.x)=(luVOID)pRealArray3;
3 P, L! v( W# S+ P) v3 W- M
break;
6 d) X& Y5 {( E* t o
case 46: //重载函数new8 I1 m' J1 K* L# }
a=ExeOperator(mm,xx,hFor,theOperator,luDynData_realarray); //直接调用基本类型luDynData_realarray的new函数
9 k* p5 G. T2 Z' j( \
if(a.VType==luDynData_realarray) a.VType=Matrix; //设置扩展类型为自定义的Matrix类型
6 W8 d) x6 r% {+ ~$ C6 U
break;
, {% V8 c( N( J: v& c
case 49: //重载函数o
) s9 {! j# @4 ^6 r3 i
pMessage=(luMessage)SearchKey("\0\0\0\0",sizeof(luVOID),luPubKey_User);+ P: h7 {3 z+ A, x: }
if(!pMessage) break;
% p2 N/ [+ v! T1 P\\" P% i, p$ x2 R$ p
pRealArray1=(luRealArray *)SearchKey((char *)&(xx->x),sizeof(luVOID),luDynData_realarray);3 n; T* ? p! f( P q/ v9 ?7 v
if(!pRealArray1) break; //对象句柄无效，不是实数数组) m+ a) b$ P, E
if(pRealArray1->DimLen!=2) break; //不是二维实数数组（矩阵）* `1 A+ U% a, k( g
pa=pRealArray1->Array;
( _* T: y5 b7 r
m=pRealArray1->Dim[0]; n=pRealArray1->Dim[1]; k=0;& w/ @/ u! y. Z9 C+ [2 J$ r2 `
for(i=0; i<m; i++) //输出矩阵
* S0 g3 A h$ q' g/ ]& [; ~
{
; B, l4 U8 q* X- L7 F+ W\\" a
pMessage(L"\r\n"); k+=2;5 r& Q, w1 n4 m; `
for(j=0; j<n; j++)
* N1 A! T* `) B t
{
+ R% d: B7 t) H, ~
_gcvt_s(chNum,pa[i*n+j],16);
& B4 r+ j% L$ L* i1 Y\\" R1 Q8 s/ z
for(u=0;chNum[u];u++) {wchNum[u]=chNum[u]; k++;}. x+ z3 o/ q: S+ W2 X' `; U3 Y; C+ g
wchNum[u]='\0';
7 Y' J ?: ?- T b* X
pMessage(wchNum); pMessage(L" "); k+=2;
+ d5 a3 M9 p Q. [0 Q
}# J/ l( L1 N* i, w) _2 b
}
6 D# y: v/ ]5 y% k1 u0 e6 i& ?/ `% P
pMessage(L"\r\n"); k+=2;
& ?3 H\\" v4 @) h' t% m
a.BType=luStaData_int64; a.VType=luStaData_int64; a.x=k; //按函数o的要求，返回输出的字符总数
: ?! [4 [% h) l5 T# A
break;. K2 q$ N2 z. ?/ @5 k/ Q3 D
default:1 h+ f1 n4 ^5 \! [) v
break;+ j Q; t9 _2 ?- h
}
0 K* v- q7 ^' P# o! w
return a;
, c; ?) h2 g4 I) H
}- z& v: u; v9 p0 R
void main(void)# c: t/ `% [9 F
{
. D2 q( J+ B& s+ Q/ u7 l
void *hFor; //表达式句柄
8 ?+ {/ C$ C. r8 n: j) g# l. N5 g, v
luINT nPara; //存放表达式的自变量个数
0 g# O; k/ h6 ?6 }3 b
LuData *pPara; //存放输入自变量的数组指针3 {& b' o& X9 x' B2 w
luINT ErrBegin,ErrEnd; //表达式编译出错的初始位置和结束位置
# y& n1 o1 ^0 \
int ErrCode; //错误代码
7 J3 f* P2 z# v- w. r
void *v;9 Q& c% P( Z9 ?
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.]}";//字符串表达式，矩阵乘7 J6 ~% X; C8 W) _
//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.]}";//字符串表达式，矩阵点乘
9 Z/ H0 M' _7 N\\" O1 c
LuData Val;3 Q' ^8 ?, ]% q
if(!InitLu()) return; //初始化Lu
3 W8 ~$ W\\" U- O8 C) p* C( d& A1 @
while(LockKey(Matrix,DelMatrix,OpMatrix)){Matrix++;} //锁定一个键，用于存储矩阵扩展类型
* w8 f. R5 \0 h W
3 U# p& t& l$ e9 T
Val.BType=luStaData_int64; Val.VType=luStaData_int64; Val.x=Matrix; //定义整数常量
! x B. x* T' F0 r7 u
SetConst(L"matrix",&Val); //设置整数常量
; \8 \( p5 ~+ ^3 [
InsertKey("\0\0\0\0",4,luPubKey_User,LuMessage,NULL,NULL,1,v); //使Lu运行时可输出函数信息
( F' F# B) V, i
wcout.imbue(locale("chs")); //设置输出的locale为中文% n4 ~' _% U4 o4 g5 [! o\\" s\\" K
' Q s& ^# {6 Y
ErrCode=LuCom(ForStr,0,0,0,hFor,nPara,pPara,ErrBegin,ErrEnd); //编译表达式4 C; i6 ^7 E8 L3 V- r
if(ErrCode)
9 }) M3 r7 }. ~6 A ?: d7 C
{
- M) Q1 m9 O) m( v4 b; N, w
wcout<<L"表达式有错误！错误代码："<<ErrCode<<endl;
0 y) |2 K8 O2 A2 w
}
8 J' I0 F. N; G3 F: w
else8 x* t4 X' W, U5 h. V
{
& o- o/ _9 M& X
LuCal(hFor,pPara); //计算表达式的值
. L& ]( L7 Y5 L9 x- \
}
0 i. Y8 p; C% q9 E( [) t1 V
LockKey(Matrix,NULL,OpMatrix);//解锁键Matrix，本例中，该函数可以不用& D2 r2 \8 `* e: Q& |1 s! [! ^) _
FreeLu(); //释放Lu
* ^$ K7 f! Y. W, u\\" _
}

#include <windows.h>. u8 t% w; Z: F2 }* q7 \: H

#include <iostream>6 c3 H* p/ _* U0 d2 L+ ~

#include <math.h>8 i/ J7 w! k# [3 E$ ]: P$ V

#include "lu32.h"4 M7 T6 F6 R- ?+ X

) v% T/ z7 p# F

#pragma comment( lib, "lu32.lib" )& o/ l  b$ G6 X! l0 }- O1 _

( \& E1 E0 w1 l/ D* n

using namespace std;) u; ^- M6 P8 E) W

P( P$ a; {+ V7 B

luKEY Matrix=-1000;        //标识矩阵类型，最终的Matrix由LockKey决定: Y; [2 m2 x+ Q

7 B/ j3 k. V4 ~: u* D
void _stdcall LuMessage(wchar_t *pch)//输出动态库信息，该函数注册到Lu，由Lu二级函数调用 
- h. e4 S7 ?% a3 M- Y0 @\\" v7 m
{ 
( Y5 p/ p  Z' Y# q( e5 i( ?
        wcout<<pch; 
/ v' V9 r. E1 H' i% i
} 
( D' r9 s8 h7 n% M) G
void _stdcall DelMatrix(void *me)        //用于LockKey函数，因为是基于系统内置实数数组创建矩阵，故该函数什么也不做; g+ g! s* l6 M  A; b

{9 V' F/ i# e! o) J\\" |

} 
' ^. t$ f% {0 m8 M/ I% D
LuData _stdcall OpMatrix(luINT mm,LuData *xx,void *hFor,int theOperator)        //运算符重载函数，用于LockKey函数 
2 C' W! k  f4 L4 F
{ 
) j- K, b% M3 r* z: G1 U  r
        LuData a; 
' ?  w  C, Q) }. b
        luRealArray *pRealArray1,*pRealArray2,*pRealArray3;0 `. @3 E, \  ?4 B

luVOID i,j,k,m,n,u,v;# {' |5 `7 k$ {; h8 s0 g/ S7 U6 g

double *pa,*pb,*pc;' m+ t: K/ O' s  t/ J, J* a

luMessage pMessage;4 a, `6 Q* T& X7 R

wchar_t wchNum[32]; 
0 S7 f1 H  C* Q6 j) D
        char chNum[32];+ D9 }# U$ [$ ^7 b2 U0 F( L: e

a.BType=luStaData_nil; a.VType=luStaData_nil; a.x=0; 
0 ?3 B9 \& e; }/ \5 D( r
        switch(theOperator) 
) N$ J* L& |, Y9 O( D, j% i. D
        { 
7 ~0 c/ @. F0 E9 p# Q5 {1 t! M\\" H
        case 2:        //重载运算符* 
: T, j  F3 ]: n: s6 v3 d) x
                pRealArray1=(luRealArray *)SearchKey((char *)&(xx->x),sizeof(luVOID),luDynData_realarray); 
& k7 D$ J2 c0 Y7 V
                pRealArray2=(luRealArray *)SearchKey((char *)&((xx+1)->x),sizeof(luVOID),luDynData_realarray); 
6 ]' j1 B4 C4 X& y& ^# S
                if(!pRealArray1 || !pRealArray2) break;        //对象句柄无效，不是实数数组) i$ D5 T6 i: h+ d* d8 l

if(pRealArray1->DimLen!=2 || pRealArray2->DimLen!=2) break;        //不是二维实数数组（矩阵）: h6 q( y! i1 P3 f

if(pRealArray1->Dim[1]!=pRealArray2->Dim[0]) break;        //维数不匹配 
- t$ [! J, }3 ^* D7 Q\\" e5 V, g* e
                pRealArray3=(luRealArray *)NewSysObj(luDynData_realarray,pRealArray1->Dim[0]*pRealArray2->Dim[1],2);        //创建矩阵对象7 o, g6 d; @- E

if(!pRealArray3) break;: b# }* Y+ x5 r# q, }, `

pRealArray3->Dim[0]=pRealArray1->Dim[0]; pRealArray3->Dim[1]=pRealArray2->Dim[1];        //设置矩阵维数大小\\" w# t2 J0 \2 L$ }! Q0 X

pa=pRealArray1->Array; pb=pRealArray2->Array; pc=pRealArray3->Array;, b, e# M7 h1 z2 D+ y/ }

m=pRealArray1->Dim[0]; n=pRealArray1->Dim[1]; k=pRealArray2->Dim[1];. U7 r! |: U) n

for(i=0; i<m; i++)        //矩阵乘 
( Z6 ]2 ~! u% C: X
                {+ z' b7 T8 f, N

for(j=0; j<k; j++) 
# t. S8 f# \% p2 t1 e5 t2 f
                        { 
2 n# x# _: m! Q
                                u=i*k+j; pc[u]=0.0;: I  C9 C! \) J& k- k& @

for (v=0; v<n; v++) 
5 `* [. f% S4 S3 w: D
                                { 
2 T' H1 R8 \6 S# Q$ @! m
                                        pc[u]=pc[u]+pa[i*n+v]*pb[v*k+j]; 
  }0 Z1 o) H  \$ Z/ v+ C* d
                                } 
2 V& _- g. U9 ^; P  ?. r: Z0 Y  L( M
                        }: Y* K6 g0 f: `\\" ~# I- C

} 
0 v$ H# S6 o# p7 `\\" g/ R/ R( i
                FunReObj(hFor);        //告诉Lu，返回一个动态对象, y2 T/ a/ K  C* t; ~/ V\\" _) i

a.BType=luDynData_realarray; a.VType=Matrix; a.x=0; *(luVOID *)&(a.x)=(luVOID)pRealArray3; 
1 C. W\\" }! p\\" Z: w
                break; 
7 ^2 E5 R  r% L) b0 {4 [9 a
        case 25:        //重载运算符.*1 Q: z$ }9 C$ e9 g8 y# U. Z\\" r% x, Q

pRealArray1=(luRealArray *)SearchKey((char *)&(xx->x),sizeof(luVOID),luDynData_realarray);+ H9 ]) ?\\" I7 A9 e( D0 D

pRealArray2=(luRealArray *)SearchKey((char *)&((xx+1)->x),sizeof(luVOID),luDynData_realarray);) n: ]8 L* ?* \) V) m4 n

if(!pRealArray1 || !pRealArray2) break;        //对象句柄无效，不是实数数组: ?6 g7 J* S$ e/ W

if(pRealArray1->DimLen!=2 || pRealArray2->DimLen!=2) break;        //不是二维实数数组（矩阵）. e& F, H; o+ N! h# N

if(pRealArray1->Dim[0]!=pRealArray2->Dim[0] || pRealArray1->Dim[1]!=pRealArray2->Dim[1]) break;        //维数不相同 
# ~/ X# v3 j3 o
                pRealArray3=(luRealArray *)NewSysObj(luDynData_realarray,pRealArray1->ArrayLen,2);        //创建矩阵对象 
' L5 @0 p& ~: p
                if(!pRealArray3) break;; J) [: }2 x6 P! j+ {1 j

pRealArray3->Dim[0]=pRealArray1->Dim[0]; pRealArray3->Dim[1]=pRealArray1->Dim[1];        //设置矩阵维数大小# M6 l' a- Y5 S3 Y- e2 s

for(i=0;i<pRealArray1->ArrayLen;i++) pRealArray3->Array[i]=pRealArray1->Array[i]*pRealArray2->Array[i];//矩阵点乘; |0 a9 }9 z9 P. x+ E7 W\\" j3 G

FunReObj(hFor);        //告诉Lu，返回一个动态对象 
# v0 c: z# _0 V% }5 v$ D
                a.BType=luDynData_realarray; a.VType=Matrix; a.x=0; *(luVOID *)&(a.x)=(luVOID)pRealArray3; 
3 P, L! v( W# S+ P) v3 W- M
                break; 
6 d) X& Y5 {( E* t  o
        case 46:        //重载函数new8 I1 m' J1 K* L# }

a=ExeOperator(mm,xx,hFor,theOperator,luDynData_realarray);        //直接调用基本类型luDynData_realarray的new函数 
9 k* p5 G. T2 Z' j( \
                if(a.VType==luDynData_realarray) a.VType=Matrix;        //设置扩展类型为自定义的Matrix类型 
6 W8 d) x6 r% {+ ~$ C6 U
                break; 
, {% V8 c( N( J: v& c
        case 49:        //重载函数o 
) s9 {! j# @4 ^6 r3 i
                pMessage=(luMessage)SearchKey("\0\0\0\0",sizeof(luVOID),luPubKey_User);+ P: h7 {3 z+ A, x: }

if(!pMessage) break; 
% p2 N/ [+ v! T1 P\\" P% i, p$ x2 R$ p
                pRealArray1=(luRealArray *)SearchKey((char *)&(xx->x),sizeof(luVOID),luDynData_realarray);3 n; T* ?  p! f( P  q/ v9 ?7 v

if(!pRealArray1) break;        //对象句柄无效，不是实数数组) m+ a) b$ P, E

if(pRealArray1->DimLen!=2) break;        //不是二维实数数组（矩阵）* `1 A+ U% a, k( g

pa=pRealArray1->Array; 
( _* T: y5 b7 r
                m=pRealArray1->Dim[0]; n=pRealArray1->Dim[1]; k=0;& w/ @/ u! y. Z9 C+ [2 J$ r2 `

for(i=0; i<m; i++)        //输出矩阵 
* S0 g3 A  h$ q' g/ ]& [; ~
                { 
; B, l4 U8 q* X- L7 F+ W\\" a
                        pMessage(L"\r\n"); k+=2;5 r& Q, w1 n4 m; `

for(j=0; j<n; j++) 
* N1 A! T* `) B  t
                        { 
+ R% d: B7 t) H, ~
                                _gcvt_s(chNum,pa[i*n+j],16); 
& B4 r+ j% L$ L* i1 Y\\" R1 Q8 s/ z
                                for(u=0;chNum[u];u++) {wchNum[u]=chNum[u]; k++;}. x+ z3 o/ q: S+ W2 X' `; U3 Y; C+ g

wchNum[u]='\0'; 
7 Y' J  ?: ?- T  b* X
                                pMessage(wchNum); pMessage(L"  "); k+=2; 
+ d5 a3 M9 p  Q. [0 Q
                        }# J/ l( L1 N* i, w) _2 b

} 
6 D# y: v/ ]5 y% k1 u0 e6 i& ?/ `% P
                pMessage(L"\r\n"); k+=2; 
& ?3 H\\" v4 @) h' t% m
                a.BType=luStaData_int64; a.VType=luStaData_int64; a.x=k;        //按函数o的要求，返回输出的字符总数 
: ?! [4 [% h) l5 T# A
                break;. K2 q$ N2 z. ?/ @5 k/ Q3 D

default:1 h+ f1 n4 ^5 \! [) v

break;+ j  Q; t9 _2 ?- h

} 
0 K* v- q7 ^' P# o! w
        return a; 
, c; ?) h2 g4 I) H
}- z& v: u; v9 p0 R

void main(void)# c: t/ `% [9 F

{ 
. D2 q( J+ B& s+ Q/ u7 l
        void *hFor;                //表达式句柄 
8 ?+ {/ C$ C. r8 n: j) g# l. N5 g, v
        luINT nPara;                //存放表达式的自变量个数 
0 g# O; k/ h6 ?6 }3 b
        LuData *pPara;                //存放输入自变量的数组指针3 {& b' o& X9 x' B2 w

luINT ErrBegin,ErrEnd;        //表达式编译出错的初始位置和结束位置 
# y& n1 o1 ^0 \
        int ErrCode;                //错误代码 
7 J3 f* P2 z# v- w. r
        void *v;9 Q& c% P( Z9 ?

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.]}";//字符串表达式，矩阵乘7 J6 ~% X; C8 W) _

//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.]}";//字符串表达式，矩阵点乘 
9 Z/ H0 M' _7 N\\" O1 c
        LuData Val;3 Q' ^8 ?, ]% q

if(!InitLu()) return;        //初始化Lu 
3 W8 ~$ W\\" U- O8 C) p* C( d& A1 @
        while(LockKey(Matrix,DelMatrix,OpMatrix)){Matrix++;}        //锁定一个键，用于存储矩阵扩展类型 
* w8 f. R5 \0 h  W
 
3 U# p& t& l$ e9 T
        Val.BType=luStaData_int64; Val.VType=luStaData_int64; Val.x=Matrix;        //定义整数常量 
! x  B. x* T' F0 r7 u
        SetConst(L"matrix",&Val);        //设置整数常量 
; \8 \( p5 ~+ ^3 [
        InsertKey("\0\0\0\0",4,luPubKey_User,LuMessage,NULL,NULL,1,v); //使Lu运行时可输出函数信息 
( F' F# B) V, i
        wcout.imbue(locale("chs"));        //设置输出的locale为中文% n4 ~' _% U4 o4 g5 [! o\\" s\\" K

' Q  s& ^# {6 Y

ErrCode=LuCom(ForStr,0,0,0,hFor,nPara,pPara,ErrBegin,ErrEnd); //编译表达式4 C; i6 ^7 E8 L3 V- r

if(ErrCode) 
9 }) M3 r7 }. ~6 A  ?: d7 C
        { 
- M) Q1 m9 O) m( v4 b; N, w
                wcout<<L"表达式有错误！错误代码："<<ErrCode<<endl; 
0 y) |2 K8 O2 A2 w
        } 
8 J' I0 F. N; G3 F: w
        else8 x* t4 X' W, U5 h. V

{ 
& o- o/ _9 M& X
                LuCal(hFor,pPara);        //计算表达式的值 
. L& ]( L7 Y5 L9 x- \
        } 
0 i. Y8 p; C% q9 E( [) t1 V
        LockKey(Matrix,NULL,OpMatrix);//解锁键Matrix，本例中，该函数可以不用& D2 r2 \8 `* e: Q& |1 s! [! ^) _

FreeLu();                        //释放Lu 
* ^$ K7 f! Y. W, u\\" _
}

习题：

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

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

main(:a,b,c,d,t,i)=0 e4 H/ m4 T# O\" n, U
a=new[matrix,2,2,data:1.,2.,2.,1.],
( a: ]8 G( Y. ?3 }, M0 O# T# v
b=new[matrix,2,2,data:2.,1.,1.,2.],9 j( ?/ _2 j% p/ l
c=new[matrix,2,2,data:2/3.,-1/3.,-1/3.,2/3.],
+ ]. L% e7 q: I( y1 E9 H, Q
t=clock(),$ p% o9 ` b! B1 G# w( @: r
d=a*b, i=0, while{i<1000000, d=d*c*b, i++},/ p( ~8 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\"}";//字符串表达式

复制代码

结果：