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

查看: 8453|回复: 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>
- b/ v1 S6 ^+ V7 J4 ^1 t6 n
#include <iostream>9 z9 D1 `! k\\" v9 G8 v7 z- g
#include <math.h>- W+ V\\" D0 ?5 ?9 d1 b1 p% m/ e
#include "lu32.h"5 C; N/ W- U! n3 \2 u4 P
9 P Z4 M- @+ f! R
#pragma comment( lib, "lu32.lib" )! l4 h7 `% }: p5 ^- Y7 b
* m7 T* S\\" F3 N a
using namespace std;
1 A- q, Y. C4 `1 G9 p: l- T
0 j8 i0 e% k5 Q+ B) I
luKEY Matrix=-1000; //标识矩阵类型，最终的Matrix由LockKey决定; }\\" Z6 V: n: i Q3 x
+ Z! r* o' a. y) ]
void _stdcall LuMessage(wchar_t *pch)//输出动态库信息，该函数注册到Lu，由Lu二级函数调用 : b\\" T, G% w |, Z
{% h# J6 E, T# D% N# f
wcout<<pch;: h; Z8 ?2 l. j+ g
}& T6 @# [; p# O! A2 m
void _stdcall DelMatrix(void *me) //用于LockKey函数，因为是基于系统内置实数数组创建矩阵，故该函数什么也不做2 p( L3 e) n7 H; `# K
{/ z% }# C4 I N- G
}# @. C1 }& D: k\\" Y% t\\" B( v
LuData _stdcall OpMatrix(luINT mm,LuData *xx,void *hFor,int theOperator) //运算符重载函数，用于LockKey函数. ?0 d6 z2 n8 t& o& [- C- [0 [0 s; {
{
1 `. x+ W+ P$ } j1 x
LuData a;8 a5 e2 G4 O) ^- z+ v
luRealArray *pRealArray1,*pRealArray2,*pRealArray3;
* } j2 g o H4 T9 S* S
luVOID i,j,k,m,n,u,v;
, c) B; O1 v) i3 f
double *pa,*pb,*pc;8 W8 C9 w _5 Z5 g8 x
luMessage pMessage;7 S5 b0 y) Z\\" }0 c
wchar_t wchNum[32];
& n+ j+ P, W# x# T4 C
char chNum[32];
2 w; u5 X* A2 y5 X, |* F
a.BType=luStaData_nil; a.VType=luStaData_nil; a.x=0;, _% @3 N% |2 `: Q
switch(theOperator)2 q0 T. V& _7 N\\" `+ m
{- E# }0 z4 N/ i* d1 b2 V5 @* S
case 2: //重载运算符*
* a. s. b! f9 O' O\\" M
pRealArray1=(luRealArray *)SearchKey((char *)&(xx->x),sizeof(luVOID),luDynData_realarray);# i2 X/ K9 k) t$ {. }! @\\" r
pRealArray2=(luRealArray *)SearchKey((char *)&((xx+1)->x),sizeof(luVOID),luDynData_realarray);
8 _3 {6 Y& o; k+ s; A' ^) F
if(!pRealArray1 || !pRealArray2) break; //对象句柄无效，不是实数数组
& N# h M2 s- J
if(pRealArray1->DimLen!=2 || pRealArray2->DimLen!=2) break; //不是二维实数数组（矩阵）
4 l( m7 a) G/ Z$ ^. H! M; y% [$ O, i
if(pRealArray1->Dim[1]!=pRealArray2->Dim[0]) break; //维数不匹配4 J7 M* }+ h2 [/ ^6 t* x
pRealArray3=(luRealArray *)NewSysObj(luDynData_realarray,pRealArray1->Dim[0]*pRealArray2->Dim[1],2); //创建矩阵对象1 V' p1 z6 V* |5 i& }$ x+ ] l
if(!pRealArray3) break;( Y\\" R4 e1 E1 j; P
pRealArray3->Dim[0]=pRealArray1->Dim[0]; pRealArray3->Dim[1]=pRealArray2->Dim[1]; //设置矩阵维数大小
9 k* z* [6 X. u w& o1 s8 f
pa=pRealArray1->Array; pb=pRealArray2->Array; pc=pRealArray3->Array;4 N) ~( I$ \0 K0 D
m=pRealArray1->Dim[0]; n=pRealArray1->Dim[1]; k=pRealArray2->Dim[1];9 ?3 s3 p2 x( a. A8 z8 \& P/ ^+ u
for(i=0; i<m; i++) //矩阵乘
- P, |3 c2 J: K, x7 r
{) Z' c( _; A\\" x B
for(j=0; j<k; j++)% y7 ^3 a, ?2 t8 X' `
{
' }3 e4 C' E* B) A5 U& x( _# x
u=i*k+j; pc[u]=0.0;
w1 s4 X$ p; \ b- w0 ~
for (v=0; v<n; v++)
: j7 u( l' b$ z' R! _: {
{
C/ T: f4 r3 n5 O; }! z+ r
pc[u]=pc[u]+pa[i*n+v]*pb[v*k+j];. B. T! S. K& e+ h9 M: P9 i
}: f! w1 ?5 y2 ?$ s* A4 r& H
}5 h- k1 l# e. Z
}# i6 s5 V+ L7 k6 O# m! i G
FunReObj(hFor); //告诉Lu，返回一个动态对象; I\\" a\\" u$ ~3 @/ m2 W
a.BType=luDynData_realarray; a.VType=Matrix; a.x=0; *(luVOID *)&(a.x)=(luVOID)pRealArray3;
9 Z* g8 E4 H; W2 \5 \9 h
break;8 a\\" a1 g/ k- U& G5 Z! R* j
case 25: //重载运算符.*! E+ s\\" K# p6 x/ T
pRealArray1=(luRealArray *)SearchKey((char *)&(xx->x),sizeof(luVOID),luDynData_realarray);
3 D4 f% ]9 Q8 u2 A( i
pRealArray2=(luRealArray *)SearchKey((char *)&((xx+1)->x),sizeof(luVOID),luDynData_realarray);
! w% i) F' h7 s7 G5 T/ `# k
if(!pRealArray1 || !pRealArray2) break; //对象句柄无效，不是实数数组( e# W: T a B+ `2 ^3 v$ G
if(pRealArray1->DimLen!=2 || pRealArray2->DimLen!=2) break; //不是二维实数数组（矩阵）
; u: o1 d9 I2 ~3 {
if(pRealArray1->Dim[0]!=pRealArray2->Dim[0] || pRealArray1->Dim[1]!=pRealArray2->Dim[1]) break; //维数不相同
\\" }' l2 P0 d. O; M
pRealArray3=(luRealArray *)NewSysObj(luDynData_realarray,pRealArray1->ArrayLen,2); //创建矩阵对象* h. k\\" Q1 M3 [5 [6 i\\" o
if(!pRealArray3) break;
- m% H2 N5 w0 z* U
pRealArray3->Dim[0]=pRealArray1->Dim[0]; pRealArray3->Dim[1]=pRealArray1->Dim[1]; //设置矩阵维数大小. [3 U& p% ?# c: b
for(i=0;i<pRealArray1->ArrayLen;i++) pRealArray3->Array[i]=pRealArray1->Array[i]*pRealArray2->Array[i];//矩阵点乘
6 n) O: P9 H, K
FunReObj(hFor); //告诉Lu，返回一个动态对象
. x& j4 }! X: J5 I2 b: E
a.BType=luDynData_realarray; a.VType=Matrix; a.x=0; *(luVOID *)&(a.x)=(luVOID)pRealArray3;6 T. w2 R; H( N9 _$ D8 @
break;
' ^3 _9 a2 |% h4 E# L; C2 v! Z
case 46: //重载函数new& ]* _( V9 H8 f\\" f/ i
a=ExeOperator(mm,xx,hFor,theOperator,luDynData_realarray); //直接调用基本类型luDynData_realarray的new函数
$ q9 m/ n* N b$ B/ S
if(a.VType==luDynData_realarray) a.VType=Matrix; //设置扩展类型为自定义的Matrix类型
; q/ Y1 B8 U X% e$ P' w
break;' \5 Z& Y\\" ^( B% o3 i/ q
case 49: //重载函数o# K/ F% C6 e2 w4 A4 ]
pMessage=(luMessage)SearchKey("\0\0\0\0",sizeof(luVOID),luPubKey_User);7 F# V\\" g3 w3 o5 x4 r6 f6 N
if(!pMessage) break;
3 v( w$ N+ _, q; Q
pRealArray1=(luRealArray *)SearchKey((char *)&(xx->x),sizeof(luVOID),luDynData_realarray);0 w ?) S\\" n3 {* O- a/ C
if(!pRealArray1) break; //对象句柄无效，不是实数数组
\\" Q\\" P' d K) l* J% Y
if(pRealArray1->DimLen!=2) break; //不是二维实数数组（矩阵）
: o: J5 M4 n. V7 r
pa=pRealArray1->Array;
% ?* Z+ Z( d; x9 @
m=pRealArray1->Dim[0]; n=pRealArray1->Dim[1]; k=0;3 Y! c& Z# D7 R& A$ w
for(i=0; i<m; i++) //输出矩阵
2 b$ {6 [9 I- n
{
. ^) h, f5 R$ ?5 V9 @
pMessage(L"\r\n"); k+=2;
& W$ A% L: A' ~1 s\\" f
for(j=0; j<n; j++)
- W/ y/ `) o; C4 ]! y2 I7 U
{- l% z( P# x2 a
_gcvt_s(chNum,pa[i*n+j],16);9 F D5 k$ M; j2 J
for(u=0;chNum[u];u++) {wchNum[u]=chNum[u]; k++;}/ V4 n- [& I2 X
wchNum[u]='\0';& v5 I4 q* |9 s
pMessage(wchNum); pMessage(L" "); k+=2;8 e, C/ @6 u9 r1 ~
}$ ]! U+ V4 [: k
}9 H1 A- t' M( R
pMessage(L"\r\n"); k+=2;7 H3 z3 O4 R: }& l\\" q7 z3 B/ j* k& e
a.BType=luStaData_int64; a.VType=luStaData_int64; a.x=k; //按函数o的要求，返回输出的字符总数# D4 d; ~/ T# \/ t: M9 g
break;
* V; ~- O5 n v0 [4 E
default:
* L\\" _! m1 {: a8 a
break;
! P! @2 s4 u( L/ W; b5 E/ c
}, K. b$ \: i( T+ M+ s
return a;* p% }\\" v; U5 I& ~+ j$ x: Z
}
0 `% C+ M7 {2 S! Z% G3 @' r
void main(void)
0 E5 U4 \! O5 D6 K! I0 v
{/ c$ L0 i; _& z* i4 j3 s\\" _5 V
void *hFor; //表达式句柄
' ~6 I5 T$ G) S) \3 p
luINT nPara; //存放表达式的自变量个数
, k4 K( w0 U6 q\\" x3 e4 i( _1 y: t
LuData *pPara; //存放输入自变量的数组指针
/ I* Q) I+ g2 [7 d- F
luINT ErrBegin,ErrEnd; //表达式编译出错的初始位置和结束位置
- t$ ] g7 }- g* k8 E7 N
int ErrCode; //错误代码0 X4 a6 s$ |/ \9 J+ Y1 D
void *v;
% ^- s' l5 `# ]# [8 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.]}";//字符串表达式，矩阵乘4 \\\" a4 t; [* r) {6 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.]}";//字符串表达式，矩阵点乘( O6 U6 a; z3 q* r
LuData Val;
: L `: b- ]$ g* ^$ @* j) I# A
if(!InitLu()) return; //初始化Lu9 m, j: y% N9 Y$ c
while(LockKey(Matrix,DelMatrix,OpMatrix)){Matrix++;} //锁定一个键，用于存储矩阵扩展类型& C4 d! I; |8 w
, u! `7 u g) a6 D
Val.BType=luStaData_int64; Val.VType=luStaData_int64; Val.x=Matrix; //定义整数常量3 [- S, R9 b& p9 K4 U
SetConst(L"matrix",&Val); //设置整数常量
7 I) c& _# N! D
InsertKey("\0\0\0\0",4,luPubKey_User,LuMessage,NULL,NULL,1,v); //使Lu运行时可输出函数信息/ c3 A2 R5 N* s! p# ~/ Q: y4 h# Q
wcout.imbue(locale("chs")); //设置输出的locale为中文
& b: v) U! ?' z& S
% s' V) }. N+ @
ErrCode=LuCom(ForStr,0,0,0,hFor,nPara,pPara,ErrBegin,ErrEnd); //编译表达式# e1 s! W( f) p+ O: m% ^/ W\\" s8 o
if(ErrCode)* R( U% W7 d: i1 U8 {
{* }9 j6 |# _1 ?4 c5 [) _
wcout<<L"表达式有错误！错误代码："<<ErrCode<<endl;# _5 `7 ` A6 F' l$ z ~$ O( P
}8 R' F# o, _/ u1 ~0 Q
else
- g5 B7 V/ x! W
{
8 A4 x9 X2 [1 V
LuCal(hFor,pPara); //计算表达式的值
' f1 v5 w\\" U. s% e' ~2 a* M
}
. j8 h: g9 V\\" u/ i% a
LockKey(Matrix,NULL,OpMatrix);//解锁键Matrix，本例中，该函数可以不用+ X/ F# ~$ A/ x( t% i
FreeLu(); //释放Lu
5 F. ~5 y5 \ y( m/ ]' c3 r+ V$ `
}

#include <windows.h> 
- b/ v1 S6 ^+ V7 J4 ^1 t6 n
#include <iostream>9 z9 D1 `! k\\" v9 G8 v7 z- g

#include <math.h>- W+ V\\" D0 ?5 ?9 d1 b1 p% m/ e

#include "lu32.h"5 C; N/ W- U! n3 \2 u4 P

9 P  Z4 M- @+ f! R

#pragma comment( lib, "lu32.lib" )! l4 h7 `% }: p5 ^- Y7 b

* m7 T* S\\" F3 N  a

using namespace std; 
1 A- q, Y. C4 `1 G9 p: l- T
 
0 j8 i0 e% k5 Q+ B) I
luKEY Matrix=-1000;        //标识矩阵类型，最终的Matrix由LockKey决定; }\\" Z6 V: n: i  Q3 x

+ Z! r* o' a. y) ]

void _stdcall LuMessage(wchar_t *pch)//输出动态库信息，该函数注册到Lu，由Lu二级函数调用 : b\\" T, G% w  |, Z

{% h# J6 E, T# D% N# f

wcout<<pch;: h; Z8 ?2 l. j+ g

}& T6 @# [; p# O! A2 m

void _stdcall DelMatrix(void *me)        //用于LockKey函数，因为是基于系统内置实数数组创建矩阵，故该函数什么也不做2 p( L3 e) n7 H; `# K

{/ z% }# C4 I  N- G

}# @. C1 }& D: k\\" Y% t\\" B( v

LuData _stdcall OpMatrix(luINT mm,LuData *xx,void *hFor,int theOperator)        //运算符重载函数，用于LockKey函数. ?0 d6 z2 n8 t& o& [- C- [0 [0 s; {

{ 
1 `. x+ W+ P$ }  j1 x
        LuData a;8 a5 e2 G4 O) ^- z+ v

luRealArray *pRealArray1,*pRealArray2,*pRealArray3; 
* }  j2 g  o  H4 T9 S* S
        luVOID i,j,k,m,n,u,v; 
, c) B; O1 v) i3 f
        double *pa,*pb,*pc;8 W8 C9 w  _5 Z5 g8 x

luMessage pMessage;7 S5 b0 y) Z\\" }0 c

wchar_t wchNum[32]; 
& n+ j+ P, W# x# T4 C
        char chNum[32]; 
2 w; u5 X* A2 y5 X, |* F
        a.BType=luStaData_nil; a.VType=luStaData_nil; a.x=0;, _% @3 N% |2 `: Q

switch(theOperator)2 q0 T. V& _7 N\\" `+ m

{- E# }0 z4 N/ i* d1 b2 V5 @* S

case 2:        //重载运算符* 
* a. s. b! f9 O' O\\" M
                pRealArray1=(luRealArray *)SearchKey((char *)&(xx->x),sizeof(luVOID),luDynData_realarray);# i2 X/ K9 k) t$ {. }! @\\" r

pRealArray2=(luRealArray *)SearchKey((char *)&((xx+1)->x),sizeof(luVOID),luDynData_realarray); 
8 _3 {6 Y& o; k+ s; A' ^) F
                if(!pRealArray1 || !pRealArray2) break;        //对象句柄无效，不是实数数组 
& N# h  M2 s- J
                if(pRealArray1->DimLen!=2 || pRealArray2->DimLen!=2) break;        //不是二维实数数组（矩阵） 
4 l( m7 a) G/ Z$ ^. H! M; y% [$ O, i
                if(pRealArray1->Dim[1]!=pRealArray2->Dim[0]) break;        //维数不匹配4 J7 M* }+ h2 [/ ^6 t* x

pRealArray3=(luRealArray *)NewSysObj(luDynData_realarray,pRealArray1->Dim[0]*pRealArray2->Dim[1],2);        //创建矩阵对象1 V' p1 z6 V* |5 i& }$ x+ ]  l

if(!pRealArray3) break;( Y\\" R4 e1 E1 j; P

pRealArray3->Dim[0]=pRealArray1->Dim[0]; pRealArray3->Dim[1]=pRealArray2->Dim[1];        //设置矩阵维数大小 
9 k* z* [6 X. u  w& o1 s8 f
                pa=pRealArray1->Array; pb=pRealArray2->Array; pc=pRealArray3->Array;4 N) ~( I$ \0 K0 D

m=pRealArray1->Dim[0]; n=pRealArray1->Dim[1]; k=pRealArray2->Dim[1];9 ?3 s3 p2 x( a. A8 z8 \& P/ ^+ u

for(i=0; i<m; i++)        //矩阵乘 
- P, |3 c2 J: K, x7 r
                {) Z' c( _; A\\" x  B

for(j=0; j<k; j++)% y7 ^3 a, ?2 t8 X' `

{ 
' }3 e4 C' E* B) A5 U& x( _# x
                                u=i*k+j; pc[u]=0.0; 
  w1 s4 X$ p; \  b- w0 ~
                                for (v=0; v<n; v++) 
: j7 u( l' b$ z' R! _: {
                                { 
  C/ T: f4 r3 n5 O; }! z+ r
                                        pc[u]=pc[u]+pa[i*n+v]*pb[v*k+j];. B. T! S. K& e+ h9 M: P9 i

}: f! w1 ?5 y2 ?$ s* A4 r& H

}5 h- k1 l# e. Z

}# i6 s5 V+ L7 k6 O# m! i  G

FunReObj(hFor);        //告诉Lu，返回一个动态对象; I\\" a\\" u$ ~3 @/ m2 W

a.BType=luDynData_realarray; a.VType=Matrix; a.x=0; *(luVOID *)&(a.x)=(luVOID)pRealArray3; 
9 Z* g8 E4 H; W2 \5 \9 h
                break;8 a\\" a1 g/ k- U& G5 Z! R* j

case 25:        //重载运算符.*! E+ s\\" K# p6 x/ T

pRealArray1=(luRealArray *)SearchKey((char *)&(xx->x),sizeof(luVOID),luDynData_realarray); 
3 D4 f% ]9 Q8 u2 A( i
                pRealArray2=(luRealArray *)SearchKey((char *)&((xx+1)->x),sizeof(luVOID),luDynData_realarray); 
! w% i) F' h7 s7 G5 T/ `# k
                if(!pRealArray1 || !pRealArray2) break;        //对象句柄无效，不是实数数组( e# W: T  a  B+ `2 ^3 v$ G

if(pRealArray1->DimLen!=2 || pRealArray2->DimLen!=2) break;        //不是二维实数数组（矩阵） 
; u: o1 d9 I2 ~3 {
                if(pRealArray1->Dim[0]!=pRealArray2->Dim[0] || pRealArray1->Dim[1]!=pRealArray2->Dim[1]) break;        //维数不相同 
\\" }' l2 P0 d. O; M
                pRealArray3=(luRealArray *)NewSysObj(luDynData_realarray,pRealArray1->ArrayLen,2);        //创建矩阵对象* h. k\\" Q1 M3 [5 [6 i\\" o

if(!pRealArray3) break; 
- m% H2 N5 w0 z* U
                pRealArray3->Dim[0]=pRealArray1->Dim[0]; pRealArray3->Dim[1]=pRealArray1->Dim[1];        //设置矩阵维数大小. [3 U& p% ?# c: b

for(i=0;i<pRealArray1->ArrayLen;i++) pRealArray3->Array[i]=pRealArray1->Array[i]*pRealArray2->Array[i];//矩阵点乘 
6 n) O: P9 H, K
                FunReObj(hFor);        //告诉Lu，返回一个动态对象 
. x& j4 }! X: J5 I2 b: E
                a.BType=luDynData_realarray; a.VType=Matrix; a.x=0; *(luVOID *)&(a.x)=(luVOID)pRealArray3;6 T. w2 R; H( N9 _$ D8 @

break; 
' ^3 _9 a2 |% h4 E# L; C2 v! Z
        case 46:        //重载函数new& ]* _( V9 H8 f\\" f/ i

a=ExeOperator(mm,xx,hFor,theOperator,luDynData_realarray);        //直接调用基本类型luDynData_realarray的new函数 
$ q9 m/ n* N  b$ B/ S
                if(a.VType==luDynData_realarray) a.VType=Matrix;        //设置扩展类型为自定义的Matrix类型 
; q/ Y1 B8 U  X% e$ P' w
                break;' \5 Z& Y\\" ^( B% o3 i/ q

case 49:        //重载函数o# K/ F% C6 e2 w4 A4 ]

pMessage=(luMessage)SearchKey("\0\0\0\0",sizeof(luVOID),luPubKey_User);7 F# V\\" g3 w3 o5 x4 r6 f6 N

if(!pMessage) break; 
3 v( w$ N+ _, q; Q
                pRealArray1=(luRealArray *)SearchKey((char *)&(xx->x),sizeof(luVOID),luDynData_realarray);0 w  ?) S\\" n3 {* O- a/ C

if(!pRealArray1) break;        //对象句柄无效，不是实数数组 
\\" Q\\" P' d  K) l* J% Y
                if(pRealArray1->DimLen!=2) break;        //不是二维实数数组（矩阵） 
: o: J5 M4 n. V7 r
                pa=pRealArray1->Array; 
% ?* Z+ Z( d; x9 @
                m=pRealArray1->Dim[0]; n=pRealArray1->Dim[1]; k=0;3 Y! c& Z# D7 R& A$ w

for(i=0; i<m; i++)        //输出矩阵 
2 b$ {6 [9 I- n
                { 
. ^) h, f5 R$ ?5 V9 @
                        pMessage(L"\r\n"); k+=2; 
& W$ A% L: A' ~1 s\\" f
                        for(j=0; j<n; j++) 
- W/ y/ `) o; C4 ]! y2 I7 U
                        {- l% z( P# x2 a

_gcvt_s(chNum,pa[i*n+j],16);9 F  D5 k$ M; j2 J

for(u=0;chNum[u];u++) {wchNum[u]=chNum[u]; k++;}/ V4 n- [& I2 X

wchNum[u]='\0';& v5 I4 q* |9 s

pMessage(wchNum); pMessage(L"  "); k+=2;8 e, C/ @6 u9 r1 ~

}$ ]! U+ V4 [: k

}9 H1 A- t' M( R

pMessage(L"\r\n"); k+=2;7 H3 z3 O4 R: }& l\\" q7 z3 B/ j* k& e

a.BType=luStaData_int64; a.VType=luStaData_int64; a.x=k;        //按函数o的要求，返回输出的字符总数# D4 d; ~/ T# \/ t: M9 g

break; 
* V; ~- O5 n  v0 [4 E
        default: 
* L\\" _! m1 {: a8 a
                break; 
! P! @2 s4 u( L/ W; b5 E/ c
        }, K. b$ \: i( T+ M+ s

return a;* p% }\\" v; U5 I& ~+ j$ x: Z

} 
0 `% C+ M7 {2 S! Z% G3 @' r
void main(void) 
0 E5 U4 \! O5 D6 K! I0 v
{/ c$ L0 i; _& z* i4 j3 s\\" _5 V

void *hFor;                //表达式句柄 
' ~6 I5 T$ G) S) \3 p
        luINT nPara;                //存放表达式的自变量个数 
, k4 K( w0 U6 q\\" x3 e4 i( _1 y: t
        LuData *pPara;                //存放输入自变量的数组指针 
/ I* Q) I+ g2 [7 d- F
        luINT ErrBegin,ErrEnd;        //表达式编译出错的初始位置和结束位置 
- t$ ]  g7 }- g* k8 E7 N
        int ErrCode;                //错误代码0 X4 a6 s$ |/ \9 J+ Y1 D

void *v; 
% ^- s' l5 `# ]# [8 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.]}";//字符串表达式，矩阵乘4 \\\" a4 t; [* r) {6 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.]}";//字符串表达式，矩阵点乘( O6 U6 a; z3 q* r

LuData Val; 
: L  `: b- ]$ g* ^$ @* j) I# A
        if(!InitLu()) return;        //初始化Lu9 m, j: y% N9 Y$ c

while(LockKey(Matrix,DelMatrix,OpMatrix)){Matrix++;}        //锁定一个键，用于存储矩阵扩展类型& C4 d! I; |8 w

, u! `7 u  g) a6 D
        Val.BType=luStaData_int64; Val.VType=luStaData_int64; Val.x=Matrix;        //定义整数常量3 [- S, R9 b& p9 K4 U

SetConst(L"matrix",&Val);        //设置整数常量 
7 I) c& _# N! D
        InsertKey("\0\0\0\0",4,luPubKey_User,LuMessage,NULL,NULL,1,v); //使Lu运行时可输出函数信息/ c3 A2 R5 N* s! p# ~/ Q: y4 h# Q

wcout.imbue(locale("chs"));        //设置输出的locale为中文 
& b: v) U! ?' z& S
   
% s' V) }. N+ @
        ErrCode=LuCom(ForStr,0,0,0,hFor,nPara,pPara,ErrBegin,ErrEnd); //编译表达式# e1 s! W( f) p+ O: m% ^/ W\\" s8 o

if(ErrCode)* R( U% W7 d: i1 U8 {

{* }9 j6 |# _1 ?4 c5 [) _

wcout<<L"表达式有错误！错误代码："<<ErrCode<<endl;# _5 `7 `  A6 F' l$ z  ~$ O( P

}8 R' F# o, _/ u1 ~0 Q

else 
- g5 B7 V/ x! W
        { 
8 A4 x9 X2 [1 V
                LuCal(hFor,pPara);        //计算表达式的值 
' f1 v5 w\\" U. s% e' ~2 a* M
        } 
. j8 h: g9 V\\" u/ i% a
        LockKey(Matrix,NULL,OpMatrix);//解锁键Matrix，本例中，该函数可以不用+ X/ F# ~$ A/ x( t% i

FreeLu();                        //释放Lu 
5 F. ~5 y5 \  y( m/ ]' c3 r+ V$ `
}

习题：

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

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

main(:a,b,c,d,t,i)=4 G$ @: q% r% z- u5 T
a=new[matrix,2,2,data:1.,2.,2.,1.],6 L# b }2 D6 ?% F, z& P
b=new[matrix,2,2,data:2.,1.,1.,2.],
\" t2 j& A$ D7 w- }3 L
c=new[matrix,2,2,data:2/3.,-1/3.,-1/3.,2/3.],, G2 D2 M$ |! ~, n% Q# T
t=clock(),. z% {! r/ X# u: o7 o; }
d=a*b, i=0, while{i<1000000, d=d*c*b, i++},
! J3 S& L4 _0 A u7 ^' f/ R
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\"}";//字符串表达式

复制代码

结果：