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

查看: 8789|回复: 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>
8 `\\" G& ^% Q( ]9 _2 T9 \8 D3 v
#include <iostream>
( i$ I b+ @\\" Z; c
#include <math.h>' o8 v( F. L6 q4 n3 [' ^
#include "lu32.h" `! A; n D1 u s8 o
* t2 c1 Z; y! h3 @3 R* y; A
#pragma comment( lib, "lu32.lib" )
\\" r% a0 b3 _' l+ G
9 c! Q, I, g) S- W/ V' w5 n! X. M
using namespace std;
+ Z3 ]; B- m( n5 q\\" `\\" @1 N5 Q: V
) d( I& h5 C+ n/ r+ t8 a; O
luKEY Matrix=-1000; //标识矩阵类型，最终的Matrix由LockKey决定7 ]% d2 Y- j, U0 X! G5 T& h4 K
4 i/ d0 D4 \7 X# t8 w
void _stdcall LuMessage(wchar_t *pch)//输出动态库信息，该函数注册到Lu，由Lu二级函数调用 1 ] T- X6 j8 Q$ I: k
{! V& j t! p\\" y. ~
wcout<<pch;
% H8 v' Y: M1 \3 \$ f+ T
}6 X Q. \% i2 @\\" T
void _stdcall DelMatrix(void *me) //用于LockKey函数，因为是基于系统内置实数数组创建矩阵，故该函数什么也不做4 i- M$ R4 `. V* Q
{: [8 Y6 [1 s: e+ L! z- L
}
4 r) [9 p& C; m% v9 Z
LuData _stdcall OpMatrix(luINT mm,LuData *xx,void *hFor,int theOperator) //运算符重载函数，用于LockKey函数
; X9 v) c' v1 t# w o
{
\\" K* @\\" a\\" i, G% p9 L
LuData a;* r5 ~1 J' l( H7 t/ ^; X
luRealArray *pRealArray1,*pRealArray2,*pRealArray3;1 k! ]5 a9 G/ I E
luVOID i,j,k,m,n,u,v;. O4 p% Y6 X8 @; B; x0 a) \
double *pa,*pb,*pc;5 S- V5 L' {& m, W
luMessage pMessage;4 T7 o: D6 D; K7 P- @) O) U
wchar_t wchNum[32];. a( y& Y' o0 j, n4 \
char chNum[32];$ z6 j& f6 L. i, |& J% n
a.BType=luStaData_nil; a.VType=luStaData_nil; a.x=0;
9 ]. n\\" M' j& l2 i2 y9 P
switch(theOperator)
6 @* a- ^- ~/ }3 v% _% ?
{2 R! g# r' i\\" m% P\\" s* J
case 2: //重载运算符* k9 N- o3 j7 B5 X
pRealArray1=(luRealArray *)SearchKey((char *)&(xx->x),sizeof(luVOID),luDynData_realarray);# C0 X- W4 N9 H* V0 Y
pRealArray2=(luRealArray *)SearchKey((char *)&((xx+1)->x),sizeof(luVOID),luDynData_realarray);- R6 O5 b; w) g$ Y$ G0 O( A0 z7 ]7 W
if(!pRealArray1 || !pRealArray2) break; //对象句柄无效，不是实数数组
' k8 o! t' F8 n9 B; K. Z) W
if(pRealArray1->DimLen!=2 || pRealArray2->DimLen!=2) break; //不是二维实数数组（矩阵）
% R0 `: s! P; Q' u7 @/ V2 H* J
if(pRealArray1->Dim[1]!=pRealArray2->Dim[0]) break; //维数不匹配
7 g# O- Y T$ N8 _# X; _7 d; j k
pRealArray3=(luRealArray *)NewSysObj(luDynData_realarray,pRealArray1->Dim[0]*pRealArray2->Dim[1],2); //创建矩阵对象
. L% s- p9 h& y+ f
if(!pRealArray3) break;: E1 O% f' B$ }' j* E& L: }
pRealArray3->Dim[0]=pRealArray1->Dim[0]; pRealArray3->Dim[1]=pRealArray2->Dim[1]; //设置矩阵维数大小
( y3 x- n7 u2 `5 [: G- X2 Y
pa=pRealArray1->Array; pb=pRealArray2->Array; pc=pRealArray3->Array;
1 |; V. I, ]# i\\" S
m=pRealArray1->Dim[0]; n=pRealArray1->Dim[1]; k=pRealArray2->Dim[1];+ Z9 \, @3 C0 {6 h, |9 \
for(i=0; i<m; i++) //矩阵乘. ^, B# \+ Z5 |
{
) A, G, V. x3 \' d
for(j=0; j<k; j++)! W9 L; h I3 T& ^
{/ |% K/ B z* ^' {: f
u=i*k+j; pc[u]=0.0;: K& ~( Z/ @- @8 C4 K* Q5 H$ W! X* `3 R
for (v=0; v<n; v++)
# s0 k( y p/ J\\" [2 n
{
7 s8 Y8 d# z* G
pc[u]=pc[u]+pa[i*n+v]*pb[v*k+j];
& @+ [+ j) O! Q( k1 g, \/ B; @6 h
}
0 y( a6 b2 D. l- k( ?2 V; C
}
8 J+ g% O L* R4 d
}
5 W- n: I( K* B! q
FunReObj(hFor); //告诉Lu，返回一个动态对象. ?. x- ]$ J8 l5 _' @
a.BType=luDynData_realarray; a.VType=Matrix; a.x=0; *(luVOID *)&(a.x)=(luVOID)pRealArray3;
2 A- D6 R* @. c8 S9 _
break;. U, l1 K1 K. S6 N( T N' G% N% K/ q
case 25: //重载运算符.*
3 D) f3 ^( l, _
pRealArray1=(luRealArray *)SearchKey((char *)&(xx->x),sizeof(luVOID),luDynData_realarray);
+ \- z/ V# q/ N3 K0 c; g
pRealArray2=(luRealArray *)SearchKey((char *)&((xx+1)->x),sizeof(luVOID),luDynData_realarray);
9 t! y c9 H% v- q' y3 |+ n\\" \' t
if(!pRealArray1 || !pRealArray2) break; //对象句柄无效，不是实数数组
\\" h$ F\\" @$ g7 R8 d0 E9 d( b- @
if(pRealArray1->DimLen!=2 || pRealArray2->DimLen!=2) break; //不是二维实数数组（矩阵）
: R4 B4 }( C; `* Y+ n
if(pRealArray1->Dim[0]!=pRealArray2->Dim[0] || pRealArray1->Dim[1]!=pRealArray2->Dim[1]) break; //维数不相同
\\" R8 Z4 K1 {' c ^% L0 Q- C
pRealArray3=(luRealArray *)NewSysObj(luDynData_realarray,pRealArray1->ArrayLen,2); //创建矩阵对象: r7 m' c9 S2 @4 ?, p7 g
if(!pRealArray3) break;- B# R G8 A# |
pRealArray3->Dim[0]=pRealArray1->Dim[0]; pRealArray3->Dim[1]=pRealArray1->Dim[1]; //设置矩阵维数大小
* N3 O# G. ], P6 B j! |
for(i=0;i<pRealArray1->ArrayLen;i++) pRealArray3->Array[i]=pRealArray1->Array[i]*pRealArray2->Array[i];//矩阵点乘5 a3 [* g5 j1 M ~3 Z
FunReObj(hFor); //告诉Lu，返回一个动态对象2 ?2 J+ b) x& W6 M, g
a.BType=luDynData_realarray; a.VType=Matrix; a.x=0; *(luVOID *)&(a.x)=(luVOID)pRealArray3;$ Q: @1 J7 ^( b0 G
break;) S' w) d2 w# u' U0 u5 t& c
case 46: //重载函数new
' s3 l0 \6 k0 E( J, u: \- ]. u: t
a=ExeOperator(mm,xx,hFor,theOperator,luDynData_realarray); //直接调用基本类型luDynData_realarray的new函数
\\" g. Z, X( Q; \* J\\" U# T+ x1 Z. T
if(a.VType==luDynData_realarray) a.VType=Matrix; //设置扩展类型为自定义的Matrix类型) p. _0 r7 g$ y5 z3 d
break;, a! Y/ z) Q: B6 N' G& u/ o$ X; S
case 49: //重载函数o
\\" Q# J8 T- t# g# C8 o
pMessage=(luMessage)SearchKey("\0\0\0\0",sizeof(luVOID),luPubKey_User);$ ^- H) P- R I
if(!pMessage) break;$ F5 x6 }# D5 N9 q
pRealArray1=(luRealArray *)SearchKey((char *)&(xx->x),sizeof(luVOID),luDynData_realarray);
& v' k# {! A/ D; {9 p7 k0 `
if(!pRealArray1) break; //对象句柄无效，不是实数数组8 W3 L1 u$ w. r, ~
if(pRealArray1->DimLen!=2) break; //不是二维实数数组（矩阵）\\" @7 q5 k9 i4 Y! V/ R
pa=pRealArray1->Array;
: `+ A4 w$ X3 A8 z9 u+ K7 L/ S7 J
m=pRealArray1->Dim[0]; n=pRealArray1->Dim[1]; k=0;4 ~! k2 Y9 b: A9 z. o9 e2 ]! R
for(i=0; i<m; i++) //输出矩阵0 h5 d/ I, C/ K
{\\" @1 U+ ~1 L& s0 ^! P\\" ~
pMessage(L"\r\n"); k+=2;
3 s6 W' Q0 k E1 K& {. o* P% b( b
for(j=0; j<n; j++)
+ C6 _3 o5 L L! A
{* }% e3 v8 r7 {& X\\" i5 q3 n
_gcvt_s(chNum,pa[i*n+j],16);
. w' }* C v1 t, W- a0 b9 y
for(u=0;chNum[u];u++) {wchNum[u]=chNum[u]; k++;}
c8 f; j7 ~) @; C
wchNum[u]='\0';. [9 W3 _; \9 K8 v\\" h9 ^% W& N
pMessage(wchNum); pMessage(L" "); k+=2;+ u4 i. u# M1 H
}
9 b1 X- s\\" a1 t4 [6 _* v
}
! a* P) i; v# K
pMessage(L"\r\n"); k+=2;2 f8 e/ X* [$ d8 ]2 Q8 y
a.BType=luStaData_int64; a.VType=luStaData_int64; a.x=k; //按函数o的要求，返回输出的字符总数; Y2 r7 @( c: F
break;
9 A) T8 e# w! k. \5 G
default:. Y8 |: F6 y+ n4 x [7 X, E/ k
break;
8 _& v6 O- v6 F6 ~! s
}9 \; [$ n t: t7 W
return a;1 r4 R$ P* [. R1 T# X2 r
}
X5 d! ^, ^) L) i! Z4 E
void main(void)
# \/ i* X) s* j1 \; P- u
{) ?! N4 V, \+ R; R- a2 ~( {: R8 A
void *hFor; //表达式句柄# T/ X1 r1 k! U* u\\" m( ~4 U
luINT nPara; //存放表达式的自变量个数! v4 \3 q4 K/ q; k$ l
LuData *pPara; //存放输入自变量的数组指针
8 \8 A. }1 E2 X& N. N8 K/ u
luINT ErrBegin,ErrEnd; //表达式编译出错的初始位置和结束位置6 f8 b' X5 Z0 _6 i
int ErrCode; //错误代码
4 V- E& p* V y
void *v;
5 X7 n. O7 I7 g3 e) n+ 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.]}";//字符串表达式，矩阵乘
: \9 r& f( H$ m, ], S' Q! d& @
//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.]}";//字符串表达式，矩阵点乘- g/ U\\" N* n) C, i* D0 g+ F5 V
LuData Val;
! {% }& l1 H) J& X
if(!InitLu()) return; //初始化Lu& ^/ d3 d; j2 ?; t: r\\" n
while(LockKey(Matrix,DelMatrix,OpMatrix)){Matrix++;} //锁定一个键，用于存储矩阵扩展类型
3 S9 Q w8 l; I( Y+ F
1 J$ D! ]7 g; U3 q
Val.BType=luStaData_int64; Val.VType=luStaData_int64; Val.x=Matrix; //定义整数常量4 I\\" b; h2 I/ v\\" ]7 V' J/ D- \
SetConst(L"matrix",&Val); //设置整数常量# z7 s7 k7 p# |% \$ d: u
InsertKey("\0\0\0\0",4,luPubKey_User,LuMessage,NULL,NULL,1,v); //使Lu运行时可输出函数信息\\" v4 K: l3 {( o+ ?8 Y
wcout.imbue(locale("chs")); //设置输出的locale为中文6 o* A# ^9 C; U8 X
! Y% l% i# o( t3 r( U6 n+ j
ErrCode=LuCom(ForStr,0,0,0,hFor,nPara,pPara,ErrBegin,ErrEnd); //编译表达式
6 }0 [, P4 b8 b
if(ErrCode). _: |\\" e1 l3 x\\" W0 L; W\\" E
{
$ y\\" I5 Q' Y: K; `
wcout<<L"表达式有错误！错误代码："<<ErrCode<<endl;1 L! N9 i v0 i% [. f
}
' g5 w- m- I6 a$ ]3 |* ]) J- q
else1 H% W( E' `8 |/ j
{, `- y( D4 T! Y3 L: b
LuCal(hFor,pPara); //计算表达式的值
# y/ m; F1 C3 i
}
% ^% j) y* M/ l
LockKey(Matrix,NULL,OpMatrix);//解锁键Matrix，本例中，该函数可以不用
# w( S' o1 Y4 e* v6 O/ u
FreeLu(); //释放Lu
8 T& }5 i+ c9 b, G( r, c# Q+ P$ h7 N
}

#include <windows.h> 
8 `\\" G& ^% Q( ]9 _2 T9 \8 D3 v
#include <iostream> 
( i$ I  b+ @\\" Z; c
#include <math.h>' o8 v( F. L6 q4 n3 [' ^

#include "lu32.h"  `! A; n  D1 u  s8 o

* t2 c1 Z; y! h3 @3 R* y; A
#pragma comment( lib, "lu32.lib" ) 
\\" r% a0 b3 _' l+ G
 
9 c! Q, I, g) S- W/ V' w5 n! X. M
using namespace std; 
+ Z3 ]; B- m( n5 q\\" `\\" @1 N5 Q: V
) d( I& h5 C+ n/ r+ t8 a; O

luKEY Matrix=-1000;        //标识矩阵类型，最终的Matrix由LockKey决定7 ]% d2 Y- j, U0 X! G5 T& h4 K

4 i/ d0 D4 \7 X# t8 w

void _stdcall LuMessage(wchar_t *pch)//输出动态库信息，该函数注册到Lu，由Lu二级函数调用 1 ]  T- X6 j8 Q$ I: k

{! V& j  t! p\\" y. ~

wcout<<pch; 
% H8 v' Y: M1 \3 \$ f+ T
}6 X  Q. \% i2 @\\" T

void _stdcall DelMatrix(void *me)        //用于LockKey函数，因为是基于系统内置实数数组创建矩阵，故该函数什么也不做4 i- M$ R4 `. V* Q

{: [8 Y6 [1 s: e+ L! z- L

} 
4 r) [9 p& C; m% v9 Z
LuData _stdcall OpMatrix(luINT mm,LuData *xx,void *hFor,int theOperator)        //运算符重载函数，用于LockKey函数 
; X9 v) c' v1 t# w  o
{ 
\\" K* @\\" a\\" i, G% p9 L
        LuData a;* r5 ~1 J' l( H7 t/ ^; X

luRealArray *pRealArray1,*pRealArray2,*pRealArray3;1 k! ]5 a9 G/ I  E

luVOID i,j,k,m,n,u,v;. O4 p% Y6 X8 @; B; x0 a) \

double *pa,*pb,*pc;5 S- V5 L' {& m, W

luMessage pMessage;4 T7 o: D6 D; K7 P- @) O) U

wchar_t wchNum[32];. a( y& Y' o0 j, n4 \

char chNum[32];$ z6 j& f6 L. i, |& J% n

a.BType=luStaData_nil; a.VType=luStaData_nil; a.x=0; 
9 ]. n\\" M' j& l2 i2 y9 P
        switch(theOperator) 
6 @* a- ^- ~/ }3 v% _% ?
        {2 R! g# r' i\\" m% P\\" s* J

case 2:        //重载运算符*  k9 N- o3 j7 B5 X

pRealArray1=(luRealArray *)SearchKey((char *)&(xx->x),sizeof(luVOID),luDynData_realarray);# C0 X- W4 N9 H* V0 Y

pRealArray2=(luRealArray *)SearchKey((char *)&((xx+1)->x),sizeof(luVOID),luDynData_realarray);- R6 O5 b; w) g$ Y$ G0 O( A0 z7 ]7 W

if(!pRealArray1 || !pRealArray2) break;        //对象句柄无效，不是实数数组 
' k8 o! t' F8 n9 B; K. Z) W
                if(pRealArray1->DimLen!=2 || pRealArray2->DimLen!=2) break;        //不是二维实数数组（矩阵） 
% R0 `: s! P; Q' u7 @/ V2 H* J
                if(pRealArray1->Dim[1]!=pRealArray2->Dim[0]) break;        //维数不匹配 
7 g# O- Y  T$ N8 _# X; _7 d; j  k
                pRealArray3=(luRealArray *)NewSysObj(luDynData_realarray,pRealArray1->Dim[0]*pRealArray2->Dim[1],2);        //创建矩阵对象 
. L% s- p9 h& y+ f
                if(!pRealArray3) break;: E1 O% f' B$ }' j* E& L: }

pRealArray3->Dim[0]=pRealArray1->Dim[0]; pRealArray3->Dim[1]=pRealArray2->Dim[1];        //设置矩阵维数大小 
( y3 x- n7 u2 `5 [: G- X2 Y
                pa=pRealArray1->Array; pb=pRealArray2->Array; pc=pRealArray3->Array; 
1 |; V. I, ]# i\\" S
                m=pRealArray1->Dim[0]; n=pRealArray1->Dim[1]; k=pRealArray2->Dim[1];+ Z9 \, @3 C0 {6 h, |9 \

for(i=0; i<m; i++)        //矩阵乘. ^, B# \+ Z5 |

{ 
) A, G, V. x3 \' d
                        for(j=0; j<k; j++)! W9 L; h  I3 T& ^

{/ |% K/ B  z* ^' {: f

u=i*k+j; pc[u]=0.0;: K& ~( Z/ @- @8 C4 K* Q5 H$ W! X* `3 R

for (v=0; v<n; v++) 
# s0 k( y  p/ J\\" [2 n
                                { 
7 s8 Y8 d# z* G
                                        pc[u]=pc[u]+pa[i*n+v]*pb[v*k+j]; 
& @+ [+ j) O! Q( k1 g, \/ B; @6 h
                                } 
0 y( a6 b2 D. l- k( ?2 V; C
                        } 
8 J+ g% O  L* R4 d
                } 
5 W- n: I( K* B! q
                FunReObj(hFor);        //告诉Lu，返回一个动态对象. ?. x- ]$ J8 l5 _' @

a.BType=luDynData_realarray; a.VType=Matrix; a.x=0; *(luVOID *)&(a.x)=(luVOID)pRealArray3; 
2 A- D6 R* @. c8 S9 _
                break;. U, l1 K1 K. S6 N( T  N' G% N% K/ q

case 25:        //重载运算符.* 
3 D) f3 ^( l, _
                pRealArray1=(luRealArray *)SearchKey((char *)&(xx->x),sizeof(luVOID),luDynData_realarray); 
+ \- z/ V# q/ N3 K0 c; g
                pRealArray2=(luRealArray *)SearchKey((char *)&((xx+1)->x),sizeof(luVOID),luDynData_realarray); 
9 t! y  c9 H% v- q' y3 |+ n\\" \' t
                if(!pRealArray1 || !pRealArray2) break;        //对象句柄无效，不是实数数组 
\\" h$ F\\" @$ g7 R8 d0 E9 d( b- @
                if(pRealArray1->DimLen!=2 || pRealArray2->DimLen!=2) break;        //不是二维实数数组（矩阵） 
: R4 B4 }( C; `* Y+ n
                if(pRealArray1->Dim[0]!=pRealArray2->Dim[0] || pRealArray1->Dim[1]!=pRealArray2->Dim[1]) break;        //维数不相同 
\\" R8 Z4 K1 {' c  ^% L0 Q- C
                pRealArray3=(luRealArray *)NewSysObj(luDynData_realarray,pRealArray1->ArrayLen,2);        //创建矩阵对象: r7 m' c9 S2 @4 ?, p7 g

if(!pRealArray3) break;- B# R  G8 A# |

pRealArray3->Dim[0]=pRealArray1->Dim[0]; pRealArray3->Dim[1]=pRealArray1->Dim[1];        //设置矩阵维数大小 
* N3 O# G. ], P6 B  j! |
                for(i=0;i<pRealArray1->ArrayLen;i++) pRealArray3->Array[i]=pRealArray1->Array[i]*pRealArray2->Array[i];//矩阵点乘5 a3 [* g5 j1 M  ~3 Z

FunReObj(hFor);        //告诉Lu，返回一个动态对象2 ?2 J+ b) x& W6 M, g

a.BType=luDynData_realarray; a.VType=Matrix; a.x=0; *(luVOID *)&(a.x)=(luVOID)pRealArray3;$ Q: @1 J7 ^( b0 G

break;) S' w) d2 w# u' U0 u5 t& c

case 46:        //重载函数new 
' s3 l0 \6 k0 E( J, u: \- ]. u: t
                a=ExeOperator(mm,xx,hFor,theOperator,luDynData_realarray);        //直接调用基本类型luDynData_realarray的new函数 
\\" g. Z, X( Q; \* J\\" U# T+ x1 Z. T
                if(a.VType==luDynData_realarray) a.VType=Matrix;        //设置扩展类型为自定义的Matrix类型) p. _0 r7 g$ y5 z3 d

break;, a! Y/ z) Q: B6 N' G& u/ o$ X; S

case 49:        //重载函数o 
\\" Q# J8 T- t# g# C8 o
                pMessage=(luMessage)SearchKey("\0\0\0\0",sizeof(luVOID),luPubKey_User);$ ^- H) P- R  I

if(!pMessage) break;$ F5 x6 }# D5 N9 q

pRealArray1=(luRealArray *)SearchKey((char *)&(xx->x),sizeof(luVOID),luDynData_realarray); 
& v' k# {! A/ D; {9 p7 k0 `
                if(!pRealArray1) break;        //对象句柄无效，不是实数数组8 W3 L1 u$ w. r, ~

if(pRealArray1->DimLen!=2) break;        //不是二维实数数组（矩阵）\\" @7 q5 k9 i4 Y! V/ R

pa=pRealArray1->Array; 
: `+ A4 w$ X3 A8 z9 u+ K7 L/ S7 J
                m=pRealArray1->Dim[0]; n=pRealArray1->Dim[1]; k=0;4 ~! k2 Y9 b: A9 z. o9 e2 ]! R

for(i=0; i<m; i++)        //输出矩阵0 h5 d/ I, C/ K

{\\" @1 U+ ~1 L& s0 ^! P\\" ~

pMessage(L"\r\n"); k+=2; 
3 s6 W' Q0 k  E1 K& {. o* P% b( b
                        for(j=0; j<n; j++) 
+ C6 _3 o5 L  L! A
                        {* }% e3 v8 r7 {& X\\" i5 q3 n

_gcvt_s(chNum,pa[i*n+j],16); 
. w' }* C  v1 t, W- a0 b9 y
                                for(u=0;chNum[u];u++) {wchNum[u]=chNum[u]; k++;} 
  c8 f; j7 ~) @; C
                                wchNum[u]='\0';. [9 W3 _; \9 K8 v\\" h9 ^% W& N

pMessage(wchNum); pMessage(L"  "); k+=2;+ u4 i. u# M1 H

} 
9 b1 X- s\\" a1 t4 [6 _* v
                } 
! a* P) i; v# K
                pMessage(L"\r\n"); k+=2;2 f8 e/ X* [$ d8 ]2 Q8 y

a.BType=luStaData_int64; a.VType=luStaData_int64; a.x=k;        //按函数o的要求，返回输出的字符总数; Y2 r7 @( c: F

break; 
9 A) T8 e# w! k. \5 G
        default:. Y8 |: F6 y+ n4 x  [7 X, E/ k

break; 
8 _& v6 O- v6 F6 ~! s
        }9 \; [$ n  t: t7 W

return a;1 r4 R$ P* [. R1 T# X2 r

} 
  X5 d! ^, ^) L) i! Z4 E
void main(void) 
# \/ i* X) s* j1 \; P- u
{) ?! N4 V, \+ R; R- a2 ~( {: R8 A

void *hFor;                //表达式句柄# T/ X1 r1 k! U* u\\" m( ~4 U

luINT nPara;                //存放表达式的自变量个数! v4 \3 q4 K/ q; k$ l

LuData *pPara;                //存放输入自变量的数组指针 
8 \8 A. }1 E2 X& N. N8 K/ u
        luINT ErrBegin,ErrEnd;        //表达式编译出错的初始位置和结束位置6 f8 b' X5 Z0 _6 i

int ErrCode;                //错误代码 
4 V- E& p* V  y
        void *v; 
5 X7 n. O7 I7 g3 e) n+ 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.]}";//字符串表达式，矩阵乘 
: \9 r& f( H$ m, ], S' Q! d& @
        //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.]}";//字符串表达式，矩阵点乘- g/ U\\" N* n) C, i* D0 g+ F5 V

LuData Val; 
! {% }& l1 H) J& X
        if(!InitLu()) return;        //初始化Lu& ^/ d3 d; j2 ?; t: r\\" n

while(LockKey(Matrix,DelMatrix,OpMatrix)){Matrix++;}        //锁定一个键，用于存储矩阵扩展类型 
3 S9 Q  w8 l; I( Y+ F
 
1 J$ D! ]7 g; U3 q
        Val.BType=luStaData_int64; Val.VType=luStaData_int64; Val.x=Matrix;        //定义整数常量4 I\\" b; h2 I/ v\\" ]7 V' J/ D- \

SetConst(L"matrix",&Val);        //设置整数常量# z7 s7 k7 p# |% \$ d: u

InsertKey("\0\0\0\0",4,luPubKey_User,LuMessage,NULL,NULL,1,v); //使Lu运行时可输出函数信息\\" v4 K: l3 {( o+ ?8 Y

wcout.imbue(locale("chs"));        //设置输出的locale为中文6 o* A# ^9 C; U8 X

! Y% l% i# o( t3 r( U6 n+ j

ErrCode=LuCom(ForStr,0,0,0,hFor,nPara,pPara,ErrBegin,ErrEnd); //编译表达式 
6 }0 [, P4 b8 b
        if(ErrCode). _: |\\" e1 l3 x\\" W0 L; W\\" E

{ 
$ y\\" I5 Q' Y: K; `
                wcout<<L"表达式有错误！错误代码："<<ErrCode<<endl;1 L! N9 i  v0 i% [. f

} 
' g5 w- m- I6 a$ ]3 |* ]) J- q
        else1 H% W( E' `8 |/ j

{, `- y( D4 T! Y3 L: b

LuCal(hFor,pPara);        //计算表达式的值 
# y/ m; F1 C3 i
        } 
% ^% j) y* M/ l
        LockKey(Matrix,NULL,OpMatrix);//解锁键Matrix，本例中，该函数可以不用 
# w( S' o1 Y4 e* v6 O/ u
        FreeLu();                        //释放Lu 
8 T& }5 i+ c9 b, G( r, c# Q+ P$ h7 N
}

习题：

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

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

main(:a,b,c,d,t,i)=% m& e% C+ M2 G0 |\" T; K
a=new[matrix,2,2,data:1.,2.,2.,1.],
5 N1 }* F% k* r& }\" ~/ r
b=new[matrix,2,2,data:2.,1.,1.,2.],
/ r8 ^! r% D) e2 H! f$ i, i, W
c=new[matrix,2,2,data:2/3.,-1/3.,-1/3.,2/3.],
! c' G/ A: \6 H
t=clock(),
) A/ M9 @( s+ M
d=a*b, i=0, while{i<1000000, d=d*c*b, i++},2 j; O/ I- [. I0 C2 P
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\"}";//字符串表达式

复制代码

结果：