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

查看: 8900|回复: 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> k. C) W8 \- N
#include <iostream>
& E0 n, v! l: E) Z( m5 q0 A. B
#include <math.h>7 _6 }9 \3 `' |# E
#include "lu32.h"2 c, H, K% u v* }
: F b z& B! e5 P\\" {
#pragma comment( lib, "lu32.lib" )
& N, C3 s+ Q/ b2 ~' E$ r
% w) I) r0 ?# H6 p% W6 i! \
using namespace std;
\\" E4 c/ M6 v+ V! d% L
+ C/ y! h1 P* C6 J\\" N: v3 l
luKEY Matrix=-1000; //标识矩阵类型，最终的Matrix由LockKey决定
6 k& Y8 |1 u& w
3 ?# A0 M0 M- \- q9 o! q, l
void _stdcall LuMessage(wchar_t *pch)//输出动态库信息，该函数注册到Lu，由Lu二级函数调用 * f6 z1 |7 l+ r# Z8 M\\" }0 [
{7 |2 y\\" J/ W( ?1 H) o- X: i
wcout<<pch;
2 G7 v1 N m q
}
0 \$ L3 T0 r9 P% S8 c j% f1 Y
void _stdcall DelMatrix(void *me) //用于LockKey函数，因为是基于系统内置实数数组创建矩阵，故该函数什么也不做
5 V: z2 o% y% X9 k) I
{
. x7 E/ Y9 u+ V/ a- |
}$ B0 u9 @0 s5 @9 i\\" \# N
LuData _stdcall OpMatrix(luINT mm,LuData *xx,void *hFor,int theOperator) //运算符重载函数，用于LockKey函数7 b, G\\" x2 I% v: p
{/ W b( E% K( J0 D
LuData a;- Z2 c: _4 d. S; B+ u1 _8 x2 q
luRealArray *pRealArray1,*pRealArray2,*pRealArray3;
/ s6 w W/ T, ]; H% k! Q
luVOID i,j,k,m,n,u,v;9 Q& T9 V* t: c( j- B
double *pa,*pb,*pc;7 k/ D! I- o, ]( z7 ^
luMessage pMessage;
' q7 p8 V+ O! \! Y1 t: M7 ?
wchar_t wchNum[32];$ s2 H$ G2 ]$ G0 }4 ~8 b
char chNum[32];\\" T( h\\" `9 \; u2 e1 e8 d
a.BType=luStaData_nil; a.VType=luStaData_nil; a.x=0;
, }( e& U: k* a) R6 W
switch(theOperator)! R7 A. N7 q9 u8 g$ d! `
{
' S+ K l7 \, O0 h
case 2: //重载运算符*
' }% v, S2 Y% m: D/ X
pRealArray1=(luRealArray *)SearchKey((char *)&(xx->x),sizeof(luVOID),luDynData_realarray);# |& h8 y. ~ K- t! w
pRealArray2=(luRealArray *)SearchKey((char *)&((xx+1)->x),sizeof(luVOID),luDynData_realarray);$ X5 N* R+ b8 y\\" ~3 y$ N$ x
if(!pRealArray1 || !pRealArray2) break; //对象句柄无效，不是实数数组, i9 ?3 T: ~% `1 o5 e1 M5 J
if(pRealArray1->DimLen!=2 || pRealArray2->DimLen!=2) break; //不是二维实数数组（矩阵）
8 y% I( o( y, s\\" m/ k
if(pRealArray1->Dim[1]!=pRealArray2->Dim[0]) break; //维数不匹配
/ i2 ?7 x. k% }0 V# _ T
pRealArray3=(luRealArray *)NewSysObj(luDynData_realarray,pRealArray1->Dim[0]*pRealArray2->Dim[1],2); //创建矩阵对象1 |, i: j$ n4 s6 V! n ^; m5 g- q4 f; l+ v
if(!pRealArray3) break;
5 p# E3 P% |2 ]2 z6 C& k
pRealArray3->Dim[0]=pRealArray1->Dim[0]; pRealArray3->Dim[1]=pRealArray2->Dim[1]; //设置矩阵维数大小# A' f; d% ?: {, j$ [
pa=pRealArray1->Array; pb=pRealArray2->Array; pc=pRealArray3->Array;
/ I1 {) x$ t! q
m=pRealArray1->Dim[0]; n=pRealArray1->Dim[1]; k=pRealArray2->Dim[1];
7 f8 y) ?8 {+ ]- f
for(i=0; i<m; i++) //矩阵乘
2 p4 Z/ O8 {, i1 Y0 P* i
{
: b( o5 o& I8 ?
for(j=0; j<k; j++)0 h0 C& x7 J% Q% K$ N* K
{$ i' \+ e7 l0 M z\\" V$ r
u=i*k+j; pc[u]=0.0;
* n% E; s% Z1 R( l5 B3 }* H5 P
for (v=0; v<n; v++)
/ E* l; a1 x4 i$ _7 |/ L
{
/ N4 \9 J2 P$ P5 w x
pc[u]=pc[u]+pa[i*n+v]*pb[v*k+j];
! I& [! U6 q7 r0 Q
}0 D! F% ^$ W: m8 h
}
: R! B. W3 A% f4 w3 J& }& V
}
5 b7 T6 H. X/ }+ o* R
FunReObj(hFor); //告诉Lu，返回一个动态对象
( c3 ^/ j- K( T$ Y. Y4 ~! Q6 d
a.BType=luDynData_realarray; a.VType=Matrix; a.x=0; *(luVOID *)&(a.x)=(luVOID)pRealArray3;
0 z6 ?% |* s& }4 }
break;% K, B2 ]# S+ w, U' ]3 N& X7 q
case 25: //重载运算符.*3 s ]2 c) |$ s. C
pRealArray1=(luRealArray *)SearchKey((char *)&(xx->x),sizeof(luVOID),luDynData_realarray);! w) d% ~+ n. n8 a
pRealArray2=(luRealArray *)SearchKey((char *)&((xx+1)->x),sizeof(luVOID),luDynData_realarray);
; U7 a2 s+ u o- z\\" A\\" R
if(!pRealArray1 || !pRealArray2) break; //对象句柄无效，不是实数数组7 n( k# a7 u* y `
if(pRealArray1->DimLen!=2 || pRealArray2->DimLen!=2) break; //不是二维实数数组（矩阵）
# V. |0 ^\\" y' O& O7 W$ @9 r! q
if(pRealArray1->Dim[0]!=pRealArray2->Dim[0] || pRealArray1->Dim[1]!=pRealArray2->Dim[1]) break; //维数不相同
: Z% ?- N' E5 y: k x1 R
pRealArray3=(luRealArray *)NewSysObj(luDynData_realarray,pRealArray1->ArrayLen,2); //创建矩阵对象
% T\\" J# V; p. F, y/ ?5 C- p
if(!pRealArray3) break;
8 |3 q: Z- `6 G# D; w6 h- d
pRealArray3->Dim[0]=pRealArray1->Dim[0]; pRealArray3->Dim[1]=pRealArray1->Dim[1]; //设置矩阵维数大小
% U( Y# d3 x! Z0 ?) y
for(i=0;i<pRealArray1->ArrayLen;i++) pRealArray3->Array[i]=pRealArray1->Array[i]*pRealArray2->Array[i];//矩阵点乘
- D& f8 v0 d7 }- Z7 y, |2 x
FunReObj(hFor); //告诉Lu，返回一个动态对象
\\" q- ?7 f7 [) J; P: [
a.BType=luDynData_realarray; a.VType=Matrix; a.x=0; *(luVOID *)&(a.x)=(luVOID)pRealArray3;
) ~6 Z8 \. n\\" b3 x\\" D! u7 e
break;9 P+ L. K1 [. W, @$ v/ U5 l
case 46: //重载函数new2 D+ k# [, A+ u8 Z5 [, a+ {5 X4 a
a=ExeOperator(mm,xx,hFor,theOperator,luDynData_realarray); //直接调用基本类型luDynData_realarray的new函数
5 z/ s3 A; w& f4 ^7 F2 C
if(a.VType==luDynData_realarray) a.VType=Matrix; //设置扩展类型为自定义的Matrix类型
. w9 ^8 j/ q: j6 _
break;
( R. T) d* s* J2 y+ q5 H
case 49: //重载函数o
) @3 L6 ^3 S3 ^
pMessage=(luMessage)SearchKey("\0\0\0\0",sizeof(luVOID),luPubKey_User);
8 \9 _& R2 Y0 r
if(!pMessage) break;+ W& \, H( h+ V7 ?
pRealArray1=(luRealArray *)SearchKey((char *)&(xx->x),sizeof(luVOID),luDynData_realarray);
& B6 i& x% }\\" a/ ]1 q
if(!pRealArray1) break; //对象句柄无效，不是实数数组) d9 @2 H$ D: v& i
if(pRealArray1->DimLen!=2) break; //不是二维实数数组（矩阵）$ w0 B- F2 r: b
pa=pRealArray1->Array;
2 }; |* ?2 [* e$ S3 D0 _
m=pRealArray1->Dim[0]; n=pRealArray1->Dim[1]; k=0;
7 M8 T! P1 U2 ?\\" @6 q\\" m$ S' F& K
for(i=0; i<m; i++) //输出矩阵
# Z% n' ~% P6 W2 g- f
{& @\\" D+ `0 G# Y* |& `
pMessage(L"\r\n"); k+=2;8 j+ V, F! V8 G: ]/ }& E
for(j=0; j<n; j++)
& a4 t4 ?: E' J2 M0 o$ D
{. B: H- [! `- Y5 R2 }* b G9 y+ O
_gcvt_s(chNum,pa[i*n+j],16);$ ]( Z' S9 s9 G- k. t9 S
for(u=0;chNum[u];u++) {wchNum[u]=chNum[u]; k++;}
% q* [+ o& j3 N- T7 N4 i
wchNum[u]='\0';' E: B+ x2 v\\" W4 { s
pMessage(wchNum); pMessage(L" "); k+=2;
' h2 U* ~' z2 s( X) o( Y
}
) V% u( p* D. T& \) i0 B: R
}
+ C- X! q' [9 F. M
pMessage(L"\r\n"); k+=2;
( N) V& }7 M+ ?& ]9 C3 `
a.BType=luStaData_int64; a.VType=luStaData_int64; a.x=k; //按函数o的要求，返回输出的字符总数
, a, S$ j\\" H) O\\" ?
break;% S7 \1 I1 L9 W# ]; J {; H( }% Y# u
default:3 j& t7 ~6 f; G5 ]0 ^
break;: m9 w\\" H! M n, m, u
}
! p h0 V Y0 g: |
return a;
5 B; s' o2 e- @7 S! L9 w7 z
}
8 s$ I( |9 x l& h
void main(void)* E; N9 o- M% l4 ]
{) |( X8 _/ [* r\\" W3 p
void *hFor; //表达式句柄
' |, g' q/ A: T8 B# @+ B/ q7 W
luINT nPara; //存放表达式的自变量个数
% w2 N% f5 h9 h9 U8 X. v7 B
LuData *pPara; //存放输入自变量的数组指针. O9 M- T# B3 x4 I a; w# k9 w
luINT ErrBegin,ErrEnd; //表达式编译出错的初始位置和结束位置\\" Q3 o/ s* p- F& M( \& K' v
int ErrCode; //错误代码. k* ~% B8 }4 ?+ @
void *v;4 x# U) ^! R8 ^0 Y: c0 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.]}";//字符串表达式，矩阵乘! k- K8 c7 [+ u8 z. T' X
//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.]}";//字符串表达式，矩阵点乘# K; u' g, b% |, O
LuData Val;% d9 O\\" H7 `9 A% G! W
if(!InitLu()) return; //初始化Lu
. A\\" @: U7 X# y
while(LockKey(Matrix,DelMatrix,OpMatrix)){Matrix++;} //锁定一个键，用于存储矩阵扩展类型
; t: N, F\\" s# X3 T1 ^2 n
' Y- e& k9 p* A3 a\\" Q
Val.BType=luStaData_int64; Val.VType=luStaData_int64; Val.x=Matrix; //定义整数常量) A8 V7 C1 o& r* z- M8 ]7 w
SetConst(L"matrix",&Val); //设置整数常量
$ o' n- T0 n+ `1 s
InsertKey("\0\0\0\0",4,luPubKey_User,LuMessage,NULL,NULL,1,v); //使Lu运行时可输出函数信息\\" `5 J) M3 c+ j$ T% L; N) b, Z
wcout.imbue(locale("chs")); //设置输出的locale为中文6 l7 Z) r% G+ j& W# _: D5 k/ V$ P
) ? N7 w1 e, g% {0 l# Q$ ]
ErrCode=LuCom(ForStr,0,0,0,hFor,nPara,pPara,ErrBegin,ErrEnd); //编译表达式# q: U0 O! Q: W, l' q. z/ t
if(ErrCode)\\" g: o* y6 \' o# |
{, a. y3 ?9 g! k( y& Z0 R\\" W/ s8 V
wcout<<L"表达式有错误！错误代码："<<ErrCode<<endl;
0 y\\" s- f0 G2 P3 \/ ?. W6 H; ?2 Z
}
% h& f. n& a2 [1 n: d
else0 z6 S- s' {, y9 w w- x
{0 C0 u. b5 |3 o! i
LuCal(hFor,pPara); //计算表达式的值
' H9 L8 p' {% [, R9 m/ E, l1 ?& e
}7 R) e3 Z8 _) U! U0 D# E
LockKey(Matrix,NULL,OpMatrix);//解锁键Matrix，本例中，该函数可以不用
: ^, N ^# E! [0 I F\\" S
FreeLu(); //释放Lu1 A; z2 ^\\" Q% ~- X2 i j( u
}

#include <windows.h>  k. C) W8 \- N

#include <iostream> 
& E0 n, v! l: E) Z( m5 q0 A. B
#include <math.h>7 _6 }9 \3 `' |# E

#include "lu32.h"2 c, H, K% u  v* }

: F  b  z& B! e5 P\\" {

#pragma comment( lib, "lu32.lib" ) 
& N, C3 s+ Q/ b2 ~' E$ r
 
% w) I) r0 ?# H6 p% W6 i! \
using namespace std; 
\\" E4 c/ M6 v+ V! d% L
+ C/ y! h1 P* C6 J\\" N: v3 l

luKEY Matrix=-1000;        //标识矩阵类型，最终的Matrix由LockKey决定 
6 k& Y8 |1 u& w
3 ?# A0 M0 M- \- q9 o! q, l

void _stdcall LuMessage(wchar_t *pch)//输出动态库信息，该函数注册到Lu，由Lu二级函数调用 * f6 z1 |7 l+ r# Z8 M\\" }0 [

{7 |2 y\\" J/ W( ?1 H) o- X: i

wcout<<pch; 
2 G7 v1 N  m  q
} 
0 \$ L3 T0 r9 P% S8 c  j% f1 Y
void _stdcall DelMatrix(void *me)        //用于LockKey函数，因为是基于系统内置实数数组创建矩阵，故该函数什么也不做 
5 V: z2 o% y% X9 k) I
{ 
. x7 E/ Y9 u+ V/ a- |
}$ B0 u9 @0 s5 @9 i\\" \# N

LuData _stdcall OpMatrix(luINT mm,LuData *xx,void *hFor,int theOperator)        //运算符重载函数，用于LockKey函数7 b, G\\" x2 I% v: p

{/ W  b( E% K( J0 D

LuData a;- Z2 c: _4 d. S; B+ u1 _8 x2 q

luRealArray *pRealArray1,*pRealArray2,*pRealArray3; 
/ s6 w  W/ T, ]; H% k! Q
        luVOID i,j,k,m,n,u,v;9 Q& T9 V* t: c( j- B

double *pa,*pb,*pc;7 k/ D! I- o, ]( z7 ^

luMessage pMessage; 
' q7 p8 V+ O! \! Y1 t: M7 ?
        wchar_t wchNum[32];$ s2 H$ G2 ]$ G0 }4 ~8 b

char chNum[32];\\" T( h\\" `9 \; u2 e1 e8 d

a.BType=luStaData_nil; a.VType=luStaData_nil; a.x=0; 
, }( e& U: k* a) R6 W
        switch(theOperator)! R7 A. N7 q9 u8 g$ d! `

{ 
' S+ K  l7 \, O0 h
        case 2:        //重载运算符* 
' }% v, S2 Y% m: D/ X
                pRealArray1=(luRealArray *)SearchKey((char *)&(xx->x),sizeof(luVOID),luDynData_realarray);# |& h8 y. ~  K- t! w

pRealArray2=(luRealArray *)SearchKey((char *)&((xx+1)->x),sizeof(luVOID),luDynData_realarray);$ X5 N* R+ b8 y\\" ~3 y$ N$ x

if(!pRealArray1 || !pRealArray2) break;        //对象句柄无效，不是实数数组, i9 ?3 T: ~% `1 o5 e1 M5 J

if(pRealArray1->DimLen!=2 || pRealArray2->DimLen!=2) break;        //不是二维实数数组（矩阵） 
8 y% I( o( y, s\\" m/ k
                if(pRealArray1->Dim[1]!=pRealArray2->Dim[0]) break;        //维数不匹配 
/ i2 ?7 x. k% }0 V# _  T
                pRealArray3=(luRealArray *)NewSysObj(luDynData_realarray,pRealArray1->Dim[0]*pRealArray2->Dim[1],2);        //创建矩阵对象1 |, i: j$ n4 s6 V! n  ^; m5 g- q4 f; l+ v

if(!pRealArray3) break; 
5 p# E3 P% |2 ]2 z6 C& k
                pRealArray3->Dim[0]=pRealArray1->Dim[0]; pRealArray3->Dim[1]=pRealArray2->Dim[1];        //设置矩阵维数大小# A' f; d% ?: {, j$ [

pa=pRealArray1->Array; pb=pRealArray2->Array; pc=pRealArray3->Array; 
/ I1 {) x$ t! q
                m=pRealArray1->Dim[0]; n=pRealArray1->Dim[1]; k=pRealArray2->Dim[1]; 
7 f8 y) ?8 {+ ]- f
                for(i=0; i<m; i++)        //矩阵乘 
2 p4 Z/ O8 {, i1 Y0 P* i
                { 
: b( o5 o& I8 ?
                        for(j=0; j<k; j++)0 h0 C& x7 J% Q% K$ N* K

{$ i' \+ e7 l0 M  z\\" V$ r

u=i*k+j; pc[u]=0.0; 
* n% E; s% Z1 R( l5 B3 }* H5 P
                                for (v=0; v<n; v++) 
/ E* l; a1 x4 i$ _7 |/ L
                                { 
/ N4 \9 J2 P$ P5 w  x
                                        pc[u]=pc[u]+pa[i*n+v]*pb[v*k+j]; 
! I& [! U6 q7 r0 Q
                                }0 D! F% ^$ W: m8 h

} 
: R! B. W3 A% f4 w3 J& }& V
                } 
5 b7 T6 H. X/ }+ o* R
                FunReObj(hFor);        //告诉Lu，返回一个动态对象 
( c3 ^/ j- K( T$ Y. Y4 ~! Q6 d
                a.BType=luDynData_realarray; a.VType=Matrix; a.x=0; *(luVOID *)&(a.x)=(luVOID)pRealArray3; 
0 z6 ?% |* s& }4 }
                break;% K, B2 ]# S+ w, U' ]3 N& X7 q

case 25:        //重载运算符.*3 s  ]2 c) |$ s. C

pRealArray1=(luRealArray *)SearchKey((char *)&(xx->x),sizeof(luVOID),luDynData_realarray);! w) d% ~+ n. n8 a

pRealArray2=(luRealArray *)SearchKey((char *)&((xx+1)->x),sizeof(luVOID),luDynData_realarray); 
; U7 a2 s+ u  o- z\\" A\\" R
                if(!pRealArray1 || !pRealArray2) break;        //对象句柄无效，不是实数数组7 n( k# a7 u* y  `

if(pRealArray1->DimLen!=2 || pRealArray2->DimLen!=2) break;        //不是二维实数数组（矩阵） 
# V. |0 ^\\" y' O& O7 W$ @9 r! q
                if(pRealArray1->Dim[0]!=pRealArray2->Dim[0] || pRealArray1->Dim[1]!=pRealArray2->Dim[1]) break;        //维数不相同 
: Z% ?- N' E5 y: k  x1 R
                pRealArray3=(luRealArray *)NewSysObj(luDynData_realarray,pRealArray1->ArrayLen,2);        //创建矩阵对象 
% T\\" J# V; p. F, y/ ?5 C- p
                if(!pRealArray3) break; 
8 |3 q: Z- `6 G# D; w6 h- d
                pRealArray3->Dim[0]=pRealArray1->Dim[0]; pRealArray3->Dim[1]=pRealArray1->Dim[1];        //设置矩阵维数大小 
% U( Y# d3 x! Z0 ?) y
                for(i=0;i<pRealArray1->ArrayLen;i++) pRealArray3->Array[i]=pRealArray1->Array[i]*pRealArray2->Array[i];//矩阵点乘 
- D& f8 v0 d7 }- Z7 y, |2 x
                FunReObj(hFor);        //告诉Lu，返回一个动态对象 
\\" q- ?7 f7 [) J; P: [
                a.BType=luDynData_realarray; a.VType=Matrix; a.x=0; *(luVOID *)&(a.x)=(luVOID)pRealArray3; 
) ~6 Z8 \. n\\" b3 x\\" D! u7 e
                break;9 P+ L. K1 [. W, @$ v/ U5 l

case 46:        //重载函数new2 D+ k# [, A+ u8 Z5 [, a+ {5 X4 a

a=ExeOperator(mm,xx,hFor,theOperator,luDynData_realarray);        //直接调用基本类型luDynData_realarray的new函数 
5 z/ s3 A; w& f4 ^7 F2 C
                if(a.VType==luDynData_realarray) a.VType=Matrix;        //设置扩展类型为自定义的Matrix类型 
. w9 ^8 j/ q: j6 _
                break; 
( R. T) d* s* J2 y+ q5 H
        case 49:        //重载函数o 
) @3 L6 ^3 S3 ^
                pMessage=(luMessage)SearchKey("\0\0\0\0",sizeof(luVOID),luPubKey_User); 
8 \9 _& R2 Y0 r
                if(!pMessage) break;+ W& \, H( h+ V7 ?

pRealArray1=(luRealArray *)SearchKey((char *)&(xx->x),sizeof(luVOID),luDynData_realarray); 
& B6 i& x% }\\" a/ ]1 q
                if(!pRealArray1) break;        //对象句柄无效，不是实数数组) d9 @2 H$ D: v& i

if(pRealArray1->DimLen!=2) break;        //不是二维实数数组（矩阵）$ w0 B- F2 r: b

pa=pRealArray1->Array; 
2 }; |* ?2 [* e$ S3 D0 _
                m=pRealArray1->Dim[0]; n=pRealArray1->Dim[1]; k=0; 
7 M8 T! P1 U2 ?\\" @6 q\\" m$ S' F& K
                for(i=0; i<m; i++)        //输出矩阵 
# Z% n' ~% P6 W2 g- f
                {& @\\" D+ `0 G# Y* |& `

pMessage(L"\r\n"); k+=2;8 j+ V, F! V8 G: ]/ }& E

for(j=0; j<n; j++) 
& a4 t4 ?: E' J2 M0 o$ D
                        {. B: H- [! `- Y5 R2 }* b  G9 y+ O

_gcvt_s(chNum,pa[i*n+j],16);$ ]( Z' S9 s9 G- k. t9 S

for(u=0;chNum[u];u++) {wchNum[u]=chNum[u]; k++;} 
% q* [+ o& j3 N- T7 N4 i
                                wchNum[u]='\0';' E: B+ x2 v\\" W4 {  s

pMessage(wchNum); pMessage(L"  "); k+=2; 
' h2 U* ~' z2 s( X) o( Y
                        } 
) V% u( p* D. T& \) i0 B: R
                } 
+ C- X! q' [9 F. M
                pMessage(L"\r\n"); k+=2; 
( N) V& }7 M+ ?& ]9 C3 `
                a.BType=luStaData_int64; a.VType=luStaData_int64; a.x=k;        //按函数o的要求，返回输出的字符总数 
, a, S$ j\\" H) O\\" ?
                break;% S7 \1 I1 L9 W# ]; J  {; H( }% Y# u

default:3 j& t7 ~6 f; G5 ]0 ^

break;: m9 w\\" H! M  n, m, u

} 
! p  h0 V  Y0 g: |
        return a; 
5 B; s' o2 e- @7 S! L9 w7 z
} 
8 s$ I( |9 x  l& h
void main(void)* E; N9 o- M% l4 ]

{) |( X8 _/ [* r\\" W3 p

void *hFor;                //表达式句柄 
' |, g' q/ A: T8 B# @+ B/ q7 W
        luINT nPara;                //存放表达式的自变量个数 
% w2 N% f5 h9 h9 U8 X. v7 B
        LuData *pPara;                //存放输入自变量的数组指针. O9 M- T# B3 x4 I  a; w# k9 w

luINT ErrBegin,ErrEnd;        //表达式编译出错的初始位置和结束位置\\" Q3 o/ s* p- F& M( \& K' v

int ErrCode;                //错误代码. k* ~% B8 }4 ?+ @

void *v;4 x# U) ^! R8 ^0 Y: c0 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.]}";//字符串表达式，矩阵乘! k- K8 c7 [+ u8 z. T' X

//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.]}";//字符串表达式，矩阵点乘# K; u' g, b% |, O

LuData Val;% d9 O\\" H7 `9 A% G! W

if(!InitLu()) return;        //初始化Lu 
. A\\" @: U7 X# y
        while(LockKey(Matrix,DelMatrix,OpMatrix)){Matrix++;}        //锁定一个键，用于存储矩阵扩展类型 
; t: N, F\\" s# X3 T1 ^2 n
' Y- e& k9 p* A3 a\\" Q

Val.BType=luStaData_int64; Val.VType=luStaData_int64; Val.x=Matrix;        //定义整数常量) A8 V7 C1 o& r* z- M8 ]7 w

SetConst(L"matrix",&Val);        //设置整数常量 
$ o' n- T0 n+ `1 s
        InsertKey("\0\0\0\0",4,luPubKey_User,LuMessage,NULL,NULL,1,v); //使Lu运行时可输出函数信息\\" `5 J) M3 c+ j$ T% L; N) b, Z

wcout.imbue(locale("chs"));        //设置输出的locale为中文6 l7 Z) r% G+ j& W# _: D5 k/ V$ P

) ?  N7 w1 e, g% {0 l# Q$ ]
        ErrCode=LuCom(ForStr,0,0,0,hFor,nPara,pPara,ErrBegin,ErrEnd); //编译表达式# q: U0 O! Q: W, l' q. z/ t

if(ErrCode)\\" g: o* y6 \' o# |

{, a. y3 ?9 g! k( y& Z0 R\\" W/ s8 V

wcout<<L"表达式有错误！错误代码："<<ErrCode<<endl; 
0 y\\" s- f0 G2 P3 \/ ?. W6 H; ?2 Z
        } 
% h& f. n& a2 [1 n: d
        else0 z6 S- s' {, y9 w  w- x

{0 C0 u. b5 |3 o! i

LuCal(hFor,pPara);        //计算表达式的值 
' H9 L8 p' {% [, R9 m/ E, l1 ?& e
        }7 R) e3 Z8 _) U! U0 D# E

LockKey(Matrix,NULL,OpMatrix);//解锁键Matrix，本例中，该函数可以不用 
: ^, N  ^# E! [0 I  F\\" S
        FreeLu();                        //释放Lu1 A; z2 ^\\" Q% ~- X2 i  j( u

}

习题：

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

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

main(:a,b,c,d,t,i)=4 U1 p* ]! P7 O |1 n3 p. j- Q
a=new[matrix,2,2,data:1.,2.,2.,1.],
; \, h. Y7 E4 H
b=new[matrix,2,2,data:2.,1.,1.,2.],
! U9 B: U, [, Q+ V% A
c=new[matrix,2,2,data:2/3.,-1/3.,-1/3.,2/3.],8 e o# W/ \' L1 T
t=clock(),
0 K2 Y' L) E4 j$ K
d=a*b, i=0, while{i<1000000, d=d*c*b, i++},
& b9 W8 Q* z0 w& t7 w- p1 n
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\"}";//字符串表达式

复制代码

结果：