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

查看: 8901|回复: 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>4 g O( S0 ?1 c& m8 g1 K
#include <iostream>
7 C0 ~\\" k8 s! R6 b+ T
#include <math.h>
) j# \+ Q2 a2 C/ s\\" Q5 u g
#include "lu32.h"0 z' T, Q) @# G
1 |; z+ r7 F* y* c% K: t0 g
#pragma comment( lib, "lu32.lib" )
& {; C7 t e; X6 w
' f s7 f2 f# d; h# Q
using namespace std;5 ]3 \. H( t3 P- u/ F0 N
8 ` h( f6 g' q/ D: { Q
luKEY Matrix=-1000; //标识矩阵类型，最终的Matrix由LockKey决定* H/ |9 t3 |9 p8 n, b$ R
2 m\\" h. k b) {5 j) M% t! b9 R2 L
void _stdcall LuMessage(wchar_t *pch)//输出动态库信息，该函数注册到Lu，由Lu二级函数调用 7 V2 I9 b7 O8 L. t* b; q3 W. T
{) V2 n8 Q0 S6 d9 |# c\\" X: s
wcout<<pch;
$ b: K {, I6 N$ I4 I( n
}% n9 h p0 I4 ?: H, Z' v4 Z0 P
void _stdcall DelMatrix(void *me) //用于LockKey函数，因为是基于系统内置实数数组创建矩阵，故该函数什么也不做6 U' b) l; C9 o. F
{
! @6 } S. z. H7 n
}8 \5 s- [; Z V$ _\\" k9 H
LuData _stdcall OpMatrix(luINT mm,LuData *xx,void *hFor,int theOperator) //运算符重载函数，用于LockKey函数; h- Q1 \- j' A
{
3 ^, d1 |8 |! {- z( w% ` ~
LuData a;
. o/ ]5 S% M6 W5 L$ f
luRealArray *pRealArray1,*pRealArray2,*pRealArray3;
/ {. d+ q# m$ {- }
luVOID i,j,k,m,n,u,v;2 w+ |2 [4 y' } s4 t
double *pa,*pb,*pc;
( H6 V5 r5 h y2 I2 L1 k3 I
luMessage pMessage;
: s! Q' V ]7 o' _# o' |
wchar_t wchNum[32];, u1 \\\" A; q! U3 D0 f0 {& u
char chNum[32];
, N& s, _* k+ S/ ]6 W0 j
a.BType=luStaData_nil; a.VType=luStaData_nil; a.x=0;
- F! r\\" L\\" U! u2 Z\\" ^
switch(theOperator)& ?5 `) ]' x2 B: _9 M% T
{
$ G% x; F# z; @/ U9 M9 S: F, s
case 2: //重载运算符*9 E9 D3 q- y I
pRealArray1=(luRealArray *)SearchKey((char *)&(xx->x),sizeof(luVOID),luDynData_realarray);4 R% U\\" S! e* y3 P
pRealArray2=(luRealArray *)SearchKey((char *)&((xx+1)->x),sizeof(luVOID),luDynData_realarray);+ a: Y) k* |% y& W
if(!pRealArray1 || !pRealArray2) break; //对象句柄无效，不是实数数组0 e' f$ k4 p/ ~7 U0 N) t7 J6 |
if(pRealArray1->DimLen!=2 || pRealArray2->DimLen!=2) break; //不是二维实数数组（矩阵）& L' M! n9 L6 \7 E6 [7 S0 B
if(pRealArray1->Dim[1]!=pRealArray2->Dim[0]) break; //维数不匹配
6 A* m$ q2 H6 K, M; o ]# t* T
pRealArray3=(luRealArray *)NewSysObj(luDynData_realarray,pRealArray1->Dim[0]*pRealArray2->Dim[1],2); //创建矩阵对象& L( Q0 C2 i5 k$ t
if(!pRealArray3) break;2 w- {( a4 }8 O6 F$ G+ m\\" a
pRealArray3->Dim[0]=pRealArray1->Dim[0]; pRealArray3->Dim[1]=pRealArray2->Dim[1]; //设置矩阵维数大小
3 z$ t) J3 d\\" B\\" R- u* l5 g
pa=pRealArray1->Array; pb=pRealArray2->Array; pc=pRealArray3->Array;
) f! p% Y! G5 V
m=pRealArray1->Dim[0]; n=pRealArray1->Dim[1]; k=pRealArray2->Dim[1];
! z4 O\\" L: ~* W\\" h
for(i=0; i<m; i++) //矩阵乘! J7 K' K' h: Z5 K- E5 U
{4 {\\" G; B* x7 y$ d& ?) E# D4 C5 m/ ?
for(j=0; j<k; j++)
2 W# g5 B4 @3 B0 H
{2 J1 `, F7 m5 j1 r3 n
u=i*k+j; pc[u]=0.0;4 m* G' T% ~4 g) H% G: Q, D
for (v=0; v<n; v++)( F, q |' l! |! p( ` q1 o
{
- e: N1 H$ |* i7 g# d: _\\" I; Y
pc[u]=pc[u]+pa[i*n+v]*pb[v*k+j];0 v7 O6 E9 K$ z) e( ~! ]. }: d4 ^, R
}- C# @- U( b& u( n, T3 d
}' @1 V! B6 H, e
}; w# I4 \2 [& o! F, J) r
FunReObj(hFor); //告诉Lu，返回一个动态对象
! i4 q% S9 `; ^8 O! P
a.BType=luDynData_realarray; a.VType=Matrix; a.x=0; *(luVOID *)&(a.x)=(luVOID)pRealArray3;
; Z$ m3 O* w& F' j4 t
break;
! T W, C4 {$ M% m$ q
case 25: //重载运算符.*5 x3 b4 E* [7 g& x/ A* j6 G
pRealArray1=(luRealArray *)SearchKey((char *)&(xx->x),sizeof(luVOID),luDynData_realarray);\\" f# e\\" ?. e% N+ u+ c# w6 p# q
pRealArray2=(luRealArray *)SearchKey((char *)&((xx+1)->x),sizeof(luVOID),luDynData_realarray);* R* R( [: K6 y+ M\\" }
if(!pRealArray1 || !pRealArray2) break; //对象句柄无效，不是实数数组9 f% L# \$ K' o Z- X+ K
if(pRealArray1->DimLen!=2 || pRealArray2->DimLen!=2) break; //不是二维实数数组（矩阵）: b. X! j1 i( H# @# P3 i
if(pRealArray1->Dim[0]!=pRealArray2->Dim[0] || pRealArray1->Dim[1]!=pRealArray2->Dim[1]) break; //维数不相同
! O6 m1 L. r1 q9 ? r( \
pRealArray3=(luRealArray *)NewSysObj(luDynData_realarray,pRealArray1->ArrayLen,2); //创建矩阵对象4 J- ]( J4 I\\" K e7 E. P
if(!pRealArray3) break;- C$ J* D; I6 e5 j
pRealArray3->Dim[0]=pRealArray1->Dim[0]; pRealArray3->Dim[1]=pRealArray1->Dim[1]; //设置矩阵维数大小) L1 ?( m4 K0 Z& V. V
for(i=0;i<pRealArray1->ArrayLen;i++) pRealArray3->Array[i]=pRealArray1->Array[i]*pRealArray2->Array[i];//矩阵点乘/ J- G$ ?. W& j: r
FunReObj(hFor); //告诉Lu，返回一个动态对象
/ u! ]7 A! D) S$ } d; |# v: T
a.BType=luDynData_realarray; a.VType=Matrix; a.x=0; *(luVOID *)&(a.x)=(luVOID)pRealArray3;6 q% x2 R5 y4 T0 |2 g7 s
break;
1 i; V+ u% J5 e
case 46: //重载函数new
+ I% Z. D, p) a/ K* z H: ~6 E
a=ExeOperator(mm,xx,hFor,theOperator,luDynData_realarray); //直接调用基本类型luDynData_realarray的new函数& q+ v3 ?7 O0 Y
if(a.VType==luDynData_realarray) a.VType=Matrix; //设置扩展类型为自定义的Matrix类型+ q9 a9 t; z i1 a! r- `/ {
break;
$ [0 O: ]- W# d* i; c9 ^+ O1 ]
case 49: //重载函数o- v& R% s4 w3 C\\" U/ L! m
pMessage=(luMessage)SearchKey("\0\0\0\0",sizeof(luVOID),luPubKey_User);4 @3 m+ k5 |: o$ \( X7 c3 x
if(!pMessage) break;
* z6 U* L8 d$ Q7 t\\" r. P
pRealArray1=(luRealArray *)SearchKey((char *)&(xx->x),sizeof(luVOID),luDynData_realarray);. Z1 ?\\" L8 b/ Z% `\\" u; V
if(!pRealArray1) break; //对象句柄无效，不是实数数组& |1 g. ] J# {\\" k- J, ^
if(pRealArray1->DimLen!=2) break; //不是二维实数数组（矩阵）
5 d- X5 f) Z6 @2 x9 e) z
pa=pRealArray1->Array;
& _0 N& J7 t X: N
m=pRealArray1->Dim[0]; n=pRealArray1->Dim[1]; k=0;1 R4 E- x) i& A! g5 u+ K6 e5 r
for(i=0; i<m; i++) //输出矩阵& P' Q& O1 s: j
{
; K; g# s\\" T j a, X0 F% e
pMessage(L"\r\n"); k+=2;
- ?6 z. m/ D% D. l
for(j=0; j<n; j++)
- r; U9 P1 E' r( Q/ ]7 i# j7 u
{
# i' q8 r7 o2 }- B2 K6 v
_gcvt_s(chNum,pa[i*n+j],16);4 K, j7 X6 K0 ^$ l3 i
for(u=0;chNum[u];u++) {wchNum[u]=chNum[u]; k++;}
0 s/ u; _8 ~& \% b% l
wchNum[u]='\0';8 v9 R. r# Y6 [) O& T8 b
pMessage(wchNum); pMessage(L" "); k+=2; M0 R0 u. }$ v3 L7 s. E
}
# L: f. V; r2 `# ?- r* K
}1 e0 E: a: T5 j4 W% f% N) ^
pMessage(L"\r\n"); k+=2;+ y7 `! P9 {5 o: B$ C+ r
a.BType=luStaData_int64; a.VType=luStaData_int64; a.x=k; //按函数o的要求，返回输出的字符总数# T8 N7 z) [2 e1 W+ `
break;
B2 P. c1 A: { v: v- h: _/ ]; d
default:1 d2 k* `) q+ F) T% P }, U7 [
break;# ]$ t$ L2 u; Z# X) b: O' K7 D$ b' T
}
' L& i0 ^! }/ N3 x2 m; r- H
return a;# J F5 ^/ |% k5 O4 V% y0 e4 @6 s. }
}! l# {0 d \# H6 C* A7 m0 p+ j
void main(void)' B6 _' |5 x1 W7 p$ ]/ {
{3 a4 D1 b( q Z
void *hFor; //表达式句柄' k0 g. v3 T4 p2 g7 H, k
luINT nPara; //存放表达式的自变量个数6 o' y# S4 C$ t6 D) A
LuData *pPara; //存放输入自变量的数组指针
1 L9 y, b- E, L3 j6 \. i8 o( I
luINT ErrBegin,ErrEnd; //表达式编译出错的初始位置和结束位置3 C ]: e+ N5 c; W
int ErrCode; //错误代码8 D7 z) H( U4 O) }, Y9 F5 w5 K# h
void *v;
( A& Y6 c% c& |# ]: y5 l( h
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.]}";//字符串表达式，矩阵乘 M& R9 I. W* m
//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.]}";//字符串表达式，矩阵点乘4 r% }+ K4 x4 h: _' }: h4 k2 ^0 m
LuData Val;9 f' G3 `( A+ e |
if(!InitLu()) return; //初始化Lu% P6 @, |( [0 ]+ ]7 }. N
while(LockKey(Matrix,DelMatrix,OpMatrix)){Matrix++;} //锁定一个键，用于存储矩阵扩展类型/ m4 I6 _; {! m1 j0 r- b
% R. T4 \, T9 v. M
Val.BType=luStaData_int64; Val.VType=luStaData_int64; Val.x=Matrix; //定义整数常量- l# T# @: E k& w
SetConst(L"matrix",&Val); //设置整数常量
. r1 a+ a* X* Z% O; q5 M
InsertKey("\0\0\0\0",4,luPubKey_User,LuMessage,NULL,NULL,1,v); //使Lu运行时可输出函数信息% t- @1 t1 e* H9 C4 Q( g
wcout.imbue(locale("chs")); //设置输出的locale为中文
6 L5 b% }; \) J) i, d
8 N9 l* z& W\\" x2 c0 X
ErrCode=LuCom(ForStr,0,0,0,hFor,nPara,pPara,ErrBegin,ErrEnd); //编译表达式; N* W1 c: r8 w+ N2 ^2 J# O
if(ErrCode)% i; b; T1 D( q
{2 L/ F. E* S% \& q: c
wcout<<L"表达式有错误！错误代码："<<ErrCode<<endl;
+ I# Z0 o, v5 R9 f% b/ N
}
/ A# G1 w# n, L
else
7 y/ P& v1 G3 \9 t9 v) a
{. r+ [, m+ y; H! G- `- l- G6 u: T5 U
LuCal(hFor,pPara); //计算表达式的值, U0 r' K' J: L) t
}
, h/ H: F; [\\" Z# p% @9 U
LockKey(Matrix,NULL,OpMatrix);//解锁键Matrix，本例中，该函数可以不用' @/ g) @3 o6 k+ B# [# R4 ?
FreeLu(); //释放Lu7 q& D: O9 x }) F
}

#include <windows.h>4 g  O( S0 ?1 c& m8 g1 K

#include <iostream> 
7 C0 ~\\" k8 s! R6 b+ T
#include <math.h> 
) j# \+ Q2 a2 C/ s\\" Q5 u  g
#include "lu32.h"0 z' T, Q) @# G

1 |; z+ r7 F* y* c% K: t0 g

#pragma comment( lib, "lu32.lib" ) 
& {; C7 t  e; X6 w
' f  s7 f2 f# d; h# Q

using namespace std;5 ]3 \. H( t3 P- u/ F0 N

8 `  h( f6 g' q/ D: {  Q

luKEY Matrix=-1000;        //标识矩阵类型，最终的Matrix由LockKey决定* H/ |9 t3 |9 p8 n, b$ R

2 m\\" h. k  b) {5 j) M% t! b9 R2 L

void _stdcall LuMessage(wchar_t *pch)//输出动态库信息，该函数注册到Lu，由Lu二级函数调用 7 V2 I9 b7 O8 L. t* b; q3 W. T

{) V2 n8 Q0 S6 d9 |# c\\" X: s

wcout<<pch; 
$ b: K  {, I6 N$ I4 I( n
}% n9 h  p0 I4 ?: H, Z' v4 Z0 P

void _stdcall DelMatrix(void *me)        //用于LockKey函数，因为是基于系统内置实数数组创建矩阵，故该函数什么也不做6 U' b) l; C9 o. F

{ 
! @6 }  S. z. H7 n
}8 \5 s- [; Z  V$ _\\" k9 H

LuData _stdcall OpMatrix(luINT mm,LuData *xx,void *hFor,int theOperator)        //运算符重载函数，用于LockKey函数; h- Q1 \- j' A

{ 
3 ^, d1 |8 |! {- z( w% `  ~
        LuData a; 
. o/ ]5 S% M6 W5 L$ f
        luRealArray *pRealArray1,*pRealArray2,*pRealArray3; 
/ {. d+ q# m$ {- }
        luVOID i,j,k,m,n,u,v;2 w+ |2 [4 y' }  s4 t

double *pa,*pb,*pc; 
( H6 V5 r5 h  y2 I2 L1 k3 I
        luMessage pMessage; 
: s! Q' V  ]7 o' _# o' |
        wchar_t wchNum[32];, u1 \\\" A; q! U3 D0 f0 {& u

char chNum[32]; 
, N& s, _* k+ S/ ]6 W0 j
        a.BType=luStaData_nil; a.VType=luStaData_nil; a.x=0; 
- F! r\\" L\\" U! u2 Z\\" ^
        switch(theOperator)& ?5 `) ]' x2 B: _9 M% T

{ 
$ G% x; F# z; @/ U9 M9 S: F, s
        case 2:        //重载运算符*9 E9 D3 q- y  I

pRealArray1=(luRealArray *)SearchKey((char *)&(xx->x),sizeof(luVOID),luDynData_realarray);4 R% U\\" S! e* y3 P

pRealArray2=(luRealArray *)SearchKey((char *)&((xx+1)->x),sizeof(luVOID),luDynData_realarray);+ a: Y) k* |% y& W

if(!pRealArray1 || !pRealArray2) break;        //对象句柄无效，不是实数数组0 e' f$ k4 p/ ~7 U0 N) t7 J6 |

if(pRealArray1->DimLen!=2 || pRealArray2->DimLen!=2) break;        //不是二维实数数组（矩阵）& L' M! n9 L6 \7 E6 [7 S0 B

if(pRealArray1->Dim[1]!=pRealArray2->Dim[0]) break;        //维数不匹配 
6 A* m$ q2 H6 K, M; o  ]# t* T
                pRealArray3=(luRealArray *)NewSysObj(luDynData_realarray,pRealArray1->Dim[0]*pRealArray2->Dim[1],2);        //创建矩阵对象& L( Q0 C2 i5 k$ t

if(!pRealArray3) break;2 w- {( a4 }8 O6 F$ G+ m\\" a

pRealArray3->Dim[0]=pRealArray1->Dim[0]; pRealArray3->Dim[1]=pRealArray2->Dim[1];        //设置矩阵维数大小 
3 z$ t) J3 d\\" B\\" R- u* l5 g
                pa=pRealArray1->Array; pb=pRealArray2->Array; pc=pRealArray3->Array; 
) f! p% Y! G5 V
                m=pRealArray1->Dim[0]; n=pRealArray1->Dim[1]; k=pRealArray2->Dim[1]; 
! z4 O\\" L: ~* W\\" h
                for(i=0; i<m; i++)        //矩阵乘! J7 K' K' h: Z5 K- E5 U

{4 {\\" G; B* x7 y$ d& ?) E# D4 C5 m/ ?

for(j=0; j<k; j++) 
2 W# g5 B4 @3 B0 H
                        {2 J1 `, F7 m5 j1 r3 n

u=i*k+j; pc[u]=0.0;4 m* G' T% ~4 g) H% G: Q, D

for (v=0; v<n; v++)( F, q  |' l! |! p( `  q1 o

{ 
- e: N1 H$ |* i7 g# d: _\\" I; Y
                                        pc[u]=pc[u]+pa[i*n+v]*pb[v*k+j];0 v7 O6 E9 K$ z) e( ~! ]. }: d4 ^, R

}- C# @- U( b& u( n, T3 d

}' @1 V! B6 H, e

}; w# I4 \2 [& o! F, J) r

FunReObj(hFor);        //告诉Lu，返回一个动态对象 
! i4 q% S9 `; ^8 O! P
                a.BType=luDynData_realarray; a.VType=Matrix; a.x=0; *(luVOID *)&(a.x)=(luVOID)pRealArray3; 
; Z$ m3 O* w& F' j4 t
                break; 
! T  W, C4 {$ M% m$ q
        case 25:        //重载运算符.*5 x3 b4 E* [7 g& x/ A* j6 G

pRealArray1=(luRealArray *)SearchKey((char *)&(xx->x),sizeof(luVOID),luDynData_realarray);\\" f# e\\" ?. e% N+ u+ c# w6 p# q

pRealArray2=(luRealArray *)SearchKey((char *)&((xx+1)->x),sizeof(luVOID),luDynData_realarray);* R* R( [: K6 y+ M\\" }

if(!pRealArray1 || !pRealArray2) break;        //对象句柄无效，不是实数数组9 f% L# \$ K' o  Z- X+ K

if(pRealArray1->DimLen!=2 || pRealArray2->DimLen!=2) break;        //不是二维实数数组（矩阵）: b. X! j1 i( H# @# P3 i

if(pRealArray1->Dim[0]!=pRealArray2->Dim[0] || pRealArray1->Dim[1]!=pRealArray2->Dim[1]) break;        //维数不相同 
! O6 m1 L. r1 q9 ?  r( \
                pRealArray3=(luRealArray *)NewSysObj(luDynData_realarray,pRealArray1->ArrayLen,2);        //创建矩阵对象4 J- ]( J4 I\\" K  e7 E. P

if(!pRealArray3) break;- C$ J* D; I6 e5 j

pRealArray3->Dim[0]=pRealArray1->Dim[0]; pRealArray3->Dim[1]=pRealArray1->Dim[1];        //设置矩阵维数大小) L1 ?( m4 K0 Z& V. V

for(i=0;i<pRealArray1->ArrayLen;i++) pRealArray3->Array[i]=pRealArray1->Array[i]*pRealArray2->Array[i];//矩阵点乘/ J- G$ ?. W& j: r

FunReObj(hFor);        //告诉Lu，返回一个动态对象 
/ u! ]7 A! D) S$ }  d; |# v: T
                a.BType=luDynData_realarray; a.VType=Matrix; a.x=0; *(luVOID *)&(a.x)=(luVOID)pRealArray3;6 q% x2 R5 y4 T0 |2 g7 s

break; 
1 i; V+ u% J5 e
        case 46:        //重载函数new 
+ I% Z. D, p) a/ K* z  H: ~6 E
                a=ExeOperator(mm,xx,hFor,theOperator,luDynData_realarray);        //直接调用基本类型luDynData_realarray的new函数& q+ v3 ?7 O0 Y

if(a.VType==luDynData_realarray) a.VType=Matrix;        //设置扩展类型为自定义的Matrix类型+ q9 a9 t; z  i1 a! r- `/ {

break; 
$ [0 O: ]- W# d* i; c9 ^+ O1 ]
        case 49:        //重载函数o- v& R% s4 w3 C\\" U/ L! m

pMessage=(luMessage)SearchKey("\0\0\0\0",sizeof(luVOID),luPubKey_User);4 @3 m+ k5 |: o$ \( X7 c3 x

if(!pMessage) break; 
* z6 U* L8 d$ Q7 t\\" r. P
                pRealArray1=(luRealArray *)SearchKey((char *)&(xx->x),sizeof(luVOID),luDynData_realarray);. Z1 ?\\" L8 b/ Z% `\\" u; V

if(!pRealArray1) break;        //对象句柄无效，不是实数数组& |1 g. ]  J# {\\" k- J, ^

if(pRealArray1->DimLen!=2) break;        //不是二维实数数组（矩阵） 
5 d- X5 f) Z6 @2 x9 e) z
                pa=pRealArray1->Array; 
& _0 N& J7 t  X: N
                m=pRealArray1->Dim[0]; n=pRealArray1->Dim[1]; k=0;1 R4 E- x) i& A! g5 u+ K6 e5 r

for(i=0; i<m; i++)        //输出矩阵& P' Q& O1 s: j

{ 
; K; g# s\\" T  j  a, X0 F% e
                        pMessage(L"\r\n"); k+=2; 
- ?6 z. m/ D% D. l
                        for(j=0; j<n; j++) 
- r; U9 P1 E' r( Q/ ]7 i# j7 u
                        { 
# i' q8 r7 o2 }- B2 K6 v
                                _gcvt_s(chNum,pa[i*n+j],16);4 K, j7 X6 K0 ^$ l3 i

for(u=0;chNum[u];u++) {wchNum[u]=chNum[u]; k++;} 
0 s/ u; _8 ~& \% b% l
                                wchNum[u]='\0';8 v9 R. r# Y6 [) O& T8 b

pMessage(wchNum); pMessage(L"  "); k+=2;  M0 R0 u. }$ v3 L7 s. E

} 
# L: f. V; r2 `# ?- r* K
                }1 e0 E: a: T5 j4 W% f% N) ^

pMessage(L"\r\n"); k+=2;+ y7 `! P9 {5 o: B$ C+ r

a.BType=luStaData_int64; a.VType=luStaData_int64; a.x=k;        //按函数o的要求，返回输出的字符总数# T8 N7 z) [2 e1 W+ `

break; 
  B2 P. c1 A: {  v: v- h: _/ ]; d
        default:1 d2 k* `) q+ F) T% P  }, U7 [

break;# ]$ t$ L2 u; Z# X) b: O' K7 D$ b' T

} 
' L& i0 ^! }/ N3 x2 m; r- H
        return a;# J  F5 ^/ |% k5 O4 V% y0 e4 @6 s. }

}! l# {0 d  \# H6 C* A7 m0 p+ j

void main(void)' B6 _' |5 x1 W7 p$ ]/ {

{3 a4 D1 b( q  Z

void *hFor;                //表达式句柄' k0 g. v3 T4 p2 g7 H, k

luINT nPara;                //存放表达式的自变量个数6 o' y# S4 C$ t6 D) A

LuData *pPara;                //存放输入自变量的数组指针 
1 L9 y, b- E, L3 j6 \. i8 o( I
        luINT ErrBegin,ErrEnd;        //表达式编译出错的初始位置和结束位置3 C  ]: e+ N5 c; W

int ErrCode;                //错误代码8 D7 z) H( U4 O) }, Y9 F5 w5 K# h

void *v; 
( A& Y6 c% c& |# ]: y5 l( h
        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.]}";//字符串表达式，矩阵乘  M& R9 I. W* m

//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.]}";//字符串表达式，矩阵点乘4 r% }+ K4 x4 h: _' }: h4 k2 ^0 m

LuData Val;9 f' G3 `( A+ e  |

if(!InitLu()) return;        //初始化Lu% P6 @, |( [0 ]+ ]7 }. N

while(LockKey(Matrix,DelMatrix,OpMatrix)){Matrix++;}        //锁定一个键，用于存储矩阵扩展类型/ m4 I6 _; {! m1 j0 r- b

% R. T4 \, T9 v. M

Val.BType=luStaData_int64; Val.VType=luStaData_int64; Val.x=Matrix;        //定义整数常量- l# T# @: E  k& w

SetConst(L"matrix",&Val);        //设置整数常量 
. r1 a+ a* X* Z% O; q5 M
        InsertKey("\0\0\0\0",4,luPubKey_User,LuMessage,NULL,NULL,1,v); //使Lu运行时可输出函数信息% t- @1 t1 e* H9 C4 Q( g

wcout.imbue(locale("chs"));        //设置输出的locale为中文 
6 L5 b% }; \) J) i, d
   
8 N9 l* z& W\\" x2 c0 X
        ErrCode=LuCom(ForStr,0,0,0,hFor,nPara,pPara,ErrBegin,ErrEnd); //编译表达式; N* W1 c: r8 w+ N2 ^2 J# O

if(ErrCode)% i; b; T1 D( q

{2 L/ F. E* S% \& q: c

wcout<<L"表达式有错误！错误代码："<<ErrCode<<endl; 
+ I# Z0 o, v5 R9 f% b/ N
        } 
/ A# G1 w# n, L
        else 
7 y/ P& v1 G3 \9 t9 v) a
        {. r+ [, m+ y; H! G- `- l- G6 u: T5 U

LuCal(hFor,pPara);        //计算表达式的值, U0 r' K' J: L) t

} 
, h/ H: F; [\\" Z# p% @9 U
        LockKey(Matrix,NULL,OpMatrix);//解锁键Matrix，本例中，该函数可以不用' @/ g) @3 o6 k+ B# [# R4 ?

FreeLu();                        //释放Lu7 q& D: O9 x  }) F

}

习题：

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

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

main(:a,b,c,d,t,i)=( v7 W+ |/ p0 N\" _3 K4 b8 Z/ |1 ]
a=new[matrix,2,2,data:1.,2.,2.,1.],5 G# j) P/ H9 p6 B
b=new[matrix,2,2,data:2.,1.,1.,2.],
! N! y7 q2 Y9 r4 C( z3 c. R
c=new[matrix,2,2,data:2/3.,-1/3.,-1/3.,2/3.],7 c0 [& v/ `+ c) o) P9 t) S5 J
t=clock(), z: }# @. D3 `9 C+ |+ M
d=a*b, i=0, while{i<1000000, d=d*c*b, i++},
5 {+ N. U\" ~% q: M) x+ q9 o) A
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\"}";//字符串表达式

复制代码

结果：