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

查看: 8876|回复: 2

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>2 v8 z2 Y k9 B) Z
#include <iostream>
* K1 z7 m( [+ ?9 C7 N5 S
#include <math.h>( w4 U& A9 `; s5 s
#include "lu32.h"
* K( t! v; x# ]
! m+ M) C! N7 Q, K
#pragma comment( lib, "lu32.lib" )\\" {3 \. b9 G8 T$ e6 a
, M- I& N2 h1 y5 ^' j
using namespace std;' \+ K; }' g! o5 |* Q& V\\" t/ ^. H
2 N# M0 l6 T& x) e/ _# E$ Z5 n* A
luKEY Matrix=-1000; //标识矩阵类型，最终的Matrix由LockKey决定6 p6 B( d7 f: s
2 H- n3 U$ `: r\\" E) M
void _stdcall LuMessage(wchar_t *pch)//输出动态库信息，该函数注册到Lu，由Lu二级函数调用
/ B. z9 K' S: B$ [$ ?. d
{
& O4 `! g0 o3 \+ E( }
wcout<<pch;
+ G6 h' t+ r4 H
} P- t! O7 A\\" S3 B; S
void _stdcall DelMatrix(void *me) //用于LockKey函数，因为是基于系统内置实数数组创建矩阵，故该函数什么也不做
( n4 D' h2 J7 p( Q9 J9 f& h0 W
{6 d$ o4 k L# K7 J' x
}9 O+ s/ h6 \% b0 y
LuData _stdcall OpMatrix(luINT mm,LuData *xx,void *hFor,int theOperator) //运算符重载函数，用于LockKey函数+ X9 P9 o) W0 f# ~1 |
{
% Z9 X7 k/ S J1 W$ V. o/ _+ F5 P
LuData a;
3 G: [0 ]: x5 O% T1 o5 S
luRealArray *pRealArray1,*pRealArray2,*pRealArray3;
+ m1 ?7 L6 L( F; F5 D
luVOID i,j,k,m,n,u,v;5 V( [* R' u. z4 u. c
double *pa,*pb,*pc;9 G, P7 m) L1 Q4 t4 H0 M
luMessage pMessage;0 F) C\\" w' F8 b) V
wchar_t wchNum[32];: F5 E3 u9 s2 M. o0 x
char chNum[32];5 f7 [\\" r\\" \. `/ t
a.BType=luStaData_nil; a.VType=luStaData_nil; a.x=0;
m+ Y) T) y# R& e. U
switch(theOperator)# C2 J* J- D( p, y
{
& d8 E2 W+ d* s
case 2: //重载运算符*
+ K' u) X8 r) E/ `& \( Q
pRealArray1=(luRealArray *)SearchKey((char *)&(xx->x),sizeof(luVOID),luDynData_realarray);3 X8 U7 [' a% J0 u [9 w
pRealArray2=(luRealArray *)SearchKey((char *)&((xx+1)->x),sizeof(luVOID),luDynData_realarray);
3 U8 f$ a% L: [) h( t% s5 p
if(!pRealArray1 || !pRealArray2) break; //对象句柄无效，不是实数数组* b& [' r9 x2 v: V+ \
if(pRealArray1->DimLen!=2 || pRealArray2->DimLen!=2) break; //不是二维实数数组（矩阵）
+ M/ \, D& K4 p5 l. v5 X- T
if(pRealArray1->Dim[1]!=pRealArray2->Dim[0]) break; //维数不匹配
: S9 C: C1 F! |) J0 E1 z5 Q9 R
pRealArray3=(luRealArray *)NewSysObj(luDynData_realarray,pRealArray1->Dim[0]*pRealArray2->Dim[1],2); //创建矩阵对象& Z( V$ x9 W2 Z
if(!pRealArray3) break;* m$ ?; M8 B, X( x& Y
pRealArray3->Dim[0]=pRealArray1->Dim[0]; pRealArray3->Dim[1]=pRealArray2->Dim[1]; //设置矩阵维数大小
! M8 ^3 B& B% z
pa=pRealArray1->Array; pb=pRealArray2->Array; pc=pRealArray3->Array;
, E2 l p) M3 c t
m=pRealArray1->Dim[0]; n=pRealArray1->Dim[1]; k=pRealArray2->Dim[1];
% o3 C$ s# e* P1 ~
for(i=0; i<m; i++) //矩阵乘# l0 j- X: P4 M- V- _
{/ r8 L- A% L8 ?- A& G
for(j=0; j<k; j++)+ J# O5 E1 Y* C$ d: K
{
: x+ S0 s, a j' E4 C) E c7 a
u=i*k+j; pc[u]=0.0;
8 m; t+ F. H. i
for (v=0; v<n; v++)
$ _! ^0 S$ d/ }9 ^6 ?, L. u; l
{\\" ?& A, e5 F: g+ W* J
pc[u]=pc[u]+pa[i*n+v]*pb[v*k+j];
4 J% R. r2 f7 ~6 x3 k( F
}
+ d1 f# R: N+ Y
}
/ N! ]+ S( h* T% t- G4 }
}
) J( K0 ^; j: k, M. V0 E) ]1 I
FunReObj(hFor); //告诉Lu，返回一个动态对象
& Y; Z' Y) U3 m1 }8 Y. M8 H
a.BType=luDynData_realarray; a.VType=Matrix; a.x=0; *(luVOID *)&(a.x)=(luVOID)pRealArray3;
' B9 J: o2 L2 k- {6 `6 l
break;: A- w4 ~+ k5 f% m+ ]' L* D
case 25: //重载运算符.*8 D+ F( d3 C, s5 A6 s( x
pRealArray1=(luRealArray *)SearchKey((char *)&(xx->x),sizeof(luVOID),luDynData_realarray);. q3 e, g/ L: S
pRealArray2=(luRealArray *)SearchKey((char *)&((xx+1)->x),sizeof(luVOID),luDynData_realarray);
- m# K% n7 X- G+ O: d5 }8 i' s' d
if(!pRealArray1 || !pRealArray2) break; //对象句柄无效，不是实数数组8 I% T O6 Y6 }+ i2 V
if(pRealArray1->DimLen!=2 || pRealArray2->DimLen!=2) break; //不是二维实数数组（矩阵）7 n. b' U; a/ r% g
if(pRealArray1->Dim[0]!=pRealArray2->Dim[0] || pRealArray1->Dim[1]!=pRealArray2->Dim[1]) break; //维数不相同. X- A- E* T; u\\" p4 e) P
pRealArray3=(luRealArray *)NewSysObj(luDynData_realarray,pRealArray1->ArrayLen,2); //创建矩阵对象
6 g( c+ C: a [/ f
if(!pRealArray3) break;
7 [4 L\\" o7 l% l' [\\" H
pRealArray3->Dim[0]=pRealArray1->Dim[0]; pRealArray3->Dim[1]=pRealArray1->Dim[1]; //设置矩阵维数大小. s7 N5 D- d+ B, e3 ]7 C
for(i=0;i<pRealArray1->ArrayLen;i++) pRealArray3->Array[i]=pRealArray1->Array[i]*pRealArray2->Array[i];//矩阵点乘
$ Y6 l9 g; {& F( N
FunReObj(hFor); //告诉Lu，返回一个动态对象
/ E w7 S [+ R. D( y9 a
a.BType=luDynData_realarray; a.VType=Matrix; a.x=0; *(luVOID *)&(a.x)=(luVOID)pRealArray3;+ q1 _+ V' p( m
break;
X! a2 w$ ~\\" a) {! ]
case 46: //重载函数new% `6 C# _) T0 ?\\" ?& F; F\\" `; h
a=ExeOperator(mm,xx,hFor,theOperator,luDynData_realarray); //直接调用基本类型luDynData_realarray的new函数) K/ Y; Y/ I\\" f! G
if(a.VType==luDynData_realarray) a.VType=Matrix; //设置扩展类型为自定义的Matrix类型
8 p2 ~. v6 c* V- n+ p
break;
5 L\\" O; u3 ~2 c, Z' b
case 49: //重载函数o% ?4 j* D* ^# j& n
pMessage=(luMessage)SearchKey("\0\0\0\0",sizeof(luVOID),luPubKey_User);
+ s2 k0 x9 Y* \- I! R0 A; @
if(!pMessage) break;3 O\\" N; C& v. U$ _0 H8 h
pRealArray1=(luRealArray *)SearchKey((char *)&(xx->x),sizeof(luVOID),luDynData_realarray); v* O( U3 m8 X3 w9 J
if(!pRealArray1) break; //对象句柄无效，不是实数数组
5 [. a; q2 i, R# h8 N
if(pRealArray1->DimLen!=2) break; //不是二维实数数组（矩阵）6 x, h* t* s! n% c: o
pa=pRealArray1->Array;
6 M2 l& E- f6 h. a9 D# k
m=pRealArray1->Dim[0]; n=pRealArray1->Dim[1]; k=0;! Q9 ]( @+ @. ~* Y
for(i=0; i<m; i++) //输出矩阵' @2 E5 Z6 d& F f1 ]
{/ `6 a5 g7 Q6 r2 Y
pMessage(L"\r\n"); k+=2;
; f$ G: Y( f\\" `# ~* Z- p+ N5 @
for(j=0; j<n; j++)4 E( p\\" g: u% R* X9 x9 F2 ?+ R+ f
{, S9 Y0 V/ g# _. G
_gcvt_s(chNum,pa[i*n+j],16);
4 T* g, L1 Z& w
for(u=0;chNum[u];u++) {wchNum[u]=chNum[u]; k++;}
5 }1 W$ a& r+ `
wchNum[u]='\0';
- `+ ]9 S* }7 R8 S6 B
pMessage(wchNum); pMessage(L" "); k+=2;; [9 v1 z5 ]0 g% c0 T# l! ~# a8 {
}
/ r, \\\" @0 W8 ^+ ]0 a
}9 Z+ S' l3 ~! \& j k$ e: K7 o/ R+ Z
pMessage(L"\r\n"); k+=2;
, Z4 c, C+ l& A2 }
a.BType=luStaData_int64; a.VType=luStaData_int64; a.x=k; //按函数o的要求，返回输出的字符总数1 L- G$ Z; J/ h5 u* a( ]1 S
break;, j' Z6 [6 R8 x; I n+ A
default: s/ I* Y o( r& l: t, d, m+ O: @. d
break;
7 F5 I V/ l2 w5 m! k2 @9 P
}7 X( e# O4 q& m. M+ X6 a
return a;3 Y Q. Q! d2 e1 x6 T
}2 c) t) T X; H
void main(void)* K: z\\" W6 H# B4 f2 _ Y
{
1 H/ \5 j9 j: A9 o: ?4 M
void *hFor; //表达式句柄
1 x0 m+ t+ |' } P. ?0 [\\" a3 f% h
luINT nPara; //存放表达式的自变量个数
* o. ? y6 k\\" P9 a# q }' h
LuData *pPara; //存放输入自变量的数组指针2 X/ j$ e6 p4 c: |
luINT ErrBegin,ErrEnd; //表达式编译出错的初始位置和结束位置
* X& ^& r5 f+ ~ q\\" L
int ErrCode; //错误代码
- n% @, ?# z/ ^- u
void *v;. c4 m0 K: C8 n/ z/ G+ 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.]}";//字符串表达式，矩阵乘
- _5 e2 x! A3 [ m
//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.]}";//字符串表达式，矩阵点乘& `. I! H* [4 q
LuData Val;
8 N% K/ `5 Q! |+ y) s0 l
if(!InitLu()) return; //初始化Lu
1 S7 P. Q; R0 l
while(LockKey(Matrix,DelMatrix,OpMatrix)){Matrix++;} //锁定一个键，用于存储矩阵扩展类型
7 ~\\" X8 h( n$ W: d% l
0 K d0 F. d3 u' i8 d! {* E
Val.BType=luStaData_int64; Val.VType=luStaData_int64; Val.x=Matrix; //定义整数常量 x- @2 n' D, N; P3 i
SetConst(L"matrix",&Val); //设置整数常量 [* T3 G3 c' t7 a
InsertKey("\0\0\0\0",4,luPubKey_User,LuMessage,NULL,NULL,1,v); //使Lu运行时可输出函数信息; M, Y9 {8 D2 n% q8 Z' L! r
wcout.imbue(locale("chs")); //设置输出的locale为中文
* a! S' `1 P1 Q* ^# U
! T Q' F! i4 i- D' Z
ErrCode=LuCom(ForStr,0,0,0,hFor,nPara,pPara,ErrBegin,ErrEnd); //编译表达式4 w, X) L0 L& o) r# o; W7 j
if(ErrCode)
, t7 F4 e7 @% X) m3 N6 w
{ D: \+ j\\" S4 |9 a# p% X+ a
wcout<<L"表达式有错误！错误代码："<<ErrCode<<endl;) ]) [$ H- a0 f7 v3 C/ X
}. R% v. Z3 O+ G8 }7 O
else
7 {. U5 B0 N, V5 D) |3 E# e
{
5 p8 x7 J2 G' u& E3 p
LuCal(hFor,pPara); //计算表达式的值3 V5 n! b; }7 @9 r% Q) ]! E
}
LockKey(Matrix,NULL,OpMatrix);//解锁键Matrix，本例中，该函数可以不用
/ b. e% O7 \, F& C
FreeLu(); //释放Lu
' P# w i1 P# T7 b% o4 J
}

#include <windows.h>2 v8 z2 Y  k9 B) Z

#include <iostream> 
* K1 z7 m( [+ ?9 C7 N5 S
#include <math.h>( w4 U& A9 `; s5 s

#include "lu32.h" 
* K( t! v; x# ]
! m+ M) C! N7 Q, K

#pragma comment( lib, "lu32.lib" )\\" {3 \. b9 G8 T$ e6 a

, M- I& N2 h1 y5 ^' j

using namespace std;' \+ K; }' g! o5 |* Q& V\\" t/ ^. H

2 N# M0 l6 T& x) e/ _# E$ Z5 n* A
luKEY Matrix=-1000;        //标识矩阵类型，最终的Matrix由LockKey决定6 p6 B( d7 f: s

2 H- n3 U$ `: r\\" E) M
void _stdcall LuMessage(wchar_t *pch)//输出动态库信息，该函数注册到Lu，由Lu二级函数调用 
/ B. z9 K' S: B$ [$ ?. d
{ 
& O4 `! g0 o3 \+ E( }
        wcout<<pch; 
+ G6 h' t+ r4 H
}  P- t! O7 A\\" S3 B; S

void _stdcall DelMatrix(void *me)        //用于LockKey函数，因为是基于系统内置实数数组创建矩阵，故该函数什么也不做 
( n4 D' h2 J7 p( Q9 J9 f& h0 W
{6 d$ o4 k  L# K7 J' x

}9 O+ s/ h6 \% b0 y

LuData _stdcall OpMatrix(luINT mm,LuData *xx,void *hFor,int theOperator)        //运算符重载函数，用于LockKey函数+ X9 P9 o) W0 f# ~1 |

{ 
% Z9 X7 k/ S  J1 W$ V. o/ _+ F5 P
        LuData a; 
3 G: [0 ]: x5 O% T1 o5 S
        luRealArray *pRealArray1,*pRealArray2,*pRealArray3; 
+ m1 ?7 L6 L( F; F5 D
        luVOID i,j,k,m,n,u,v;5 V( [* R' u. z4 u. c

double *pa,*pb,*pc;9 G, P7 m) L1 Q4 t4 H0 M

luMessage pMessage;0 F) C\\" w' F8 b) V

wchar_t wchNum[32];: F5 E3 u9 s2 M. o0 x

char chNum[32];5 f7 [\\" r\\" \. `/ t

a.BType=luStaData_nil; a.VType=luStaData_nil; a.x=0; 
  m+ Y) T) y# R& e. U
        switch(theOperator)# C2 J* J- D( p, y

{ 
& d8 E2 W+ d* s
        case 2:        //重载运算符* 
+ K' u) X8 r) E/ `& \( Q
                pRealArray1=(luRealArray *)SearchKey((char *)&(xx->x),sizeof(luVOID),luDynData_realarray);3 X8 U7 [' a% J0 u  [9 w

pRealArray2=(luRealArray *)SearchKey((char *)&((xx+1)->x),sizeof(luVOID),luDynData_realarray); 
3 U8 f$ a% L: [) h( t% s5 p
                if(!pRealArray1 || !pRealArray2) break;        //对象句柄无效，不是实数数组* b& [' r9 x2 v: V+ \

if(pRealArray1->DimLen!=2 || pRealArray2->DimLen!=2) break;        //不是二维实数数组（矩阵） 
+ M/ \, D& K4 p5 l. v5 X- T
                if(pRealArray1->Dim[1]!=pRealArray2->Dim[0]) break;        //维数不匹配 
: S9 C: C1 F! |) J0 E1 z5 Q9 R
                pRealArray3=(luRealArray *)NewSysObj(luDynData_realarray,pRealArray1->Dim[0]*pRealArray2->Dim[1],2);        //创建矩阵对象& Z( V$ x9 W2 Z

if(!pRealArray3) break;* m$ ?; M8 B, X( x& Y

pRealArray3->Dim[0]=pRealArray1->Dim[0]; pRealArray3->Dim[1]=pRealArray2->Dim[1];        //设置矩阵维数大小 
! M8 ^3 B& B% z
                pa=pRealArray1->Array; pb=pRealArray2->Array; pc=pRealArray3->Array; 
, E2 l  p) M3 c  t
                m=pRealArray1->Dim[0]; n=pRealArray1->Dim[1]; k=pRealArray2->Dim[1]; 
% o3 C$ s# e* P1 ~
                for(i=0; i<m; i++)        //矩阵乘# l0 j- X: P4 M- V- _

{/ r8 L- A% L8 ?- A& G

for(j=0; j<k; j++)+ J# O5 E1 Y* C$ d: K

{ 
: x+ S0 s, a  j' E4 C) E  c7 a
                                u=i*k+j; pc[u]=0.0; 
8 m; t+ F. H. i
                                for (v=0; v<n; v++) 
$ _! ^0 S$ d/ }9 ^6 ?, L. u; l
                                {\\" ?& A, e5 F: g+ W* J

pc[u]=pc[u]+pa[i*n+v]*pb[v*k+j]; 
4 J% R. r2 f7 ~6 x3 k( F
                                } 
+ d1 f# R: N+ Y
                        } 
/ N! ]+ S( h* T% t- G4 }
                } 
) J( K0 ^; j: k, M. V0 E) ]1 I
                FunReObj(hFor);        //告诉Lu，返回一个动态对象 
& Y; Z' Y) U3 m1 }8 Y. M8 H
                a.BType=luDynData_realarray; a.VType=Matrix; a.x=0; *(luVOID *)&(a.x)=(luVOID)pRealArray3; 
' B9 J: o2 L2 k- {6 `6 l
                break;: A- w4 ~+ k5 f% m+ ]' L* D

case 25:        //重载运算符.*8 D+ F( d3 C, s5 A6 s( x

pRealArray1=(luRealArray *)SearchKey((char *)&(xx->x),sizeof(luVOID),luDynData_realarray);. q3 e, g/ L: S

pRealArray2=(luRealArray *)SearchKey((char *)&((xx+1)->x),sizeof(luVOID),luDynData_realarray); 
- m# K% n7 X- G+ O: d5 }8 i' s' d
                if(!pRealArray1 || !pRealArray2) break;        //对象句柄无效，不是实数数组8 I% T  O6 Y6 }+ i2 V

if(pRealArray1->DimLen!=2 || pRealArray2->DimLen!=2) break;        //不是二维实数数组（矩阵）7 n. b' U; a/ r% g

if(pRealArray1->Dim[0]!=pRealArray2->Dim[0] || pRealArray1->Dim[1]!=pRealArray2->Dim[1]) break;        //维数不相同. X- A- E* T; u\\" p4 e) P

pRealArray3=(luRealArray *)NewSysObj(luDynData_realarray,pRealArray1->ArrayLen,2);        //创建矩阵对象 
6 g( c+ C: a  [/ f
                if(!pRealArray3) break; 
7 [4 L\\" o7 l% l' [\\" H
                pRealArray3->Dim[0]=pRealArray1->Dim[0]; pRealArray3->Dim[1]=pRealArray1->Dim[1];        //设置矩阵维数大小. s7 N5 D- d+ B, e3 ]7 C

for(i=0;i<pRealArray1->ArrayLen;i++) pRealArray3->Array[i]=pRealArray1->Array[i]*pRealArray2->Array[i];//矩阵点乘 
$ Y6 l9 g; {& F( N
                FunReObj(hFor);        //告诉Lu，返回一个动态对象 
/ E  w7 S  [+ R. D( y9 a
                a.BType=luDynData_realarray; a.VType=Matrix; a.x=0; *(luVOID *)&(a.x)=(luVOID)pRealArray3;+ q1 _+ V' p( m

break; 
  X! a2 w$ ~\\" a) {! ]
        case 46:        //重载函数new% `6 C# _) T0 ?\\" ?& F; F\\" `; h

a=ExeOperator(mm,xx,hFor,theOperator,luDynData_realarray);        //直接调用基本类型luDynData_realarray的new函数) K/ Y; Y/ I\\" f! G

if(a.VType==luDynData_realarray) a.VType=Matrix;        //设置扩展类型为自定义的Matrix类型 
8 p2 ~. v6 c* V- n+ p
                break; 
5 L\\" O; u3 ~2 c, Z' b
        case 49:        //重载函数o% ?4 j* D* ^# j& n

pMessage=(luMessage)SearchKey("\0\0\0\0",sizeof(luVOID),luPubKey_User); 
+ s2 k0 x9 Y* \- I! R0 A; @
                if(!pMessage) break;3 O\\" N; C& v. U$ _0 H8 h

pRealArray1=(luRealArray *)SearchKey((char *)&(xx->x),sizeof(luVOID),luDynData_realarray);  v* O( U3 m8 X3 w9 J

if(!pRealArray1) break;        //对象句柄无效，不是实数数组 
5 [. a; q2 i, R# h8 N
                if(pRealArray1->DimLen!=2) break;        //不是二维实数数组（矩阵）6 x, h* t* s! n% c: o

pa=pRealArray1->Array; 
6 M2 l& E- f6 h. a9 D# k
                m=pRealArray1->Dim[0]; n=pRealArray1->Dim[1]; k=0;! Q9 ]( @+ @. ~* Y

for(i=0; i<m; i++)        //输出矩阵' @2 E5 Z6 d& F  f1 ]

{/ `6 a5 g7 Q6 r2 Y

pMessage(L"\r\n"); k+=2; 
; f$ G: Y( f\\" `# ~* Z- p+ N5 @
                        for(j=0; j<n; j++)4 E( p\\" g: u% R* X9 x9 F2 ?+ R+ f

{, S9 Y0 V/ g# _. G

_gcvt_s(chNum,pa[i*n+j],16); 
4 T* g, L1 Z& w
                                for(u=0;chNum[u];u++) {wchNum[u]=chNum[u]; k++;} 
5 }1 W$ a& r+ `
                                wchNum[u]='\0'; 
- `+ ]9 S* }7 R8 S6 B
                                pMessage(wchNum); pMessage(L"  "); k+=2;; [9 v1 z5 ]0 g% c0 T# l! ~# a8 {

} 
/ r, \\\" @0 W8 ^+ ]0 a
                }9 Z+ S' l3 ~! \& j  k$ e: K7 o/ R+ Z

pMessage(L"\r\n"); k+=2; 
, Z4 c, C+ l& A2 }
                a.BType=luStaData_int64; a.VType=luStaData_int64; a.x=k;        //按函数o的要求，返回输出的字符总数1 L- G$ Z; J/ h5 u* a( ]1 S

break;, j' Z6 [6 R8 x; I  n+ A

default:  s/ I* Y  o( r& l: t, d, m+ O: @. d

break; 
7 F5 I  V/ l2 w5 m! k2 @9 P
        }7 X( e# O4 q& m. M+ X6 a

return a;3 Y  Q. Q! d2 e1 x6 T

}2 c) t) T  X; H

void main(void)* K: z\\" W6 H# B4 f2 _  Y

{ 
1 H/ \5 j9 j: A9 o: ?4 M
        void *hFor;                //表达式句柄 
1 x0 m+ t+ |' }  P. ?0 [\\" a3 f% h
        luINT nPara;                //存放表达式的自变量个数 
* o. ?  y6 k\\" P9 a# q  }' h
        LuData *pPara;                //存放输入自变量的数组指针2 X/ j$ e6 p4 c: |

luINT ErrBegin,ErrEnd;        //表达式编译出错的初始位置和结束位置 
* X& ^& r5 f+ ~  q\\" L
        int ErrCode;                //错误代码 
- n% @, ?# z/ ^- u
        void *v;. c4 m0 K: C8 n/ z/ G+ 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.]}";//字符串表达式，矩阵乘 
- _5 e2 x! A3 [  m
        //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.]}";//字符串表达式，矩阵点乘& `. I! H* [4 q

LuData Val; 
8 N% K/ `5 Q! |+ y) s0 l
        if(!InitLu()) return;        //初始化Lu 
1 S7 P. Q; R0 l
        while(LockKey(Matrix,DelMatrix,OpMatrix)){Matrix++;}        //锁定一个键，用于存储矩阵扩展类型 
7 ~\\" X8 h( n$ W: d% l
 
0 K  d0 F. d3 u' i8 d! {* E
        Val.BType=luStaData_int64; Val.VType=luStaData_int64; Val.x=Matrix;        //定义整数常量  x- @2 n' D, N; P3 i

SetConst(L"matrix",&Val);        //设置整数常量  [* T3 G3 c' t7 a

InsertKey("\0\0\0\0",4,luPubKey_User,LuMessage,NULL,NULL,1,v); //使Lu运行时可输出函数信息; M, Y9 {8 D2 n% q8 Z' L! r

wcout.imbue(locale("chs"));        //设置输出的locale为中文 
* a! S' `1 P1 Q* ^# U
   
! T  Q' F! i4 i- D' Z
        ErrCode=LuCom(ForStr,0,0,0,hFor,nPara,pPara,ErrBegin,ErrEnd); //编译表达式4 w, X) L0 L& o) r# o; W7 j

if(ErrCode) 
, t7 F4 e7 @% X) m3 N6 w
        {  D: \+ j\\" S4 |9 a# p% X+ a

wcout<<L"表达式有错误！错误代码："<<ErrCode<<endl;) ]) [$ H- a0 f7 v3 C/ X

}. R% v. Z3 O+ G8 }7 O

else 
7 {. U5 B0 N, V5 D) |3 E# e
        { 
5 p8 x7 J2 G' u& E3 p
                LuCal(hFor,pPara);        //计算表达式的值3 V5 n! b; }7 @9 r% Q) ]! E

} 
; p1 n  J& c/ E/ G* ^( ^( R$ ]2 {% k* D
        LockKey(Matrix,NULL,OpMatrix);//解锁键Matrix，本例中，该函数可以不用 
/ b. e% O7 \, F& C
        FreeLu();                        //释放Lu 
' P# w  i1 P# T7 b% o4 J
}

习题：

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

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

main(:a,b,c,d,t,i)=
4 E ?( ?+ Z, s4 L. H
a=new[matrix,2,2,data:1.,2.,2.,1.],
- t- S7 \+ s; t, x) A
b=new[matrix,2,2,data:2.,1.,1.,2.],$ q& A/ q2 q7 _ ^0 K% J; C
c=new[matrix,2,2,data:2/3.,-1/3.,-1/3.,2/3.],4 E( r+ e* m- R6 M$ C% U4 G- a# Q
t=clock(),
' |# u' s7 t# s$ X* V
d=a*b, i=0, while{i<1000000, d=d*c*b, i++},$ s. j$ P) J: y: i7 u& I5 u
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\"}";//字符串表达式

复制代码

结果：