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

查看: 8906|回复: 0

Lu基于系统内置对象创建扩展数据类型，小矩阵乘效率测试

[复制链接]

字体大小: 正常放大

forcal

45 主题	3 听众	282 积分

升级 91%

TA的每日心情

	难过 2012-8-27 18:22

签到天数: 1 天

[LV.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>: ~- m% E\\" @9 f; K6 [
#include <iostream>4 j- y( [+ |7 K% i
#include <math.h>
5 c, d# g! j! d4 Z* u
#include "lu32.h"
4 a- o& _# m& \0 X! Q/ N2 g
6 B0 ?\\" Q- O, E
#pragma comment( lib, "lu32.lib" )
5 g5 w! V/ X\\" I4 S) r7 B
# i4 h2 ~9 h, {! R: H: y% s9 d# A
using namespace std;6 ^5 A) P& R: @- }2 P& i6 M
8 P( ~+ Q\\" n( g/ E+ W( ?! G
luKEY Matrix=-1000; //标识矩阵类型，最终的Matrix由LockKey决定
* x; b( Q9 d7 s% A: ~- }
5 o' F+ Y; y. {. F* J: x& X
void _stdcall LuMessage(wchar_t *pch)//输出动态库信息，该函数注册到Lu，由Lu二级函数调用 ' X\\" \2 K4 Y9 j7 Z. _' ?; L
{
8 \3 L4 h1 x) j0 ? H8 W
wcout<<pch;+ V* F: U* u( c/ O' Y% o7 O( c
}
( h# D, }\\" h\\" ~9 b
void _stdcall DelMatrix(void *me) //用于LockKey函数，因为是基于系统内置实数数组创建矩阵，故该函数什么也不做 `/ O/ _! L5 Q/ E$ c8 J0 ~
{
\\" Q+ x& k7 p9 u2 e' E1 G3 X3 R
}
9 \# g* |( J4 ]( B) |9 t
LuData _stdcall OpMatrix(luINT mm,LuData *xx,void *hFor,int theOperator) //运算符重载函数，用于LockKey函数
7 y! L# o$ ?7 B
{
2 Y! E. U' R& B+ r& e5 V' |
LuData a;
# C, J5 |& H% @
luRealArray *pRealArray1,*pRealArray2,*pRealArray3;
; p. V) L; X8 x
luVOID i,j,k,m,n,u,v;
9 n: W, e+ E$ l3 ^7 G* ~5 a0 D
double *pa,*pb,*pc;
) t* L, i, s) S) q
luMessage pMessage;
wchar_t wchNum[32];* {/ W1 M& U! s$ z+ T5 A. s
char chNum[32];' y5 d4 y\\" C) q
a.BType=luStaData_nil; a.VType=luStaData_nil; a.x=0;6 C X/ x h) B' j6 a% u6 @1 b
switch(theOperator); Z' _) z$ M( K5 g
{! P+ o6 e9 M T! [! U
case 2: //重载运算符*
. ]( [+ }& i& k
pRealArray1=(luRealArray *)SearchKey((char *)&(xx->x),sizeof(luVOID),luDynData_realarray);* N* |6 c' Y/ ]4 E- {) b6 o7 a
pRealArray2=(luRealArray *)SearchKey((char *)&((xx+1)->x),sizeof(luVOID),luDynData_realarray); K( E+ W% {2 m3 v
if(!pRealArray1 || !pRealArray2) break; //对象句柄无效，不是实数数组
3 Q% s# P& H2 j# x
if(pRealArray1->DimLen!=2 || pRealArray2->DimLen!=2) break; //不是二维实数数组（矩阵）
3 O8 M* f* e7 E' A& i, q/ R5 \
if(pRealArray1->Dim[1]!=pRealArray2->Dim[0]) break; //维数不匹配) u- ^: y0 B# H8 a0 ?
pRealArray3=(luRealArray *)NewSysObj(luDynData_realarray,pRealArray1->Dim[0]*pRealArray2->Dim[1],2); //创建矩阵对象0 B1 v: F# z\\" [( s: N8 {$ \ H
if(!pRealArray3) break;
7 a4 Y1 P6 l( n; V3 I3 T/ D
pRealArray3->Dim[0]=pRealArray1->Dim[0]; pRealArray3->Dim[1]=pRealArray2->Dim[1]; //设置矩阵维数大小
% P5 o7 o* @\\" {# [9 }6 t; W
pa=pRealArray1->Array; pb=pRealArray2->Array; pc=pRealArray3->Array;\\" { c\\" }' h/ i5 P) R( _( u
m=pRealArray1->Dim[0]; n=pRealArray1->Dim[1]; k=pRealArray2->Dim[1];5 X' A1 I5 l+ ~% U9 q
for(i=0; i<m; i++) //矩阵乘/ A7 e* C3 G- |8 T
{4 B' S! p' b- h1 a! C
for(j=0; j<k; j++), k6 `( I7 r. T E' q& s
{
+ F2 @, ?7 r0 ~4 A- K
u=i*k+j; pc[u]=0.0; j5 v8 D6 H4 L\\" J9 J7 ]% y& m
for (v=0; v<n; v++)2 e& U: a3 o F) E. p4 j
{\\" X\\" o F3 D9 U( L3 p' i
pc[u]=pc[u]+pa[i*n+v]*pb[v*k+j];
1 |\\" ]0 N7 ^$ H' \9 q# l
}\\" c; e4 V6 g4 z8 J* R# _
}3 F! H$ y% ?( C4 t* [$ Z: K5 q
}
; z9 g- e- `/ v6 u# L: p: [1 w, y
FunReObj(hFor); //告诉Lu，返回一个动态对象
2 w3 C' ?1 \# Q4 x& O, z
a.BType=luDynData_realarray; a.VType=Matrix; a.x=0; *(luVOID *)&(a.x)=(luVOID)pRealArray3;
; L' L+ n: U ~+ Y
break;
5 p) g7 O Q\\" B6 _: X4 ?
case 25: //重载运算符.*
) Q, B, A0 G8 u( s# A1 i\\" O& p- ]
pRealArray1=(luRealArray *)SearchKey((char *)&(xx->x),sizeof(luVOID),luDynData_realarray);, C2 ]0 p' k, m
pRealArray2=(luRealArray *)SearchKey((char *)&((xx+1)->x),sizeof(luVOID),luDynData_realarray);0 s, |1 U4 N! n' W
if(!pRealArray1 || !pRealArray2) break; //对象句柄无效，不是实数数组+ P9 n! _ s\\" _' j* |: z
if(pRealArray1->DimLen!=2 || pRealArray2->DimLen!=2) break; //不是二维实数数组（矩阵）
. s, ^# K1 u' H' W$ M0 r
if(pRealArray1->Dim[0]!=pRealArray2->Dim[0] || pRealArray1->Dim[1]!=pRealArray2->Dim[1]) break; //维数不相同
t0 b, `' d9 |1 D! ^+ T* b
pRealArray3=(luRealArray *)NewSysObj(luDynData_realarray,pRealArray1->ArrayLen,2); //创建矩阵对象+ {! M\\" E. C2 B5 ^- @
if(!pRealArray3) break;
1 B9 t) ]) w\\" i6 v5 G5 p: Y5 r
pRealArray3->Dim[0]=pRealArray1->Dim[0]; pRealArray3->Dim[1]=pRealArray1->Dim[1]; //设置矩阵维数大小
2 M1 V* z4 i1 b! j- \
for(i=0;i<pRealArray1->ArrayLen;i++) pRealArray3->Array[i]=pRealArray1->Array[i]*pRealArray2->Array[i];//矩阵点乘
- D+ f, y/ f) C. ^8 ^) g
FunReObj(hFor); //告诉Lu，返回一个动态对象
8 T* ?3 `) d5 w\\" J- u; A
a.BType=luDynData_realarray; a.VType=Matrix; a.x=0; *(luVOID *)&(a.x)=(luVOID)pRealArray3;
+ ]) S7 |$ I0 W# e& B, b
break;
; n! z& p ]. {% P8 w/ t
case 46: //重载函数new
1 I7 I- h' H$ z, ~
a=ExeOperator(mm,xx,hFor,theOperator,luDynData_realarray); //直接调用基本类型luDynData_realarray的new函数
0 y. m: h+ c0 w- `, S0 O\\" u
if(a.VType==luDynData_realarray) a.VType=Matrix; //设置扩展类型为自定义的Matrix类型. l7 |5 ^; Z2 w# I* i9 l: m h\\" m
break;- t/ m* k4 H$ x5 w: m- m& a1 F
case 49: //重载函数o
: v& k; D7 D! `/ {: G: K
pMessage=(luMessage)SearchKey("\0\0\0\0",sizeof(luVOID),luPubKey_User);$ l( y( x( g* P( N' Q8 e& q! h
if(!pMessage) break;0 L. ]% h% V1 o, o5 w& b0 R
pRealArray1=(luRealArray *)SearchKey((char *)&(xx->x),sizeof(luVOID),luDynData_realarray);* \/ Y; ]& J! y, a8 }2 Y
if(!pRealArray1) break; //对象句柄无效，不是实数数组' j& g6 t0 n7 s5 j8 }$ v
if(pRealArray1->DimLen!=2) break; //不是二维实数数组（矩阵）! G) K9 j3 H! ~' J- \
pa=pRealArray1->Array;6 ?4 L& ^* n/ k |* A. L
m=pRealArray1->Dim[0]; n=pRealArray1->Dim[1]; k=0;4 K& I P6 T/ ^4 V* O6 M
for(i=0; i<m; i++) //输出矩阵
. R! j0 |+ C7 z/ k' c7 Z
{, J7 b( l\\" u8 M. g) Z# R2 J
pMessage(L"\r\n"); k+=2;; D\\" v- @; i5 m\\" z! w. s: S4 f
for(j=0; j<n; j++)
$ T( k9 b D! `! d# n+ M
{& z z9 h/ |6 A& a, o+ p
_gcvt_s(chNum,pa[i*n+j],16);
6 \+ j- [7 V0 c1 `4 w5 q
for(u=0;chNum[u];u++) {wchNum[u]=chNum[u]; k++;}0 }3 H: K# S% b+ Z8 _
wchNum[u]='\0';
& Y( F( e E3 ]- f# V: p
pMessage(wchNum); pMessage(L" "); k+=2;
+ a; T, w; G# P; Z) V
}4 K6 z$ C9 X- X6 a8 \
}
4 R& U z$ a8 s! ^
pMessage(L"\r\n"); k+=2;3 h& M# _& n) \
a.BType=luStaData_int64; a.VType=luStaData_int64; a.x=k; //按函数o的要求，返回输出的字符总数
- W! D' I* L1 z3 o/ w/ |
break;% r, Q% M+ r5 m2 w7 F9 G- J& ]. o7 F8 h
default:
7 u' A: F. i. r0 s2 s3 S4 F
break;\\" N8 M G( q+ v1 C4 j! `# u
}3 b. p, f, N; E) g2 J
return a;, m% Y- M+ ]: x' n
}
! k+ C/ p% g* k2 P4 r9 n. b/ H: J' K
void main(void)/ ^/ E5 t4 }- m# g3 z6 V% Q
{ G0 a+ W, {3 M( S2 `, b) \
void *hFor; //表达式句柄
) z+ a+ B t' m2 g5 z- i% ^
luINT nPara; //存放表达式的自变量个数, Y' S; @1 O5 ^; W) A, Q
LuData *pPara; //存放输入自变量的数组指针1 }7 S8 ?3 g% E$ e
luINT ErrBegin,ErrEnd; //表达式编译出错的初始位置和结束位置
9 f/ l( G9 N( q8 S, w- h
int ErrCode; //错误代码& f( o. c% U* b' y; V
void *v;1 I/ F$ Y( ` g9 Y! @' K! T4 Q
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.]}";//字符串表达式，矩阵乘+ O1 P5 k# i8 F0 c. M/ J# Z
//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.]}";//字符串表达式，矩阵点乘
6 T' G, ~0 V! I$ M. Z) w) f2 A$ L
LuData Val;
w. j- ?\\" v3 w5 y) Z) t
if(!InitLu()) return; //初始化Lu
3 Q; _! _2 |2 w
while(LockKey(Matrix,DelMatrix,OpMatrix)){Matrix++;} //锁定一个键，用于存储矩阵扩展类型. b, ]9 k. N$ |, v$ m7 z
: e* n% x# p( q
Val.BType=luStaData_int64; Val.VType=luStaData_int64; Val.x=Matrix; //定义整数常量/ h3 U1 M K8 H. }4 e% g! c
SetConst(L"matrix",&Val); //设置整数常量* O# i5 I# }3 v# ?5 j( t
InsertKey("\0\0\0\0",4,luPubKey_User,LuMessage,NULL,NULL,1,v); //使Lu运行时可输出函数信息9 h! a( Q) R8 U+ D6 Z5 h
wcout.imbue(locale("chs")); //设置输出的locale为中文
: Y$ a# H) w\\" }/ Z8 {
. y0 `6 e$ O5 x$ b( u/ j
ErrCode=LuCom(ForStr,0,0,0,hFor,nPara,pPara,ErrBegin,ErrEnd); //编译表达式
/ q% c3 {, k# @# N# i, d
if(ErrCode)
\\" e' z6 l; S+ l' X: P: Z\\" v, f
{\\" f. q& ^$ D) J8 o+ e% E) {
wcout<<L"表达式有错误！错误代码："<<ErrCode<<endl;
0 e& z, d( p, G+ @* Y2 {
}1 r3 v! `& u: w. E8 N\\" W' w
else& F% f/ D1 O; X0 z- _3 z5 N
{7 c7 {! Z- E4 N$ L
LuCal(hFor,pPara); //计算表达式的值
; `7 S; I& V! z8 `! t; D- B& b. m' y3 i
}% e\\" k7 t' O0 V, m6 X, J9 m4 i
LockKey(Matrix,NULL,OpMatrix);//解锁键Matrix，本例中，该函数可以不用
/ y: _* t' |, m) j
FreeLu(); //释放Lu
# G# x$ R G8 s
}

#include <windows.h>: ~- m% E\\" @9 f; K6 [

#include <iostream>4 j- y( [+ |7 K% i

#include <math.h> 
5 c, d# g! j! d4 Z* u
#include "lu32.h" 
4 a- o& _# m& \0 X! Q/ N2 g
 
6 B0 ?\\" Q- O, E
#pragma comment( lib, "lu32.lib" ) 
5 g5 w! V/ X\\" I4 S) r7 B
 
# i4 h2 ~9 h, {! R: H: y% s9 d# A
using namespace std;6 ^5 A) P& R: @- }2 P& i6 M

8 P( ~+ Q\\" n( g/ E+ W( ?! G

luKEY Matrix=-1000;        //标识矩阵类型，最终的Matrix由LockKey决定 
* x; b( Q9 d7 s% A: ~- }
5 o' F+ Y; y. {. F* J: x& X

void _stdcall LuMessage(wchar_t *pch)//输出动态库信息，该函数注册到Lu，由Lu二级函数调用 ' X\\" \2 K4 Y9 j7 Z. _' ?; L

{ 
8 \3 L4 h1 x) j0 ?  H8 W
        wcout<<pch;+ V* F: U* u( c/ O' Y% o7 O( c

} 
( h# D, }\\" h\\" ~9 b
void _stdcall DelMatrix(void *me)        //用于LockKey函数，因为是基于系统内置实数数组创建矩阵，故该函数什么也不做  `/ O/ _! L5 Q/ E$ c8 J0 ~

{ 
\\" Q+ x& k7 p9 u2 e' E1 G3 X3 R
} 
9 \# g* |( J4 ]( B) |9 t
LuData _stdcall OpMatrix(luINT mm,LuData *xx,void *hFor,int theOperator)        //运算符重载函数，用于LockKey函数 
7 y! L# o$ ?7 B
{ 
2 Y! E. U' R& B+ r& e5 V' |
        LuData a; 
# C, J5 |& H% @
        luRealArray *pRealArray1,*pRealArray2,*pRealArray3; 
; p. V) L; X8 x
        luVOID i,j,k,m,n,u,v; 
9 n: W, e+ E$ l3 ^7 G* ~5 a0 D
        double *pa,*pb,*pc; 
) t* L, i, s) S) q
        luMessage pMessage; 
  M( D+ e  \1 A3 h: W* R1 r8 S# L  I
        wchar_t wchNum[32];* {/ W1 M& U! s$ z+ T5 A. s

char chNum[32];' y5 d4 y\\" C) q

a.BType=luStaData_nil; a.VType=luStaData_nil; a.x=0;6 C  X/ x  h) B' j6 a% u6 @1 b

switch(theOperator); Z' _) z$ M( K5 g

{! P+ o6 e9 M  T! [! U

case 2:        //重载运算符* 
. ]( [+ }& i& k
                pRealArray1=(luRealArray *)SearchKey((char *)&(xx->x),sizeof(luVOID),luDynData_realarray);* N* |6 c' Y/ ]4 E- {) b6 o7 a

pRealArray2=(luRealArray *)SearchKey((char *)&((xx+1)->x),sizeof(luVOID),luDynData_realarray);  K( E+ W% {2 m3 v

if(!pRealArray1 || !pRealArray2) break;        //对象句柄无效，不是实数数组 
3 Q% s# P& H2 j# x
                if(pRealArray1->DimLen!=2 || pRealArray2->DimLen!=2) break;        //不是二维实数数组（矩阵） 
3 O8 M* f* e7 E' A& i, q/ R5 \
                if(pRealArray1->Dim[1]!=pRealArray2->Dim[0]) break;        //维数不匹配) u- ^: y0 B# H8 a0 ?

pRealArray3=(luRealArray *)NewSysObj(luDynData_realarray,pRealArray1->Dim[0]*pRealArray2->Dim[1],2);        //创建矩阵对象0 B1 v: F# z\\" [( s: N8 {$ \  H

if(!pRealArray3) break; 
7 a4 Y1 P6 l( n; V3 I3 T/ D
                pRealArray3->Dim[0]=pRealArray1->Dim[0]; pRealArray3->Dim[1]=pRealArray2->Dim[1];        //设置矩阵维数大小 
% P5 o7 o* @\\" {# [9 }6 t; W
                pa=pRealArray1->Array; pb=pRealArray2->Array; pc=pRealArray3->Array;\\" {  c\\" }' h/ i5 P) R( _( u

m=pRealArray1->Dim[0]; n=pRealArray1->Dim[1]; k=pRealArray2->Dim[1];5 X' A1 I5 l+ ~% U9 q

for(i=0; i<m; i++)        //矩阵乘/ A7 e* C3 G- |8 T

{4 B' S! p' b- h1 a! C

for(j=0; j<k; j++), k6 `( I7 r. T  E' q& s

{ 
+ F2 @, ?7 r0 ~4 A- K
                                u=i*k+j; pc[u]=0.0;  j5 v8 D6 H4 L\\" J9 J7 ]% y& m

for (v=0; v<n; v++)2 e& U: a3 o  F) E. p4 j

{\\" X\\" o  F3 D9 U( L3 p' i

pc[u]=pc[u]+pa[i*n+v]*pb[v*k+j]; 
1 |\\" ]0 N7 ^$ H' \9 q# l
                                }\\" c; e4 V6 g4 z8 J* R# _

}3 F! H$ y% ?( C4 t* [$ Z: K5 q

} 
; z9 g- e- `/ v6 u# L: p: [1 w, y
                FunReObj(hFor);        //告诉Lu，返回一个动态对象 
2 w3 C' ?1 \# Q4 x& O, z
                a.BType=luDynData_realarray; a.VType=Matrix; a.x=0; *(luVOID *)&(a.x)=(luVOID)pRealArray3; 
; L' L+ n: U  ~+ Y
                break; 
5 p) g7 O  Q\\" B6 _: X4 ?
        case 25:        //重载运算符.* 
) Q, B, A0 G8 u( s# A1 i\\" O& p- ]
                pRealArray1=(luRealArray *)SearchKey((char *)&(xx->x),sizeof(luVOID),luDynData_realarray);, C2 ]0 p' k, m

pRealArray2=(luRealArray *)SearchKey((char *)&((xx+1)->x),sizeof(luVOID),luDynData_realarray);0 s, |1 U4 N! n' W

if(!pRealArray1 || !pRealArray2) break;        //对象句柄无效，不是实数数组+ P9 n! _  s\\" _' j* |: z

if(pRealArray1->DimLen!=2 || pRealArray2->DimLen!=2) break;        //不是二维实数数组（矩阵） 
. s, ^# K1 u' H' W$ M0 r
                if(pRealArray1->Dim[0]!=pRealArray2->Dim[0] || pRealArray1->Dim[1]!=pRealArray2->Dim[1]) break;        //维数不相同 
  t0 b, `' d9 |1 D! ^+ T* b
                pRealArray3=(luRealArray *)NewSysObj(luDynData_realarray,pRealArray1->ArrayLen,2);        //创建矩阵对象+ {! M\\" E. C2 B5 ^- @

if(!pRealArray3) break; 
1 B9 t) ]) w\\" i6 v5 G5 p: Y5 r
                pRealArray3->Dim[0]=pRealArray1->Dim[0]; pRealArray3->Dim[1]=pRealArray1->Dim[1];        //设置矩阵维数大小 
2 M1 V* z4 i1 b! j- \
                for(i=0;i<pRealArray1->ArrayLen;i++) pRealArray3->Array[i]=pRealArray1->Array[i]*pRealArray2->Array[i];//矩阵点乘 
- D+ f, y/ f) C. ^8 ^) g
                FunReObj(hFor);        //告诉Lu，返回一个动态对象 
8 T* ?3 `) d5 w\\" J- u; A
                a.BType=luDynData_realarray; a.VType=Matrix; a.x=0; *(luVOID *)&(a.x)=(luVOID)pRealArray3; 
+ ]) S7 |$ I0 W# e& B, b
                break; 
; n! z& p  ]. {% P8 w/ t
        case 46:        //重载函数new 
1 I7 I- h' H$ z, ~
                a=ExeOperator(mm,xx,hFor,theOperator,luDynData_realarray);        //直接调用基本类型luDynData_realarray的new函数 
0 y. m: h+ c0 w- `, S0 O\\" u
                if(a.VType==luDynData_realarray) a.VType=Matrix;        //设置扩展类型为自定义的Matrix类型. l7 |5 ^; Z2 w# I* i9 l: m  h\\" m

break;- t/ m* k4 H$ x5 w: m- m& a1 F

case 49:        //重载函数o 
: v& k; D7 D! `/ {: G: K
                pMessage=(luMessage)SearchKey("\0\0\0\0",sizeof(luVOID),luPubKey_User);$ l( y( x( g* P( N' Q8 e& q! h

if(!pMessage) break;0 L. ]% h% V1 o, o5 w& b0 R

pRealArray1=(luRealArray *)SearchKey((char *)&(xx->x),sizeof(luVOID),luDynData_realarray);* \/ Y; ]& J! y, a8 }2 Y

if(!pRealArray1) break;        //对象句柄无效，不是实数数组' j& g6 t0 n7 s5 j8 }$ v

if(pRealArray1->DimLen!=2) break;        //不是二维实数数组（矩阵）! G) K9 j3 H! ~' J- \

pa=pRealArray1->Array;6 ?4 L& ^* n/ k  |* A. L

m=pRealArray1->Dim[0]; n=pRealArray1->Dim[1]; k=0;4 K& I  P6 T/ ^4 V* O6 M

for(i=0; i<m; i++)        //输出矩阵 
. R! j0 |+ C7 z/ k' c7 Z
                {, J7 b( l\\" u8 M. g) Z# R2 J

pMessage(L"\r\n"); k+=2;; D\\" v- @; i5 m\\" z! w. s: S4 f

for(j=0; j<n; j++) 
$ T( k9 b  D! `! d# n+ M
                        {& z  z9 h/ |6 A& a, o+ p

_gcvt_s(chNum,pa[i*n+j],16); 
6 \+ j- [7 V0 c1 `4 w5 q
                                for(u=0;chNum[u];u++) {wchNum[u]=chNum[u]; k++;}0 }3 H: K# S% b+ Z8 _

wchNum[u]='\0'; 
& Y( F( e  E3 ]- f# V: p
                                pMessage(wchNum); pMessage(L"  "); k+=2; 
+ a; T, w; G# P; Z) V
                        }4 K6 z$ C9 X- X6 a8 \

} 
4 R& U  z$ a8 s! ^
                pMessage(L"\r\n"); k+=2;3 h& M# _& n) \

a.BType=luStaData_int64; a.VType=luStaData_int64; a.x=k;        //按函数o的要求，返回输出的字符总数 
- W! D' I* L1 z3 o/ w/ |
                break;% r, Q% M+ r5 m2 w7 F9 G- J& ]. o7 F8 h

default: 
7 u' A: F. i. r0 s2 s3 S4 F
                break;\\" N8 M  G( q+ v1 C4 j! `# u

}3 b. p, f, N; E) g2 J

return a;, m% Y- M+ ]: x' n

} 
! k+ C/ p% g* k2 P4 r9 n. b/ H: J' K
void main(void)/ ^/ E5 t4 }- m# g3 z6 V% Q

{  G0 a+ W, {3 M( S2 `, b) \

void *hFor;                //表达式句柄 
) z+ a+ B  t' m2 g5 z- i% ^
        luINT nPara;                //存放表达式的自变量个数, Y' S; @1 O5 ^; W) A, Q

LuData *pPara;                //存放输入自变量的数组指针1 }7 S8 ?3 g% E$ e

luINT ErrBegin,ErrEnd;        //表达式编译出错的初始位置和结束位置 
9 f/ l( G9 N( q8 S, w- h
        int ErrCode;                //错误代码& f( o. c% U* b' y; V

void *v;1 I/ F$ Y( `  g9 Y! @' K! T4 Q

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.]}";//字符串表达式，矩阵乘+ O1 P5 k# i8 F0 c. M/ J# Z

//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.]}";//字符串表达式，矩阵点乘 
6 T' G, ~0 V! I$ M. Z) w) f2 A$ L
        LuData Val; 
  w. j- ?\\" v3 w5 y) Z) t
        if(!InitLu()) return;        //初始化Lu 
3 Q; _! _2 |2 w
        while(LockKey(Matrix,DelMatrix,OpMatrix)){Matrix++;}        //锁定一个键，用于存储矩阵扩展类型. b, ]9 k. N$ |, v$ m7 z

: e* n% x# p( q
        Val.BType=luStaData_int64; Val.VType=luStaData_int64; Val.x=Matrix;        //定义整数常量/ h3 U1 M  K8 H. }4 e% g! c

SetConst(L"matrix",&Val);        //设置整数常量* O# i5 I# }3 v# ?5 j( t

InsertKey("\0\0\0\0",4,luPubKey_User,LuMessage,NULL,NULL,1,v); //使Lu运行时可输出函数信息9 h! a( Q) R8 U+ D6 Z5 h

wcout.imbue(locale("chs"));        //设置输出的locale为中文 
: Y$ a# H) w\\" }/ Z8 {
   
. y0 `6 e$ O5 x$ b( u/ j
        ErrCode=LuCom(ForStr,0,0,0,hFor,nPara,pPara,ErrBegin,ErrEnd); //编译表达式 
/ q% c3 {, k# @# N# i, d
        if(ErrCode) 
\\" e' z6 l; S+ l' X: P: Z\\" v, f
        {\\" f. q& ^$ D) J8 o+ e% E) {

wcout<<L"表达式有错误！错误代码："<<ErrCode<<endl; 
0 e& z, d( p, G+ @* Y2 {
        }1 r3 v! `& u: w. E8 N\\" W' w

else& F% f/ D1 O; X0 z- _3 z5 N

{7 c7 {! Z- E4 N$ L

LuCal(hFor,pPara);        //计算表达式的值 
; `7 S; I& V! z8 `! t; D- B& b. m' y3 i
        }% e\\" k7 t' O0 V, m6 X, J9 m4 i

LockKey(Matrix,NULL,OpMatrix);//解锁键Matrix，本例中，该函数可以不用 
/ y: _* t' |, m) j
        FreeLu();                        //释放Lu 
# G# x$ R  G8 s
}

习题：

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

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

main(:a,b,c,d,t,i)=: v/ a2 h+ y8 _- ?8 n5 T5 r
a=new[matrix,2,2,data:1.,2.,2.,1.],
* N; \2 J2 l* e
b=new[matrix,2,2,data:2.,1.,1.,2.],: F5 Z, m% E, }% a& J0 b4 U9 M
c=new[matrix,2,2,data:2/3.,-1/3.,-1/3.,2/3.],
& @5 Y F6 v\" D5 d4 [. g
t=clock(),
& e3 n+ z: H/ ]\" y8 T7 U, W
d=a*b, i=0, while{i<1000000, d=d*c*b, i++},
1 D! ^' O1 T8 K% a# i
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\"}";//字符串表达式

复制代码

结果：