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

查看: 8522|回复: 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>
; [; h; \2 C6 x* K; v
#include <iostream>: ~6 x\\" }# B d7 a; F
#include <math.h>
5 c: X4 o- r+ i5 z: o' S ?9 t& K
#include "lu32.h"
+ N4 V9 J0 ?- L- P
8 z& j' O9 L [1 \ ^
#pragma comment( lib, "lu32.lib" )
; k4 |9 n- s' m2 r( D; t1 _
5 N) w/ O2 ~/ U: s
using namespace std;
4 p& a, `* U$ l2 j5 S/ e7 w' r5 z6 |
- ~\\" S) t' x\\" I! d% A ]
luKEY Matrix=-1000; //标识矩阵类型，最终的Matrix由LockKey决定
5 |+ B1 X: f8 G1 F$ n
# w, d: n& T# Q% ]1 M0 O# H9 L: F
void _stdcall LuMessage(wchar_t *pch)//输出动态库信息，该函数注册到Lu，由Lu二级函数调用
4 H6 ~# o. u) _4 l3 o
{
3 ]2 Z' R7 S6 I0 A0 ~
wcout<<pch;
4 q' e+ Z\\" A9 M9 Y0 r1 V. F
}0 }5 m4 c/ O( N8 ^5 Z5 \. A# a
void _stdcall DelMatrix(void *me) //用于LockKey函数，因为是基于系统内置实数数组创建矩阵，故该函数什么也不做
$ A! C8 F: c% a; p9 y
{
0 [0 |3 |: O: W. W4 L/ i4 R
} n. ]2 F' U$ ~! N5 q0 ~# Z
LuData _stdcall OpMatrix(luINT mm,LuData *xx,void *hFor,int theOperator) //运算符重载函数，用于LockKey函数
\\" C0 ^! M6 f' o/ N, K9 k
{. T* }6 B8 A3 h+ c; P+ b
LuData a;6 `) t0 m( W& U1 s+ b# A
luRealArray *pRealArray1,*pRealArray2,*pRealArray3;
. g3 C; A% K\\" k) m
luVOID i,j,k,m,n,u,v;& u9 Y! Q% \6 q! y\\" g0 u; V: ?
double *pa,*pb,*pc;9 }6 c1 ]: ~- @$ \1 _
luMessage pMessage;
! O2 [4 s8 ~2 O
wchar_t wchNum[32];' ~- x7 y% Y- O+ e
char chNum[32];
) y! t3 o- L: k' W$ m8 }) D
a.BType=luStaData_nil; a.VType=luStaData_nil; a.x=0;
; b+ w F# b% X\\" _( g0 [% x5 B
switch(theOperator)
$ E# A% e, t2 B3 j5 t
{: v X# [5 H) ]9 ^4 U4 @\\" `% o: F
case 2: //重载运算符*
$ G1 H0 t6 v8 W+ E. `- v
pRealArray1=(luRealArray *)SearchKey((char *)&(xx->x),sizeof(luVOID),luDynData_realarray);: F1 U0 z: n- J+ \* `; \6 A/ ?
pRealArray2=(luRealArray *)SearchKey((char *)&((xx+1)->x),sizeof(luVOID),luDynData_realarray);; _+ `* x: p5 r4 y+ B9 V7 m
if(!pRealArray1 || !pRealArray2) break; //对象句柄无效，不是实数数组\\" p* |- X& Q. R) g
if(pRealArray1->DimLen!=2 || pRealArray2->DimLen!=2) break; //不是二维实数数组（矩阵）\\" i\\" F( W! o0 v% L& c. q( b
if(pRealArray1->Dim[1]!=pRealArray2->Dim[0]) break; //维数不匹配
' A# q9 M5 p- J! A! \
pRealArray3=(luRealArray *)NewSysObj(luDynData_realarray,pRealArray1->Dim[0]*pRealArray2->Dim[1],2); //创建矩阵对象 Q6 h) ]1 V( e8 F
if(!pRealArray3) break; P* g6 o8 M7 N* V
pRealArray3->Dim[0]=pRealArray1->Dim[0]; pRealArray3->Dim[1]=pRealArray2->Dim[1]; //设置矩阵维数大小* z( [\\" p: S& ]( B; h/ v\\" I
pa=pRealArray1->Array; pb=pRealArray2->Array; pc=pRealArray3->Array;% W, W8 N4 Y; W2 f% W9 R/ @4 O$ H
m=pRealArray1->Dim[0]; n=pRealArray1->Dim[1]; k=pRealArray2->Dim[1];( O% m R L& x5 L0 j& P
for(i=0; i<m; i++) //矩阵乘
; x\\" F) {/ u4 C( K! y, b8 o+ ~
{
- ~; T2 j$ n/ j
for(j=0; j<k; j++)5 x J/ I3 ?. O( u& }8 m9 r/ ?! P
{
' m- T& Q9 [: R2 ~
u=i*k+j; pc[u]=0.0;\\" ~6 D& y; u! }) x( w3 j
for (v=0; v<n; v++)8 b3 E0 \( X7 O4 A
{
8 E$ ]) m/ c9 I; e$ a# W! T) G
pc[u]=pc[u]+pa[i*n+v]*pb[v*k+j];1 Y7 f9 k; t+ K6 a! ~
}
/ F& { a* Q& r7 O) T0 N
}+ I* O3 ^) Z9 _( e& [' k. x, O
} A: {1 D1 T5 }2 P7 f8 C8 m& _; S
FunReObj(hFor); //告诉Lu，返回一个动态对象0 X! [6 D: k+ b9 {5 w# r, A2 t
a.BType=luDynData_realarray; a.VType=Matrix; a.x=0; *(luVOID *)&(a.x)=(luVOID)pRealArray3;! ~9 U9 `7 A1 }. g' C! Q
break;
. ?. }6 j# l( b
case 25: //重载运算符.*6 X3 I+ |3 F9 d. }1 _8 \
pRealArray1=(luRealArray *)SearchKey((char *)&(xx->x),sizeof(luVOID),luDynData_realarray);
( k- Q5 c# r7 _
pRealArray2=(luRealArray *)SearchKey((char *)&((xx+1)->x),sizeof(luVOID),luDynData_realarray);
6 y) P2 N0 `' `1 b* C1 t/ w
if(!pRealArray1 || !pRealArray2) break; //对象句柄无效，不是实数数组
\\" b2 W( B. @9 J; `
if(pRealArray1->DimLen!=2 || pRealArray2->DimLen!=2) break; //不是二维实数数组（矩阵）
1 N; A' t; U* u+ p
if(pRealArray1->Dim[0]!=pRealArray2->Dim[0] || pRealArray1->Dim[1]!=pRealArray2->Dim[1]) break; //维数不相同9 p% [9 X7 ^. K! A1 j- s+ O
pRealArray3=(luRealArray *)NewSysObj(luDynData_realarray,pRealArray1->ArrayLen,2); //创建矩阵对象0 l8 c; F* r& F' e3 ~! G' g
if(!pRealArray3) break;
0 B- i\\" |' b- ^0 X
pRealArray3->Dim[0]=pRealArray1->Dim[0]; pRealArray3->Dim[1]=pRealArray1->Dim[1]; //设置矩阵维数大小
* j\\" Z8 v' _# J7 S3 C
for(i=0;i<pRealArray1->ArrayLen;i++) pRealArray3->Array[i]=pRealArray1->Array[i]*pRealArray2->Array[i];//矩阵点乘
3 o\\" k1 _- a8 | `
FunReObj(hFor); //告诉Lu，返回一个动态对象% [1 v8 t2 F7 M- [' v f' ]- M
a.BType=luDynData_realarray; a.VType=Matrix; a.x=0; *(luVOID *)&(a.x)=(luVOID)pRealArray3;4 D6 _* j( ?+ b
break;
/ |% `% q3 ]8 f3 ]\\" F
case 46: //重载函数new
0 o2 |( ^% B$ C# P# h; x/ y
a=ExeOperator(mm,xx,hFor,theOperator,luDynData_realarray); //直接调用基本类型luDynData_realarray的new函数( m- i* u& E4 C; G: s8 Z
if(a.VType==luDynData_realarray) a.VType=Matrix; //设置扩展类型为自定义的Matrix类型2 y7 X. W- @& l/ A
break;+ D2 m6 y ]6 V% Q8 j: D
case 49: //重载函数o
. @4 w2 F: f. @
pMessage=(luMessage)SearchKey("\0\0\0\0",sizeof(luVOID),luPubKey_User);$ a2 k# z0 _6 o; R7 P5 Y8 @# _
if(!pMessage) break;
1 m; A% n( t6 f1 k* r- T2 |3 e
pRealArray1=(luRealArray *)SearchKey((char *)&(xx->x),sizeof(luVOID),luDynData_realarray);
. u* |% M* s# c7 b7 w
if(!pRealArray1) break; //对象句柄无效，不是实数数组
' C! I5 c& Y3 q1 ~% X/ q7 |, v
if(pRealArray1->DimLen!=2) break; //不是二维实数数组（矩阵）
/ U4 }% a: X) K! a% T I+ t
pa=pRealArray1->Array;
0 [+ Y' C+ w# m& _* O8 i, l
m=pRealArray1->Dim[0]; n=pRealArray1->Dim[1]; k=0;
% J/ ^7 |5 ]3 j. ~7 X; @, T& I( p
for(i=0; i<m; i++) //输出矩阵6 |+ n) B3 Z/ ]! y0 Z
{
; i2 j\\" m2 i/ |* Z8 e* l6 V
pMessage(L"\r\n"); k+=2;
1 I2 _6 y9 {5 E5 E, z1 }* S9 S; A
for(j=0; j<n; j++)
$ s( S3 e. P! Y- Z3 i. ~
{% o( b# [; @; ^3 z0 s+ p, `3 m
_gcvt_s(chNum,pa[i*n+j],16);9 w2 \% R, m- b/ D4 q& x4 r
for(u=0;chNum[u];u++) {wchNum[u]=chNum[u]; k++;}; u) r7 r- _9 D p |
wchNum[u]='\0';
I& N* L0 a, D* Z3 Q7 _% v# Q
pMessage(wchNum); pMessage(L" "); k+=2;
0 u7 h9 h& a, M/ }
}$ u: e2 L0 M- z' v) D& L& @9 a+ j4 {
}
. ?2 p& \2 S- B3 D1 t/ ~2 [4 c( d
pMessage(L"\r\n"); k+=2;
; v: H) X- C; d- n. ?
a.BType=luStaData_int64; a.VType=luStaData_int64; a.x=k; //按函数o的要求，返回输出的字符总数! j4 U4 N8 Q3 X. g8 P\\" J
break;
0 z/ Q1 e8 I0 q+ C9 V) q
default:
: b4 a( Q6 P9 F1 S: v
break;2 Y K* m$ M7 t' p! }\\" @
}
3 k) A. G9 R$ D4 k, }) h$ Y- A4 j
return a; i- W& x& \( M) D
}
) b5 n; `4 E+ I( [8 J: h
void main(void)) G( `, b( h* f y7 y, A4 A! u
{1 l; J: }0 V8 N! j& P' _
void *hFor; //表达式句柄) } _% l+ m+ F0 m
luINT nPara; //存放表达式的自变量个数
2 C7 ~4 e8 v% K1 F
LuData *pPara; //存放输入自变量的数组指针\\" c3 o( X: d. ^( u1 j
luINT ErrBegin,ErrEnd; //表达式编译出错的初始位置和结束位置, [' z\\" U/ ^- ]4 |7 p1 E
int ErrCode; //错误代码
; p) w, }4 k4 C/ R: }
void *v;1 R% W0 E, Y+ {# F1 {
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.]}";//字符串表达式，矩阵乘
2 g: {. k/ B' O! u+ W+ [7 \
//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.]}";//字符串表达式，矩阵点乘
# D8 {- j# l* T K' ]1 [
LuData Val;
) x. B\\" K- E0 L3 k
if(!InitLu()) return; //初始化Lu
1 l2 {+ p0 r! N* N% W
while(LockKey(Matrix,DelMatrix,OpMatrix)){Matrix++;} //锁定一个键，用于存储矩阵扩展类型0 J% {! L4 D& C. S6 `
' ]/ z( j5 Y+ ^% v
Val.BType=luStaData_int64; Val.VType=luStaData_int64; Val.x=Matrix; //定义整数常量9 S0 T- ?% b! k: E* ?: e! i
SetConst(L"matrix",&Val); //设置整数常量+ n0 U$ \4 @% T5 H8 b7 G
InsertKey("\0\0\0\0",4,luPubKey_User,LuMessage,NULL,NULL,1,v); //使Lu运行时可输出函数信息
% W! _- W4 l ~' d# p\\" A
wcout.imbue(locale("chs")); //设置输出的locale为中文
1 Z- P% f3 K8 J
, E1 y/ Z2 _/ O2 f- {. [
ErrCode=LuCom(ForStr,0,0,0,hFor,nPara,pPara,ErrBegin,ErrEnd); //编译表达式) I) r; c o( K# M\\" A- Q: a. x5 i3 b) R$ j
if(ErrCode)
! J$ D5 s3 ?\\" ]1 g0 X/ |% S
{
) W9 h* h6 o1 o5 p5 A+ A( {& y
wcout<<L"表达式有错误！错误代码："<<ErrCode<<endl;
) |/ B$ l+ Z5 E+ p; M' ~0 H+ ^
}' u* z) B& ~; H) w
else' k/ e( k3 P' e\\" x% [1 C
{9 v8 F) |, _$ C* h m
LuCal(hFor,pPara); //计算表达式的值, e& ], ?& j/ y5 e3 x
}3 l+ V; a2 F0 ^+ D# l* T* H
LockKey(Matrix,NULL,OpMatrix);//解锁键Matrix，本例中，该函数可以不用3 h$ @; Z7 l$ h+ a J3 J% y
FreeLu(); //释放Lu6 ^6 p5 k b3 ~- j E) l: b
}

#include <windows.h> 
; [; h; \2 C6 x* K; v
#include <iostream>: ~6 x\\" }# B  d7 a; F

#include <math.h> 
5 c: X4 o- r+ i5 z: o' S  ?9 t& K
#include "lu32.h" 
+ N4 V9 J0 ?- L- P
8 z& j' O9 L  [1 \  ^

#pragma comment( lib, "lu32.lib" ) 
; k4 |9 n- s' m2 r( D; t1 _
5 N) w/ O2 ~/ U: s

using namespace std; 
4 p& a, `* U$ l2 j5 S/ e7 w' r5 z6 |
 
- ~\\" S) t' x\\" I! d% A  ]
luKEY Matrix=-1000;        //标识矩阵类型，最终的Matrix由LockKey决定 
5 |+ B1 X: f8 G1 F$ n
 
# w, d: n& T# Q% ]1 M0 O# H9 L: F
void _stdcall LuMessage(wchar_t *pch)//输出动态库信息，该函数注册到Lu，由Lu二级函数调用 
4 H6 ~# o. u) _4 l3 o
{ 
3 ]2 Z' R7 S6 I0 A0 ~
        wcout<<pch; 
4 q' e+ Z\\" A9 M9 Y0 r1 V. F
}0 }5 m4 c/ O( N8 ^5 Z5 \. A# a

void _stdcall DelMatrix(void *me)        //用于LockKey函数，因为是基于系统内置实数数组创建矩阵，故该函数什么也不做 
$ A! C8 F: c% a; p9 y
{ 
0 [0 |3 |: O: W. W4 L/ i4 R
}  n. ]2 F' U$ ~! N5 q0 ~# Z

LuData _stdcall OpMatrix(luINT mm,LuData *xx,void *hFor,int theOperator)        //运算符重载函数，用于LockKey函数 
\\" C0 ^! M6 f' o/ N, K9 k
{. T* }6 B8 A3 h+ c; P+ b

LuData a;6 `) t0 m( W& U1 s+ b# A

luRealArray *pRealArray1,*pRealArray2,*pRealArray3; 
. g3 C; A% K\\" k) m
        luVOID i,j,k,m,n,u,v;& u9 Y! Q% \6 q! y\\" g0 u; V: ?

double *pa,*pb,*pc;9 }6 c1 ]: ~- @$ \1 _

luMessage pMessage; 
! O2 [4 s8 ~2 O
        wchar_t wchNum[32];' ~- x7 y% Y- O+ e

char chNum[32]; 
) y! t3 o- L: k' W$ m8 }) D
        a.BType=luStaData_nil; a.VType=luStaData_nil; a.x=0; 
; b+ w  F# b% X\\" _( g0 [% x5 B
        switch(theOperator) 
$ E# A% e, t2 B3 j5 t
        {: v  X# [5 H) ]9 ^4 U4 @\\" `% o: F

case 2:        //重载运算符* 
$ G1 H0 t6 v8 W+ E. `- v
                pRealArray1=(luRealArray *)SearchKey((char *)&(xx->x),sizeof(luVOID),luDynData_realarray);: F1 U0 z: n- J+ \* `; \6 A/ ?

pRealArray2=(luRealArray *)SearchKey((char *)&((xx+1)->x),sizeof(luVOID),luDynData_realarray);; _+ `* x: p5 r4 y+ B9 V7 m

if(!pRealArray1 || !pRealArray2) break;        //对象句柄无效，不是实数数组\\" p* |- X& Q. R) g

if(pRealArray1->DimLen!=2 || pRealArray2->DimLen!=2) break;        //不是二维实数数组（矩阵）\\" i\\" F( W! o0 v% L& c. q( b

if(pRealArray1->Dim[1]!=pRealArray2->Dim[0]) break;        //维数不匹配 
' A# q9 M5 p- J! A! \
                pRealArray3=(luRealArray *)NewSysObj(luDynData_realarray,pRealArray1->Dim[0]*pRealArray2->Dim[1],2);        //创建矩阵对象  Q6 h) ]1 V( e8 F

if(!pRealArray3) break;  P* g6 o8 M7 N* V

pRealArray3->Dim[0]=pRealArray1->Dim[0]; pRealArray3->Dim[1]=pRealArray2->Dim[1];        //设置矩阵维数大小* z( [\\" p: S& ]( B; h/ v\\" I

pa=pRealArray1->Array; pb=pRealArray2->Array; pc=pRealArray3->Array;% W, W8 N4 Y; W2 f% W9 R/ @4 O$ H

m=pRealArray1->Dim[0]; n=pRealArray1->Dim[1]; k=pRealArray2->Dim[1];( O% m  R  L& x5 L0 j& P

for(i=0; i<m; i++)        //矩阵乘 
; x\\" F) {/ u4 C( K! y, b8 o+ ~
                { 
- ~; T2 j$ n/ j
                        for(j=0; j<k; j++)5 x  J/ I3 ?. O( u& }8 m9 r/ ?! P

{ 
' m- T& Q9 [: R2 ~
                                u=i*k+j; pc[u]=0.0;\\" ~6 D& y; u! }) x( w3 j

for (v=0; v<n; v++)8 b3 E0 \( X7 O4 A

{ 
8 E$ ]) m/ c9 I; e$ a# W! T) G
                                        pc[u]=pc[u]+pa[i*n+v]*pb[v*k+j];1 Y7 f9 k; t+ K6 a! ~

} 
/ F& {  a* Q& r7 O) T0 N
                        }+ I* O3 ^) Z9 _( e& [' k. x, O

}  A: {1 D1 T5 }2 P7 f8 C8 m& _; S

FunReObj(hFor);        //告诉Lu，返回一个动态对象0 X! [6 D: k+ b9 {5 w# r, A2 t

a.BType=luDynData_realarray; a.VType=Matrix; a.x=0; *(luVOID *)&(a.x)=(luVOID)pRealArray3;! ~9 U9 `7 A1 }. g' C! Q

break; 
. ?. }6 j# l( b
        case 25:        //重载运算符.*6 X3 I+ |3 F9 d. }1 _8 \

pRealArray1=(luRealArray *)SearchKey((char *)&(xx->x),sizeof(luVOID),luDynData_realarray); 
( k- Q5 c# r7 _
                pRealArray2=(luRealArray *)SearchKey((char *)&((xx+1)->x),sizeof(luVOID),luDynData_realarray); 
6 y) P2 N0 `' `1 b* C1 t/ w
                if(!pRealArray1 || !pRealArray2) break;        //对象句柄无效，不是实数数组 
\\" b2 W( B. @9 J; `
                if(pRealArray1->DimLen!=2 || pRealArray2->DimLen!=2) break;        //不是二维实数数组（矩阵） 
1 N; A' t; U* u+ p
                if(pRealArray1->Dim[0]!=pRealArray2->Dim[0] || pRealArray1->Dim[1]!=pRealArray2->Dim[1]) break;        //维数不相同9 p% [9 X7 ^. K! A1 j- s+ O

pRealArray3=(luRealArray *)NewSysObj(luDynData_realarray,pRealArray1->ArrayLen,2);        //创建矩阵对象0 l8 c; F* r& F' e3 ~! G' g

if(!pRealArray3) break; 
0 B- i\\" |' b- ^0 X
                pRealArray3->Dim[0]=pRealArray1->Dim[0]; pRealArray3->Dim[1]=pRealArray1->Dim[1];        //设置矩阵维数大小 
* j\\" Z8 v' _# J7 S3 C
                for(i=0;i<pRealArray1->ArrayLen;i++) pRealArray3->Array[i]=pRealArray1->Array[i]*pRealArray2->Array[i];//矩阵点乘 
3 o\\" k1 _- a8 |  `
                FunReObj(hFor);        //告诉Lu，返回一个动态对象% [1 v8 t2 F7 M- [' v  f' ]- M

a.BType=luDynData_realarray; a.VType=Matrix; a.x=0; *(luVOID *)&(a.x)=(luVOID)pRealArray3;4 D6 _* j( ?+ b

break; 
/ |% `% q3 ]8 f3 ]\\" F
        case 46:        //重载函数new 
0 o2 |( ^% B$ C# P# h; x/ y
                a=ExeOperator(mm,xx,hFor,theOperator,luDynData_realarray);        //直接调用基本类型luDynData_realarray的new函数( m- i* u& E4 C; G: s8 Z

if(a.VType==luDynData_realarray) a.VType=Matrix;        //设置扩展类型为自定义的Matrix类型2 y7 X. W- @& l/ A

break;+ D2 m6 y  ]6 V% Q8 j: D

case 49:        //重载函数o 
. @4 w2 F: f. @
                pMessage=(luMessage)SearchKey("\0\0\0\0",sizeof(luVOID),luPubKey_User);$ a2 k# z0 _6 o; R7 P5 Y8 @# _

if(!pMessage) break; 
1 m; A% n( t6 f1 k* r- T2 |3 e
                pRealArray1=(luRealArray *)SearchKey((char *)&(xx->x),sizeof(luVOID),luDynData_realarray); 
. u* |% M* s# c7 b7 w
                if(!pRealArray1) break;        //对象句柄无效，不是实数数组 
' C! I5 c& Y3 q1 ~% X/ q7 |, v
                if(pRealArray1->DimLen!=2) break;        //不是二维实数数组（矩阵） 
/ U4 }% a: X) K! a% T  I+ t
                pa=pRealArray1->Array; 
0 [+ Y' C+ w# m& _* O8 i, l
                m=pRealArray1->Dim[0]; n=pRealArray1->Dim[1]; k=0; 
% J/ ^7 |5 ]3 j. ~7 X; @, T& I( p
                for(i=0; i<m; i++)        //输出矩阵6 |+ n) B3 Z/ ]! y0 Z

{ 
; i2 j\\" m2 i/ |* Z8 e* l6 V
                        pMessage(L"\r\n"); k+=2; 
1 I2 _6 y9 {5 E5 E, z1 }* S9 S; A
                        for(j=0; j<n; j++) 
$ s( S3 e. P! Y- Z3 i. ~
                        {% o( b# [; @; ^3 z0 s+ p, `3 m

_gcvt_s(chNum,pa[i*n+j],16);9 w2 \% R, m- b/ D4 q& x4 r

for(u=0;chNum[u];u++) {wchNum[u]=chNum[u]; k++;}; u) r7 r- _9 D  p  |

wchNum[u]='\0'; 
  I& N* L0 a, D* Z3 Q7 _% v# Q
                                pMessage(wchNum); pMessage(L"  "); k+=2; 
0 u7 h9 h& a, M/ }
                        }$ u: e2 L0 M- z' v) D& L& @9 a+ j4 {

} 
. ?2 p& \2 S- B3 D1 t/ ~2 [4 c( d
                pMessage(L"\r\n"); k+=2; 
; v: H) X- C; d- n. ?
                a.BType=luStaData_int64; a.VType=luStaData_int64; a.x=k;        //按函数o的要求，返回输出的字符总数! j4 U4 N8 Q3 X. g8 P\\" J

break; 
0 z/ Q1 e8 I0 q+ C9 V) q
        default: 
: b4 a( Q6 P9 F1 S: v
                break;2 Y  K* m$ M7 t' p! }\\" @

} 
3 k) A. G9 R$ D4 k, }) h$ Y- A4 j
        return a;  i- W& x& \( M) D

} 
) b5 n; `4 E+ I( [8 J: h
void main(void)) G( `, b( h* f  y7 y, A4 A! u

{1 l; J: }0 V8 N! j& P' _

void *hFor;                //表达式句柄) }  _% l+ m+ F0 m

luINT nPara;                //存放表达式的自变量个数 
2 C7 ~4 e8 v% K1 F
        LuData *pPara;                //存放输入自变量的数组指针\\" c3 o( X: d. ^( u1 j

luINT ErrBegin,ErrEnd;        //表达式编译出错的初始位置和结束位置, [' z\\" U/ ^- ]4 |7 p1 E

int ErrCode;                //错误代码 
; p) w, }4 k4 C/ R: }
        void *v;1 R% W0 E, Y+ {# F1 {

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.]}";//字符串表达式，矩阵乘 
2 g: {. k/ B' O! u+ W+ [7 \
        //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.]}";//字符串表达式，矩阵点乘 
# D8 {- j# l* T  K' ]1 [
        LuData Val; 
) x. B\\" K- E0 L3 k
        if(!InitLu()) return;        //初始化Lu 
1 l2 {+ p0 r! N* N% W
        while(LockKey(Matrix,DelMatrix,OpMatrix)){Matrix++;}        //锁定一个键，用于存储矩阵扩展类型0 J% {! L4 D& C. S6 `

' ]/ z( j5 Y+ ^% v
        Val.BType=luStaData_int64; Val.VType=luStaData_int64; Val.x=Matrix;        //定义整数常量9 S0 T- ?% b! k: E* ?: e! i

SetConst(L"matrix",&Val);        //设置整数常量+ n0 U$ \4 @% T5 H8 b7 G

InsertKey("\0\0\0\0",4,luPubKey_User,LuMessage,NULL,NULL,1,v); //使Lu运行时可输出函数信息 
% W! _- W4 l  ~' d# p\\" A
        wcout.imbue(locale("chs"));        //设置输出的locale为中文 
1 Z- P% f3 K8 J
  , E1 y/ Z2 _/ O2 f- {. [

ErrCode=LuCom(ForStr,0,0,0,hFor,nPara,pPara,ErrBegin,ErrEnd); //编译表达式) I) r; c  o( K# M\\" A- Q: a. x5 i3 b) R$ j

if(ErrCode) 
! J$ D5 s3 ?\\" ]1 g0 X/ |% S
        { 
) W9 h* h6 o1 o5 p5 A+ A( {& y
                wcout<<L"表达式有错误！错误代码："<<ErrCode<<endl; 
) |/ B$ l+ Z5 E+ p; M' ~0 H+ ^
        }' u* z) B& ~; H) w

else' k/ e( k3 P' e\\" x% [1 C

{9 v8 F) |, _$ C* h  m

LuCal(hFor,pPara);        //计算表达式的值, e& ], ?& j/ y5 e3 x

}3 l+ V; a2 F0 ^+ D# l* T* H

LockKey(Matrix,NULL,OpMatrix);//解锁键Matrix，本例中，该函数可以不用3 h$ @; Z7 l$ h+ a  J3 J% y

FreeLu();                        //释放Lu6 ^6 p5 k  b3 ~- j  E) l: b

}

习题：

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

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

main(:a,b,c,d,t,i)=! N$ a) f$ x7 z; X6 l
a=new[matrix,2,2,data:1.,2.,2.,1.],
\" S y* y4 B/ Y5 c
b=new[matrix,2,2,data:2.,1.,1.,2.],
! P! S9 h$ z0 N
c=new[matrix,2,2,data:2/3.,-1/3.,-1/3.,2/3.],9 R! ~8 Z+ y( Y% X: H
t=clock(),
, x% r+ J( G! K! b2 w
d=a*b, i=0, while{i<1000000, d=d*c*b, i++},; w$ I3 \1 l7 ~' F) w
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\"}";//字符串表达式

复制代码

结果：