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

查看: 8897|回复: 0

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>
; n5 G+ M3 Z; C% c$ r# z
#include <iostream>( p a2 R+ y2 c6 f7 W
#include <math.h>\\" ?# B9 r6 [) ^7 ^' [\\" q5 H
#include "lu32.h"5 h3 H$ `2 D4 q+ I O
( ^% c\\" m/ h4 q) i
#pragma comment( lib, "lu32.lib" )& h9 p* R* f6 j: {4 l2 I4 U+ K+ _
9 w$ d! n% m1 v( J' ]- w
using namespace std;
8 n! l. L, t8 g
6 Z\\" K0 B# J g/ C4 D5 z' I
luKEY Matrix=-1000; //标识矩阵类型，最终的Matrix由LockKey决定
# ]% c0 p2 I# r1 } N( n2 z
$ r7 |. I2 |$ p, A\\" d
void _stdcall LuMessage(wchar_t *pch)//输出动态库信息，该函数注册到Lu，由Lu二级函数调用 # y% z' \2 u. ?- I4 y# \
{
1 x; W# H1 L2 T& \3 i
wcout<<pch;: ^, ]+ j6 N. m% v# |2 @
}
/ o7 @ q. A* ]$ A1 i3 t& K+ k
void _stdcall DelMatrix(void *me) //用于LockKey函数，因为是基于系统内置实数数组创建矩阵，故该函数什么也不做
\\" [ a- R1 z0 ]1 r
{
7 e# b6 [% r' H' Z( f% Y\\" j\\" S& _
}6 S0 B, o( Y& [
LuData _stdcall OpMatrix(luINT mm,LuData *xx,void *hFor,int theOperator) //运算符重载函数，用于LockKey函数
% s7 o- h) ~; y% p; u4 {
{/ {0 {- s4 b; i7 F
LuData a;* O! P T4 x& f\\" t7 c* [/ |
luRealArray *pRealArray1,*pRealArray2,*pRealArray3;
; n+ E; h/ ]6 F0 Q$ ~. V\\" d
luVOID i,j,k,m,n,u,v;9 W+ D9 ]1 e7 g2 d& m
double *pa,*pb,*pc;
+ L/ N) c# j' N# |$ |% s- R
luMessage pMessage;
8 W a- E: I8 C2 F, i* V8 U) L% A
wchar_t wchNum[32];
5 f# o7 @3 R\\" a' R( }5 G: L
char chNum[32];& g\\" f' y4 G$ f7 `
a.BType=luStaData_nil; a.VType=luStaData_nil; a.x=0;
7 k3 u7 ^6 }& G* z5 `- V4 X+ h; g% u
switch(theOperator)1 m+ E& Q/ F/ K- c) m, ~1 H
{3 i# m' W# n: i2 y8 T- ~, `; y! I
case 2: //重载运算符*1 e0 }* M% y- _- \5 L
pRealArray1=(luRealArray *)SearchKey((char *)&(xx->x),sizeof(luVOID),luDynData_realarray);8 q3 I$ v+ ^' S7 h `/ D) B
pRealArray2=(luRealArray *)SearchKey((char *)&((xx+1)->x),sizeof(luVOID),luDynData_realarray);
, f' }\\" O/ j8 \5 v* m
if(!pRealArray1 || !pRealArray2) break; //对象句柄无效，不是实数数组& G8 I7 ]. [- t+ W
if(pRealArray1->DimLen!=2 || pRealArray2->DimLen!=2) break; //不是二维实数数组（矩阵）
- m' d& P8 d+ g* B) {; J3 {
if(pRealArray1->Dim[1]!=pRealArray2->Dim[0]) break; //维数不匹配
3 C f4 L1 T3 }/ Y
pRealArray3=(luRealArray *)NewSysObj(luDynData_realarray,pRealArray1->Dim[0]*pRealArray2->Dim[1],2); //创建矩阵对象: x3 d! W5 \6 n& a J) `; `% `0 m
if(!pRealArray3) break;5 O- G- q; I' q% n
pRealArray3->Dim[0]=pRealArray1->Dim[0]; pRealArray3->Dim[1]=pRealArray2->Dim[1]; //设置矩阵维数大小( q* T0 Z' \2 I$ ?
pa=pRealArray1->Array; pb=pRealArray2->Array; pc=pRealArray3->Array;* U$ z\\" h# I8 ~; z; p
m=pRealArray1->Dim[0]; n=pRealArray1->Dim[1]; k=pRealArray2->Dim[1];3 m! C( A, f' ~: P( t: a2 m+ W
for(i=0; i<m; i++) //矩阵乘- i+ Y9 q/ S0 }+ u
{
* E' c `& c+ Z* o
for(j=0; j<k; j++)& b: o% q3 `6 T) c\\" b6 d
{5 l/ A2 f% `9 o) W% D, Z+ v: H$ y
u=i*k+j; pc[u]=0.0;, [2 m. G+ L7 N
for (v=0; v<n; v++)
# c, O( t9 I\\" M
{
& t+ s' o8 r* V% o% \
pc[u]=pc[u]+pa[i*n+v]*pb[v*k+j];- ^7 ^0 v' J% B3 {3 u4 {0 X
}
7 @4 s# m% s\\" R) F5 L4 \7 l( S
}. z d$ K8 N; J) |$ ~
}\\" V6 `' P. F' I8 \ |% g) F
FunReObj(hFor); //告诉Lu，返回一个动态对象
* ?3 Z( q: l2 q9 U, T
a.BType=luDynData_realarray; a.VType=Matrix; a.x=0; *(luVOID *)&(a.x)=(luVOID)pRealArray3;
2 Q2 b: c: b8 @1 Y1 s
break;. N9 z0 ?; D) P- \9 `. ~' @
case 25: //重载运算符.*' {4 o* V5 \0 @& O9 j5 v
pRealArray1=(luRealArray *)SearchKey((char *)&(xx->x),sizeof(luVOID),luDynData_realarray);
- j* c/ x3 O' `2 W4 }
pRealArray2=(luRealArray *)SearchKey((char *)&((xx+1)->x),sizeof(luVOID),luDynData_realarray);
! R6 d6 b s& d/ m
if(!pRealArray1 || !pRealArray2) break; //对象句柄无效，不是实数数组
/ e% i) c( R\\" U6 a4 N/ N6 f2 r
if(pRealArray1->DimLen!=2 || pRealArray2->DimLen!=2) break; //不是二维实数数组（矩阵）4 v% M7 |/ f1 R* Y4 n0 @- C! r
if(pRealArray1->Dim[0]!=pRealArray2->Dim[0] || pRealArray1->Dim[1]!=pRealArray2->Dim[1]) break; //维数不相同
6 b2 F4 \. C/ X4 N
pRealArray3=(luRealArray *)NewSysObj(luDynData_realarray,pRealArray1->ArrayLen,2); //创建矩阵对象
& y. Q) X+ T1 Z7 Z% J
if(!pRealArray3) break;; l\\" t, u$ s. N9 _6 D\\" X; m
pRealArray3->Dim[0]=pRealArray1->Dim[0]; pRealArray3->Dim[1]=pRealArray1->Dim[1]; //设置矩阵维数大小
7 ?4 k9 _5 }' v) C\\" J- Y
for(i=0;i<pRealArray1->ArrayLen;i++) pRealArray3->Array[i]=pRealArray1->Array[i]*pRealArray2->Array[i];//矩阵点乘
, ~' m+ ?2 }+ E& m0 S+ O, [/ Q, t
FunReObj(hFor); //告诉Lu，返回一个动态对象
: \8 f$ y2 ?% T* S+ O% T
a.BType=luDynData_realarray; a.VType=Matrix; a.x=0; *(luVOID *)&(a.x)=(luVOID)pRealArray3;( W z% x! [! x
break;
2 `3 W( e) u# V. K* r
case 46: //重载函数new
* ]! U2 x; ^' I7 y6 m9 c
a=ExeOperator(mm,xx,hFor,theOperator,luDynData_realarray); //直接调用基本类型luDynData_realarray的new函数 R7 U8 K4 p s/ e( S3 |
if(a.VType==luDynData_realarray) a.VType=Matrix; //设置扩展类型为自定义的Matrix类型: _8 q$ e4 A' V2 C+ n! }% B* B
break;* |: `7 C+ j! l/ q
case 49: //重载函数o0 M7 C( N0 P. z
pMessage=(luMessage)SearchKey("\0\0\0\0",sizeof(luVOID),luPubKey_User);
9 r\\" u) \. U7 ^% j4 p8 d$ m. u5 W' l
if(!pMessage) break;
9 J: F3 I4 B. v' ^
pRealArray1=(luRealArray *)SearchKey((char *)&(xx->x),sizeof(luVOID),luDynData_realarray);3 D8 ^& U7 ]* n) \
if(!pRealArray1) break; //对象句柄无效，不是实数数组# _\\" G4 `$ C0 b8 L. G6 A
if(pRealArray1->DimLen!=2) break; //不是二维实数数组（矩阵）2 R7 i\\" B) a7 R+ m: r9 `
pa=pRealArray1->Array;
, c' m! p9 W+ @- D1 F, @% E
m=pRealArray1->Dim[0]; n=pRealArray1->Dim[1]; k=0;1 E: B9 p' Z( I0 e5 \
for(i=0; i<m; i++) //输出矩阵: }7 F0 d- i5 C6 v8 `2 ~\\" p
{0 u) R7 s: C3 U, y) ^
pMessage(L"\r\n"); k+=2;
2 a( \0 i! @& T2 t9 n/ e+ {& D
for(j=0; j<n; j++)
' w6 P$ A' @8 f4 b- b& \9 g x
{
6 r, I( T\\" N4 f1 w4 u) ?/ k, Y$ ~
_gcvt_s(chNum,pa[i*n+j],16);
* p7 F- A! H* i5 E( F
for(u=0;chNum[u];u++) {wchNum[u]=chNum[u]; k++;}
& ]) I0 d4 k/ ~4 a
wchNum[u]='\0';0 D- b. l1 r8 W8 z8 O. H; p. f
pMessage(wchNum); pMessage(L" "); k+=2;+ \- r1 T9 J4 `
}
) L0 ^) K0 N+ l! {0 q\\" \9 h
}
5 v; u3 X T7 e2 P- g$ K
pMessage(L"\r\n"); k+=2;
0 s. n) A( ^7 l; Q ]1 j' t
a.BType=luStaData_int64; a.VType=luStaData_int64; a.x=k; //按函数o的要求，返回输出的字符总数
) V$ e A/ e: m; e5 j( {1 J& }
break;
4 a3 ^( z+ S( G' ?4 [ H\\" h- K: f
default:8 P% e& _\\" j* C, i# R9 l; l, b
break;
3 |7 q& e. s5 T5 g0 d) u
}8 l, V9 W- ^+ q$ ~1 _
return a;
, F$ ~: B3 F; t, X* j4 i
}2 w4 B; h0 @! I3 h0 m
void main(void); [3 U- n/ B F% x5 o
{, J\\" R, T; J7 W) n+ ^1 ]# s3 z u
void *hFor; //表达式句柄
: Z& D\\" E) E3 N3 p\\" b, m) J W- M
luINT nPara; //存放表达式的自变量个数. W- ]/ C' P' b1 J( ], Q4 U H
LuData *pPara; //存放输入自变量的数组指针$ X) ^& ~7 m) y& g
luINT ErrBegin,ErrEnd; //表达式编译出错的初始位置和结束位置0 H1 L& L+ |2 G1 H5 O- N. r
int ErrCode; //错误代码, e/ k$ y. ^# X5 K, V2 k Y
void *v;
\\" e x4 z1 b! r$ w3 x
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( s, V; O4 ]' ]! n$ g
//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.]}";//字符串表达式，矩阵点乘5 W8 g: @/ w# w) s
LuData Val;0 T8 i/ R: g/ V8 G2 S- ^6 Z! z& {
if(!InitLu()) return; //初始化Lu
5 t) L. m X4 ]( z0 x( w! ^
while(LockKey(Matrix,DelMatrix,OpMatrix)){Matrix++;} //锁定一个键，用于存储矩阵扩展类型
5 E& T, X2 Y% q5 s
: D9 X% w% R3 _4 x
Val.BType=luStaData_int64; Val.VType=luStaData_int64; Val.x=Matrix; //定义整数常量2 o& x* ~% E% K3 F1 I( V; U8 z
SetConst(L"matrix",&Val); //设置整数常量
7 s* j, \6 V' `9 w
InsertKey("\0\0\0\0",4,luPubKey_User,LuMessage,NULL,NULL,1,v); //使Lu运行时可输出函数信息5 a% X; V& o) Y( p9 k7 W
wcout.imbue(locale("chs")); //设置输出的locale为中文
, b9 J/ a/ @, h8 x* F% ^
% n, [3 o, G- \3 T
ErrCode=LuCom(ForStr,0,0,0,hFor,nPara,pPara,ErrBegin,ErrEnd); //编译表达式 w: A. I6 X& M\\" f9 H
if(ErrCode)
\\" k. P$ C) R; S0 ?/ I
{! o7 s1 V( @; m+ B
wcout<<L"表达式有错误！错误代码："<<ErrCode<<endl;
' ?6 e0 c5 b6 N0 G) _$ ^$ ]4 P
}
6 D. Z8 s( x; v- v2 J2 N0 Z: k4 Z
else2 H# n5 x9 |9 q. o$ p! K
{& J\\" G& h) ], v0 o; D
LuCal(hFor,pPara); //计算表达式的值
- q8 @* u4 q/ y. Z
}3 u+ o, x; H. V1 z) n
LockKey(Matrix,NULL,OpMatrix);//解锁键Matrix，本例中，该函数可以不用0 o& S# o\\" z# [
FreeLu(); //释放Lu# n: ?, ^9 E\\" q5 j; d, \- d
}

#include <windows.h> 
; n5 G+ M3 Z; C% c$ r# z
#include <iostream>( p  a2 R+ y2 c6 f7 W

#include <math.h>\\" ?# B9 r6 [) ^7 ^' [\\" q5 H

#include "lu32.h"5 h3 H$ `2 D4 q+ I  O

( ^% c\\" m/ h4 q) i
#pragma comment( lib, "lu32.lib" )& h9 p* R* f6 j: {4 l2 I4 U+ K+ _

9 w$ d! n% m1 v( J' ]- w

using namespace std; 
8 n! l. L, t8 g
 
6 Z\\" K0 B# J  g/ C4 D5 z' I
luKEY Matrix=-1000;        //标识矩阵类型，最终的Matrix由LockKey决定 
# ]% c0 p2 I# r1 }  N( n2 z
$ r7 |. I2 |$ p, A\\" d

void _stdcall LuMessage(wchar_t *pch)//输出动态库信息，该函数注册到Lu，由Lu二级函数调用 # y% z' \2 u. ?- I4 y# \

{ 
1 x; W# H1 L2 T& \3 i
        wcout<<pch;: ^, ]+ j6 N. m% v# |2 @

} 
/ o7 @  q. A* ]$ A1 i3 t& K+ k
void _stdcall DelMatrix(void *me)        //用于LockKey函数，因为是基于系统内置实数数组创建矩阵，故该函数什么也不做 
\\" [  a- R1 z0 ]1 r
{ 
7 e# b6 [% r' H' Z( f% Y\\" j\\" S& _
}6 S0 B, o( Y& [

LuData _stdcall OpMatrix(luINT mm,LuData *xx,void *hFor,int theOperator)        //运算符重载函数，用于LockKey函数 
% s7 o- h) ~; y% p; u4 {
{/ {0 {- s4 b; i7 F

LuData a;* O! P  T4 x& f\\" t7 c* [/ |

luRealArray *pRealArray1,*pRealArray2,*pRealArray3; 
; n+ E; h/ ]6 F0 Q$ ~. V\\" d
        luVOID i,j,k,m,n,u,v;9 W+ D9 ]1 e7 g2 d& m

double *pa,*pb,*pc; 
+ L/ N) c# j' N# |$ |% s- R
        luMessage pMessage; 
8 W  a- E: I8 C2 F, i* V8 U) L% A
        wchar_t wchNum[32]; 
5 f# o7 @3 R\\" a' R( }5 G: L
        char chNum[32];& g\\" f' y4 G$ f7 `

a.BType=luStaData_nil; a.VType=luStaData_nil; a.x=0; 
7 k3 u7 ^6 }& G* z5 `- V4 X+ h; g% u
        switch(theOperator)1 m+ E& Q/ F/ K- c) m, ~1 H

{3 i# m' W# n: i2 y8 T- ~, `; y! I

case 2:        //重载运算符*1 e0 }* M% y- _- \5 L

pRealArray1=(luRealArray *)SearchKey((char *)&(xx->x),sizeof(luVOID),luDynData_realarray);8 q3 I$ v+ ^' S7 h  `/ D) B

pRealArray2=(luRealArray *)SearchKey((char *)&((xx+1)->x),sizeof(luVOID),luDynData_realarray); 
, f' }\\" O/ j8 \5 v* m
                if(!pRealArray1 || !pRealArray2) break;        //对象句柄无效，不是实数数组& G8 I7 ]. [- t+ W

if(pRealArray1->DimLen!=2 || pRealArray2->DimLen!=2) break;        //不是二维实数数组（矩阵） 
- m' d& P8 d+ g* B) {; J3 {
                if(pRealArray1->Dim[1]!=pRealArray2->Dim[0]) break;        //维数不匹配 
3 C  f4 L1 T3 }/ Y
                pRealArray3=(luRealArray *)NewSysObj(luDynData_realarray,pRealArray1->Dim[0]*pRealArray2->Dim[1],2);        //创建矩阵对象: x3 d! W5 \6 n& a  J) `; `% `0 m

if(!pRealArray3) break;5 O- G- q; I' q% n

pRealArray3->Dim[0]=pRealArray1->Dim[0]; pRealArray3->Dim[1]=pRealArray2->Dim[1];        //设置矩阵维数大小( q* T0 Z' \2 I$ ?

pa=pRealArray1->Array; pb=pRealArray2->Array; pc=pRealArray3->Array;* U$ z\\" h# I8 ~; z; p

m=pRealArray1->Dim[0]; n=pRealArray1->Dim[1]; k=pRealArray2->Dim[1];3 m! C( A, f' ~: P( t: a2 m+ W

for(i=0; i<m; i++)        //矩阵乘- i+ Y9 q/ S0 }+ u

{ 
* E' c  `& c+ Z* o
                        for(j=0; j<k; j++)& b: o% q3 `6 T) c\\" b6 d

{5 l/ A2 f% `9 o) W% D, Z+ v: H$ y

u=i*k+j; pc[u]=0.0;, [2 m. G+ L7 N

for (v=0; v<n; v++) 
# c, O( t9 I\\" M
                                { 
& t+ s' o8 r* V% o% \
                                        pc[u]=pc[u]+pa[i*n+v]*pb[v*k+j];- ^7 ^0 v' J% B3 {3 u4 {0 X

} 
7 @4 s# m% s\\" R) F5 L4 \7 l( S
                        }. z  d$ K8 N; J) |$ ~

}\\" V6 `' P. F' I8 \  |% g) F

FunReObj(hFor);        //告诉Lu，返回一个动态对象 
* ?3 Z( q: l2 q9 U, T
                a.BType=luDynData_realarray; a.VType=Matrix; a.x=0; *(luVOID *)&(a.x)=(luVOID)pRealArray3; 
2 Q2 b: c: b8 @1 Y1 s
                break;. N9 z0 ?; D) P- \9 `. ~' @

case 25:        //重载运算符.*' {4 o* V5 \0 @& O9 j5 v

pRealArray1=(luRealArray *)SearchKey((char *)&(xx->x),sizeof(luVOID),luDynData_realarray); 
- j* c/ x3 O' `2 W4 }
                pRealArray2=(luRealArray *)SearchKey((char *)&((xx+1)->x),sizeof(luVOID),luDynData_realarray); 
! R6 d6 b  s& d/ m
                if(!pRealArray1 || !pRealArray2) break;        //对象句柄无效，不是实数数组 
/ e% i) c( R\\" U6 a4 N/ N6 f2 r
                if(pRealArray1->DimLen!=2 || pRealArray2->DimLen!=2) break;        //不是二维实数数组（矩阵）4 v% M7 |/ f1 R* Y4 n0 @- C! r

if(pRealArray1->Dim[0]!=pRealArray2->Dim[0] || pRealArray1->Dim[1]!=pRealArray2->Dim[1]) break;        //维数不相同 
6 b2 F4 \. C/ X4 N
                pRealArray3=(luRealArray *)NewSysObj(luDynData_realarray,pRealArray1->ArrayLen,2);        //创建矩阵对象 
& y. Q) X+ T1 Z7 Z% J
                if(!pRealArray3) break;; l\\" t, u$ s. N9 _6 D\\" X; m

pRealArray3->Dim[0]=pRealArray1->Dim[0]; pRealArray3->Dim[1]=pRealArray1->Dim[1];        //设置矩阵维数大小 
7 ?4 k9 _5 }' v) C\\" J- Y
                for(i=0;i<pRealArray1->ArrayLen;i++) pRealArray3->Array[i]=pRealArray1->Array[i]*pRealArray2->Array[i];//矩阵点乘 
, ~' m+ ?2 }+ E& m0 S+ O, [/ Q, t
                FunReObj(hFor);        //告诉Lu，返回一个动态对象 
: \8 f$ y2 ?% T* S+ O% T
                a.BType=luDynData_realarray; a.VType=Matrix; a.x=0; *(luVOID *)&(a.x)=(luVOID)pRealArray3;( W  z% x! [! x

break; 
2 `3 W( e) u# V. K* r
        case 46:        //重载函数new 
* ]! U2 x; ^' I7 y6 m9 c
                a=ExeOperator(mm,xx,hFor,theOperator,luDynData_realarray);        //直接调用基本类型luDynData_realarray的new函数  R7 U8 K4 p  s/ e( S3 |

if(a.VType==luDynData_realarray) a.VType=Matrix;        //设置扩展类型为自定义的Matrix类型: _8 q$ e4 A' V2 C+ n! }% B* B

break;* |: `7 C+ j! l/ q

case 49:        //重载函数o0 M7 C( N0 P. z

pMessage=(luMessage)SearchKey("\0\0\0\0",sizeof(luVOID),luPubKey_User); 
9 r\\" u) \. U7 ^% j4 p8 d$ m. u5 W' l
                if(!pMessage) break; 
9 J: F3 I4 B. v' ^
                pRealArray1=(luRealArray *)SearchKey((char *)&(xx->x),sizeof(luVOID),luDynData_realarray);3 D8 ^& U7 ]* n) \

if(!pRealArray1) break;        //对象句柄无效，不是实数数组# _\\" G4 `$ C0 b8 L. G6 A

if(pRealArray1->DimLen!=2) break;        //不是二维实数数组（矩阵）2 R7 i\\" B) a7 R+ m: r9 `

pa=pRealArray1->Array; 
, c' m! p9 W+ @- D1 F, @% E
                m=pRealArray1->Dim[0]; n=pRealArray1->Dim[1]; k=0;1 E: B9 p' Z( I0 e5 \

for(i=0; i<m; i++)        //输出矩阵: }7 F0 d- i5 C6 v8 `2 ~\\" p

{0 u) R7 s: C3 U, y) ^

pMessage(L"\r\n"); k+=2; 
2 a( \0 i! @& T2 t9 n/ e+ {& D
                        for(j=0; j<n; j++) 
' w6 P$ A' @8 f4 b- b& \9 g  x
                        { 
6 r, I( T\\" N4 f1 w4 u) ?/ k, Y$ ~
                                _gcvt_s(chNum,pa[i*n+j],16); 
* p7 F- A! H* i5 E( F
                                for(u=0;chNum[u];u++) {wchNum[u]=chNum[u]; k++;} 
& ]) I0 d4 k/ ~4 a
                                wchNum[u]='\0';0 D- b. l1 r8 W8 z8 O. H; p. f

pMessage(wchNum); pMessage(L"  "); k+=2;+ \- r1 T9 J4 `

} 
) L0 ^) K0 N+ l! {0 q\\" \9 h
                } 
5 v; u3 X  T7 e2 P- g$ K
                pMessage(L"\r\n"); k+=2; 
0 s. n) A( ^7 l; Q  ]1 j' t
                a.BType=luStaData_int64; a.VType=luStaData_int64; a.x=k;        //按函数o的要求，返回输出的字符总数 
) V$ e  A/ e: m; e5 j( {1 J& }
                break; 
4 a3 ^( z+ S( G' ?4 [  H\\" h- K: f
        default:8 P% e& _\\" j* C, i# R9 l; l, b

break; 
3 |7 q& e. s5 T5 g0 d) u
        }8 l, V9 W- ^+ q$ ~1 _

return a; 
, F$ ~: B3 F; t, X* j4 i
}2 w4 B; h0 @! I3 h0 m

void main(void); [3 U- n/ B  F% x5 o

{, J\\" R, T; J7 W) n+ ^1 ]# s3 z  u

void *hFor;                //表达式句柄 
: Z& D\\" E) E3 N3 p\\" b, m) J  W- M
        luINT nPara;                //存放表达式的自变量个数. W- ]/ C' P' b1 J( ], Q4 U  H

LuData *pPara;                //存放输入自变量的数组指针$ X) ^& ~7 m) y& g

luINT ErrBegin,ErrEnd;        //表达式编译出错的初始位置和结束位置0 H1 L& L+ |2 G1 H5 O- N. r

int ErrCode;                //错误代码, e/ k$ y. ^# X5 K, V2 k  Y

void *v; 
\\" e  x4 z1 b! r$ w3 x
        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( s, V; O4 ]' ]! n$ g
        //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.]}";//字符串表达式，矩阵点乘5 W8 g: @/ w# w) s

LuData Val;0 T8 i/ R: g/ V8 G2 S- ^6 Z! z& {

if(!InitLu()) return;        //初始化Lu 
5 t) L. m  X4 ]( z0 x( w! ^
        while(LockKey(Matrix,DelMatrix,OpMatrix)){Matrix++;}        //锁定一个键，用于存储矩阵扩展类型 
5 E& T, X2 Y% q5 s
 
: D9 X% w% R3 _4 x
        Val.BType=luStaData_int64; Val.VType=luStaData_int64; Val.x=Matrix;        //定义整数常量2 o& x* ~% E% K3 F1 I( V; U8 z

SetConst(L"matrix",&Val);        //设置整数常量 
7 s* j, \6 V' `9 w
        InsertKey("\0\0\0\0",4,luPubKey_User,LuMessage,NULL,NULL,1,v); //使Lu运行时可输出函数信息5 a% X; V& o) Y( p9 k7 W

wcout.imbue(locale("chs"));        //设置输出的locale为中文 
, b9 J/ a/ @, h8 x* F% ^
  % n, [3 o, G- \3 T

ErrCode=LuCom(ForStr,0,0,0,hFor,nPara,pPara,ErrBegin,ErrEnd); //编译表达式  w: A. I6 X& M\\" f9 H

if(ErrCode) 
\\" k. P$ C) R; S0 ?/ I
        {! o7 s1 V( @; m+ B

wcout<<L"表达式有错误！错误代码："<<ErrCode<<endl; 
' ?6 e0 c5 b6 N0 G) _$ ^$ ]4 P
        } 
6 D. Z8 s( x; v- v2 J2 N0 Z: k4 Z
        else2 H# n5 x9 |9 q. o$ p! K

{& J\\" G& h) ], v0 o; D

LuCal(hFor,pPara);        //计算表达式的值 
- q8 @* u4 q/ y. Z
        }3 u+ o, x; H. V1 z) n

LockKey(Matrix,NULL,OpMatrix);//解锁键Matrix，本例中，该函数可以不用0 o& S# o\\" z# [

FreeLu();                        //释放Lu# n: ?, ^9 E\\" q5 j; d, \- d

}

习题：

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

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

main(:a,b,c,d,t,i)=
# w5 \8 Z1 I# H2 x+ z! h
a=new[matrix,2,2,data:1.,2.,2.,1.],
, h' @+ j# j: }$ B& }
b=new[matrix,2,2,data:2.,1.,1.,2.],
$ |9 j6 d( m; V/ i# m
c=new[matrix,2,2,data:2/3.,-1/3.,-1/3.,2/3.],
) D/ K; Q8 |\" v9 M
t=clock(),
/ @* ^+ v7 q( Y! Z! X# e, O
d=a*b, i=0, while{i<1000000, d=d*c*b, i++},# p1 `) o3 ]8 l\" 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\"}";//字符串表达式

复制代码

结果：