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

查看: 8734|回复: 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>4 P$ P, ?5 d2 D( b1 J$ u: o' |
#include <iostream>
6 Z9 b2 U/ ~7 G' ]) I5 g
#include <math.h>$ y% ]\\" q. d$ R+ Z8 A. ^0 L# B
#include "lu32.h"
7 x ~5 n) D9 T8 `% J
7 R4 w$ x G# e( S0 e
#pragma comment( lib, "lu32.lib" )$ b$ T3 P5 ]$ h2 c
. T3 i3 J. b/ @& e$ R
using namespace std;
- c/ |8 q5 m9 p\\" [6 I- }, g
m/ h |1 Z/ ~7 r\\" M\\" V0 f
luKEY Matrix=-1000; //标识矩阵类型，最终的Matrix由LockKey决定. t' {1 y8 K& v/ \ _
e8 T- A1 V4 T4 f/ B* q) Z# @\\" l
void _stdcall LuMessage(wchar_t *pch)//输出动态库信息，该函数注册到Lu，由Lu二级函数调用
' w$ `2 g\\" D% v+ g/ L# g
{
/ l4 G' ^9 i8 Z8 r y6 R/ ]
wcout<<pch;
& w* J! {; n* j
}. y+ u* V$ k, p7 j( P
void _stdcall DelMatrix(void *me) //用于LockKey函数，因为是基于系统内置实数数组创建矩阵，故该函数什么也不做
6 l& i% S: u. F& d7 R
{
\\" V8 B\\" l! {, f; |. e& ^) y
}; u2 y7 v$ M; j, @# Z+ K
LuData _stdcall OpMatrix(luINT mm,LuData *xx,void *hFor,int theOperator) //运算符重载函数，用于LockKey函数
5 N6 t. G- D. q. f; A
{
9 g1 f; O) @5 A, E6 w
LuData a;$ p- A9 b+ w0 T9 N( t) ~9 x
luRealArray *pRealArray1,*pRealArray2,*pRealArray3;9 b$ Q* k* s* K7 n: l\\" J
luVOID i,j,k,m,n,u,v;* w* v' T2 F6 U$ r
double *pa,*pb,*pc;
( t! l- E, p4 y9 a' H6 e3 U
luMessage pMessage;& ^7 n' {\\" c. [* y
wchar_t wchNum[32];
1 d& N! [\\" S! n$ v6 x
char chNum[32];2 u6 _2 U! y1 B: g! } L& R, h. R
a.BType=luStaData_nil; a.VType=luStaData_nil; a.x=0;2 r) d5 [4 O! c) @1 o) M# q
switch(theOperator)
' p$ ~. |5 R) R2 d3 b# v\\" Y% g
{; Y- p% U# l, e+ S: i9 o P O7 U* T
case 2: //重载运算符*
; \9 d( S7 t+ B, I! Z% v! C
pRealArray1=(luRealArray *)SearchKey((char *)&(xx->x),sizeof(luVOID),luDynData_realarray);
- u3 e+ t\\" H\\" W2 j7 t8 z
pRealArray2=(luRealArray *)SearchKey((char *)&((xx+1)->x),sizeof(luVOID),luDynData_realarray);
3 ~. \( N9 o0 h2 `6 n- p
if(!pRealArray1 || !pRealArray2) break; //对象句柄无效，不是实数数组
# m) K# B0 w# s6 L/ r
if(pRealArray1->DimLen!=2 || pRealArray2->DimLen!=2) break; //不是二维实数数组（矩阵）
$ k) I4 k r! K: V5 K
if(pRealArray1->Dim[1]!=pRealArray2->Dim[0]) break; //维数不匹配
* Y8 {$ T5 u1 T
pRealArray3=(luRealArray *)NewSysObj(luDynData_realarray,pRealArray1->Dim[0]*pRealArray2->Dim[1],2); //创建矩阵对象; R* o1 ^/ l4 ^* o* A) ^9 q
if(!pRealArray3) break;8 n& ?$ }2 f5 \& i3 E! u2 [' S
pRealArray3->Dim[0]=pRealArray1->Dim[0]; pRealArray3->Dim[1]=pRealArray2->Dim[1]; //设置矩阵维数大小4 F6 a5 ~3 E\\" I\\" a
pa=pRealArray1->Array; pb=pRealArray2->Array; pc=pRealArray3->Array;
- i7 v' P0 A0 _9 g. J. f7 \5 d
m=pRealArray1->Dim[0]; n=pRealArray1->Dim[1]; k=pRealArray2->Dim[1]; a# T! e( ^) c. Q; `3 F
for(i=0; i<m; i++) //矩阵乘
+ p* S- C) Y( p! i/ |
{
6 Z' l! @1 B2 j4 S: p
for(j=0; j<k; j++)
. g; M6 |: J3 @6 q! a: m5 O% T
{1 t3 [\\" M, I( d; { F! {\\" q8 L2 U4 o: P; G
u=i*k+j; pc[u]=0.0;
( ~- }: Q3 {$ u! y# Q( q: ?
for (v=0; v<n; v++)
% P; w5 j* F) ?# F. e- V
{3 M1 R: z; g0 x3 f9 t. {; ]( |
pc[u]=pc[u]+pa[i*n+v]*pb[v*k+j];1 U% w( { s1 L\\" [* f( m R- g
}4 b' ^4 e; h0 z\\" m# }4 C3 p( o
}
3 r: z1 r1 z8 s. `7 l: Z
}
8 u/ h* x( y6 G, m, \* W- ?2 ^& O
FunReObj(hFor); //告诉Lu，返回一个动态对象
d. z) r# {( b+ ?% k
a.BType=luDynData_realarray; a.VType=Matrix; a.x=0; *(luVOID *)&(a.x)=(luVOID)pRealArray3;; l C2 D2 V9 U8 ]0 D2 ?
break;2 s- T5 f) s* X) V' T$ Y& ?
case 25: //重载运算符.*
' ^6 F. h) I5 c1 D4 v' t) R\\" {
pRealArray1=(luRealArray *)SearchKey((char *)&(xx->x),sizeof(luVOID),luDynData_realarray);# s2 i8 X4 i! v% V! Z8 ]! }
pRealArray2=(luRealArray *)SearchKey((char *)&((xx+1)->x),sizeof(luVOID),luDynData_realarray);* `\\" L, b. F9 L4 o m; v- ^7 I
if(!pRealArray1 || !pRealArray2) break; //对象句柄无效，不是实数数组! G7 `1 r! D+ R/ U
if(pRealArray1->DimLen!=2 || pRealArray2->DimLen!=2) break; //不是二维实数数组（矩阵）
- y( s: J' c8 R l\\" N
if(pRealArray1->Dim[0]!=pRealArray2->Dim[0] || pRealArray1->Dim[1]!=pRealArray2->Dim[1]) break; //维数不相同( s) W7 V! T! O8 n( d; F% x
pRealArray3=(luRealArray *)NewSysObj(luDynData_realarray,pRealArray1->ArrayLen,2); //创建矩阵对象9 d- _% ^4 d7 m. t
if(!pRealArray3) break;
\\" i2 n m8 K4 Z3 w) J
pRealArray3->Dim[0]=pRealArray1->Dim[0]; pRealArray3->Dim[1]=pRealArray1->Dim[1]; //设置矩阵维数大小1 [6 d h\\" I( Z
for(i=0;i<pRealArray1->ArrayLen;i++) pRealArray3->Array[i]=pRealArray1->Array[i]*pRealArray2->Array[i];//矩阵点乘
, w. v6 i6 U$ J1 A- H
FunReObj(hFor); //告诉Lu，返回一个动态对象
9 l7 I1 i& j6 `; L0 i% l# ]
a.BType=luDynData_realarray; a.VType=Matrix; a.x=0; *(luVOID *)&(a.x)=(luVOID)pRealArray3;5 J7 B. z. J1 j: h3 z4 R
break;
) o( s$ E9 \0 E) {( Q: z
case 46: //重载函数new\\" b6 U1 [( H2 K3 ~9 F* X
a=ExeOperator(mm,xx,hFor,theOperator,luDynData_realarray); //直接调用基本类型luDynData_realarray的new函数
% y) D) C- i! O\\" {& S; m8 {# S. F
if(a.VType==luDynData_realarray) a.VType=Matrix; //设置扩展类型为自定义的Matrix类型: r) I6 P. T1 A' K) \
break;
* m$ ]1 Z/ m' j2 j/ F8 ]: j3 }
case 49: //重载函数o
* g; S: q. M# h' ]% s2 Y& i: m8 G
pMessage=(luMessage)SearchKey("\0\0\0\0",sizeof(luVOID),luPubKey_User);
3 S% w8 D/ J7 O# T
if(!pMessage) break;+ L/ @! j; @0 m: v7 \( |1 u
pRealArray1=(luRealArray *)SearchKey((char *)&(xx->x),sizeof(luVOID),luDynData_realarray);
% j( e. L4 e( R& q4 V4 A
if(!pRealArray1) break; //对象句柄无效，不是实数数组
\\" y) j! C. H\\" J) e# q+ C3 @
if(pRealArray1->DimLen!=2) break; //不是二维实数数组（矩阵）
; d: v7 e6 T1 m$ X6 ] q
pa=pRealArray1->Array;$ t) F5 Z. x+ ~% Z
m=pRealArray1->Dim[0]; n=pRealArray1->Dim[1]; k=0;% n3 i+ N/ U7 H$ l\\" ?
for(i=0; i<m; i++) //输出矩阵 a0 ?( Q8 u W\\" d$ E5 B7 \% }5 t
{
# f5 Y8 j: @- S. X. |! g* o* E# |
pMessage(L"\r\n"); k+=2;# e. b# E& |* }% n! t: b
for(j=0; j<n; j++)/ Y7 _6 \/ e) x0 Q! _
{
, N/ P* Y! p4 x' H9 a% \: |0 j
_gcvt_s(chNum,pa[i*n+j],16);1 A: W* ]! ^5 a% W8 S! D
for(u=0;chNum[u];u++) {wchNum[u]=chNum[u]; k++;}8 c I* }! z5 [4 k6 O
wchNum[u]='\0';2 M6 e4 U! f) W' p
pMessage(wchNum); pMessage(L" "); k+=2; Z\\" W6 B0 [8 ^6 \% `1 p% g) x
}
2 ]# ]) {# S1 M% D1 [1 _
}
- N, K/ q6 b9 j) o, c5 N
pMessage(L"\r\n"); k+=2;
5 N) h4 u& T4 |& }/ d) V/ X: r
a.BType=luStaData_int64; a.VType=luStaData_int64; a.x=k; //按函数o的要求，返回输出的字符总数
3 q6 l% H* W& f- E
break;
b8 h; ^. ] U) C
default:+ m6 J& S, ?: s3 |' {8 W) M/ G2 n
break;
- X0 O0 `\\" z1 \
}6 l/ \9 |2 D7 L7 @0 r8 I, ?6 x
return a;( `3 l0 a7 P7 j6 p$ O( q* _8 \1 l
}
u# b* x, y. y5 }2 q& h+ X
void main(void)* E7 z0 C, e$ }& a, o- C4 E3 e
{7 M. Z: y1 U9 u' ]
void *hFor; //表达式句柄
/ S/ ^; U8 Q8 L/ q
luINT nPara; //存放表达式的自变量个数
/ x0 b# ^/ [\\" }# `
LuData *pPara; //存放输入自变量的数组指针
2 N2 y- w\\" t; K- Q( e. @! o9 i
luINT ErrBegin,ErrEnd; //表达式编译出错的初始位置和结束位置1 x& J2 A: g' J
int ErrCode; //错误代码. P' t' o/ L0 |7 p\\" ]
void *v;
- M! q' I) T% a: x, |2 h& p9 M
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.]}";//字符串表达式，矩阵乘
5 U8 t& X& U K8 P5 k1 ~
//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.]}";//字符串表达式，矩阵点乘/ Y$ ~* ?% B' F. C4 x
LuData Val;
2 d C* Z/ T2 @1 [9 C2 X8 Z2 e3 B
if(!InitLu()) return; //初始化Lu$ y0 p M5 v* l8 |1 F/ y; C( t4 p; O
while(LockKey(Matrix,DelMatrix,OpMatrix)){Matrix++;} //锁定一个键，用于存储矩阵扩展类型
) J+ ~+ f) b, p
& B$ a, e0 X8 N8 ^
Val.BType=luStaData_int64; Val.VType=luStaData_int64; Val.x=Matrix; //定义整数常量
- Q\\" B2 o. p\\" ~/ x
SetConst(L"matrix",&Val); //设置整数常量
, E3 f0 C8 S i& I c
InsertKey("\0\0\0\0",4,luPubKey_User,LuMessage,NULL,NULL,1,v); //使Lu运行时可输出函数信息# e5 h0 X& f+ U/ c+ m w2 P+ {5 D
wcout.imbue(locale("chs")); //设置输出的locale为中文( |# h3 M4 E$ C) T' E
9 P9 k7 e u* f' P: b5 i6 F
ErrCode=LuCom(ForStr,0,0,0,hFor,nPara,pPara,ErrBegin,ErrEnd); //编译表达式 E5 N4 A& S) g4 q# c
if(ErrCode)# D# G1 [8 ^; z! I
{ H; p) a5 @( R0 ~6 ?# ]9 ^
wcout<<L"表达式有错误！错误代码："<<ErrCode<<endl;
+ k& u4 E' d) k9 f# l
}3 W5 Q8 u8 q) R3 k
else0 E, V6 v: d& f* S2 h: r' ]% w
{
' }9 w6 N5 E+ B- ~' R
LuCal(hFor,pPara); //计算表达式的值
& ?* t( Z$ d6 R. v
}( Y& A+ z! n1 v6 N3 x\\" X: c\\" f6 j' S) }
LockKey(Matrix,NULL,OpMatrix);//解锁键Matrix，本例中，该函数可以不用
5 s+ ?. l+ g. M, a- U
FreeLu(); //释放Lu
- v+ U6 A0 n' J- @/ w$ ?( o( L
}

#include <windows.h>4 P$ P, ?5 d2 D( b1 J$ u: o' |

#include <iostream> 
6 Z9 b2 U/ ~7 G' ]) I5 g
#include <math.h>$ y% ]\\" q. d$ R+ Z8 A. ^0 L# B

#include "lu32.h" 
7 x  ~5 n) D9 T8 `% J
7 R4 w$ x  G# e( S0 e

#pragma comment( lib, "lu32.lib" )$ b$ T3 P5 ]$ h2 c

. T3 i3 J. b/ @& e$ R
using namespace std; 
- c/ |8 q5 m9 p\\" [6 I- }, g
  m/ h  |1 Z/ ~7 r\\" M\\" V0 f

luKEY Matrix=-1000;        //标识矩阵类型，最终的Matrix由LockKey决定. t' {1 y8 K& v/ \  _

e8 T- A1 V4 T4 f/ B* q) Z# @\\" l
void _stdcall LuMessage(wchar_t *pch)//输出动态库信息，该函数注册到Lu，由Lu二级函数调用 
' w$ `2 g\\" D% v+ g/ L# g
{ 
/ l4 G' ^9 i8 Z8 r  y6 R/ ]
        wcout<<pch; 
& w* J! {; n* j
}. y+ u* V$ k, p7 j( P

void _stdcall DelMatrix(void *me)        //用于LockKey函数，因为是基于系统内置实数数组创建矩阵，故该函数什么也不做 
6 l& i% S: u. F& d7 R
{ 
\\" V8 B\\" l! {, f; |. e& ^) y
}; u2 y7 v$ M; j, @# Z+ K

LuData _stdcall OpMatrix(luINT mm,LuData *xx,void *hFor,int theOperator)        //运算符重载函数，用于LockKey函数 
5 N6 t. G- D. q. f; A
{ 
9 g1 f; O) @5 A, E6 w
        LuData a;$ p- A9 b+ w0 T9 N( t) ~9 x

luRealArray *pRealArray1,*pRealArray2,*pRealArray3;9 b$ Q* k* s* K7 n: l\\" J

luVOID i,j,k,m,n,u,v;* w* v' T2 F6 U$ r

double *pa,*pb,*pc; 
( t! l- E, p4 y9 a' H6 e3 U
        luMessage pMessage;& ^7 n' {\\" c. [* y

wchar_t wchNum[32]; 
1 d& N! [\\" S! n$ v6 x
        char chNum[32];2 u6 _2 U! y1 B: g! }  L& R, h. R

a.BType=luStaData_nil; a.VType=luStaData_nil; a.x=0;2 r) d5 [4 O! c) @1 o) M# q

switch(theOperator) 
' p$ ~. |5 R) R2 d3 b# v\\" Y% g
        {; Y- p% U# l, e+ S: i9 o  P  O7 U* T

case 2:        //重载运算符* 
; \9 d( S7 t+ B, I! Z% v! C
                pRealArray1=(luRealArray *)SearchKey((char *)&(xx->x),sizeof(luVOID),luDynData_realarray); 
- u3 e+ t\\" H\\" W2 j7 t8 z
                pRealArray2=(luRealArray *)SearchKey((char *)&((xx+1)->x),sizeof(luVOID),luDynData_realarray); 
3 ~. \( N9 o0 h2 `6 n- p
                if(!pRealArray1 || !pRealArray2) break;        //对象句柄无效，不是实数数组 
# m) K# B0 w# s6 L/ r
                if(pRealArray1->DimLen!=2 || pRealArray2->DimLen!=2) break;        //不是二维实数数组（矩阵） 
$ k) I4 k  r! K: V5 K
                if(pRealArray1->Dim[1]!=pRealArray2->Dim[0]) break;        //维数不匹配 
* Y8 {$ T5 u1 T
                pRealArray3=(luRealArray *)NewSysObj(luDynData_realarray,pRealArray1->Dim[0]*pRealArray2->Dim[1],2);        //创建矩阵对象; R* o1 ^/ l4 ^* o* A) ^9 q

if(!pRealArray3) break;8 n& ?$ }2 f5 \& i3 E! u2 [' S

pRealArray3->Dim[0]=pRealArray1->Dim[0]; pRealArray3->Dim[1]=pRealArray2->Dim[1];        //设置矩阵维数大小4 F6 a5 ~3 E\\" I\\" a

pa=pRealArray1->Array; pb=pRealArray2->Array; pc=pRealArray3->Array; 
- i7 v' P0 A0 _9 g. J. f7 \5 d
                m=pRealArray1->Dim[0]; n=pRealArray1->Dim[1]; k=pRealArray2->Dim[1];  a# T! e( ^) c. Q; `3 F

for(i=0; i<m; i++)        //矩阵乘 
+ p* S- C) Y( p! i/ |
                { 
6 Z' l! @1 B2 j4 S: p
                        for(j=0; j<k; j++) 
. g; M6 |: J3 @6 q! a: m5 O% T
                        {1 t3 [\\" M, I( d; {  F! {\\" q8 L2 U4 o: P; G

u=i*k+j; pc[u]=0.0; 
( ~- }: Q3 {$ u! y# Q( q: ?
                                for (v=0; v<n; v++) 
% P; w5 j* F) ?# F. e- V
                                {3 M1 R: z; g0 x3 f9 t. {; ]( |

pc[u]=pc[u]+pa[i*n+v]*pb[v*k+j];1 U% w( {  s1 L\\" [* f( m  R- g

}4 b' ^4 e; h0 z\\" m# }4 C3 p( o

} 
3 r: z1 r1 z8 s. `7 l: Z
                } 
8 u/ h* x( y6 G, m, \* W- ?2 ^& O
                FunReObj(hFor);        //告诉Lu，返回一个动态对象 
  d. z) r# {( b+ ?% k
                a.BType=luDynData_realarray; a.VType=Matrix; a.x=0; *(luVOID *)&(a.x)=(luVOID)pRealArray3;; l  C2 D2 V9 U8 ]0 D2 ?

break;2 s- T5 f) s* X) V' T$ Y& ?

case 25:        //重载运算符.* 
' ^6 F. h) I5 c1 D4 v' t) R\\" {
                pRealArray1=(luRealArray *)SearchKey((char *)&(xx->x),sizeof(luVOID),luDynData_realarray);# s2 i8 X4 i! v% V! Z8 ]! }

pRealArray2=(luRealArray *)SearchKey((char *)&((xx+1)->x),sizeof(luVOID),luDynData_realarray);* `\\" L, b. F9 L4 o  m; v- ^7 I

if(!pRealArray1 || !pRealArray2) break;        //对象句柄无效，不是实数数组! G7 `1 r! D+ R/ U

if(pRealArray1->DimLen!=2 || pRealArray2->DimLen!=2) break;        //不是二维实数数组（矩阵） 
- y( s: J' c8 R  l\\" N
                if(pRealArray1->Dim[0]!=pRealArray2->Dim[0] || pRealArray1->Dim[1]!=pRealArray2->Dim[1]) break;        //维数不相同( s) W7 V! T! O8 n( d; F% x

pRealArray3=(luRealArray *)NewSysObj(luDynData_realarray,pRealArray1->ArrayLen,2);        //创建矩阵对象9 d- _% ^4 d7 m. t

if(!pRealArray3) break; 
\\" i2 n  m8 K4 Z3 w) J
                pRealArray3->Dim[0]=pRealArray1->Dim[0]; pRealArray3->Dim[1]=pRealArray1->Dim[1];        //设置矩阵维数大小1 [6 d  h\\" I( Z

for(i=0;i<pRealArray1->ArrayLen;i++) pRealArray3->Array[i]=pRealArray1->Array[i]*pRealArray2->Array[i];//矩阵点乘 
, w. v6 i6 U$ J1 A- H
                FunReObj(hFor);        //告诉Lu，返回一个动态对象 
9 l7 I1 i& j6 `; L0 i% l# ]
                a.BType=luDynData_realarray; a.VType=Matrix; a.x=0; *(luVOID *)&(a.x)=(luVOID)pRealArray3;5 J7 B. z. J1 j: h3 z4 R

break; 
) o( s$ E9 \0 E) {( Q: z
        case 46:        //重载函数new\\" b6 U1 [( H2 K3 ~9 F* X

a=ExeOperator(mm,xx,hFor,theOperator,luDynData_realarray);        //直接调用基本类型luDynData_realarray的new函数 
% y) D) C- i! O\\" {& S; m8 {# S. F
                if(a.VType==luDynData_realarray) a.VType=Matrix;        //设置扩展类型为自定义的Matrix类型: r) I6 P. T1 A' K) \

break; 
* m$ ]1 Z/ m' j2 j/ F8 ]: j3 }
        case 49:        //重载函数o 
* g; S: q. M# h' ]% s2 Y& i: m8 G
                pMessage=(luMessage)SearchKey("\0\0\0\0",sizeof(luVOID),luPubKey_User); 
3 S% w8 D/ J7 O# T
                if(!pMessage) break;+ L/ @! j; @0 m: v7 \( |1 u

pRealArray1=(luRealArray *)SearchKey((char *)&(xx->x),sizeof(luVOID),luDynData_realarray); 
% j( e. L4 e( R& q4 V4 A
                if(!pRealArray1) break;        //对象句柄无效，不是实数数组 
\\" y) j! C. H\\" J) e# q+ C3 @
                if(pRealArray1->DimLen!=2) break;        //不是二维实数数组（矩阵） 
; d: v7 e6 T1 m$ X6 ]  q
                pa=pRealArray1->Array;$ t) F5 Z. x+ ~% Z

m=pRealArray1->Dim[0]; n=pRealArray1->Dim[1]; k=0;% n3 i+ N/ U7 H$ l\\" ?

for(i=0; i<m; i++)        //输出矩阵  a0 ?( Q8 u  W\\" d$ E5 B7 \% }5 t

{ 
# f5 Y8 j: @- S. X. |! g* o* E# |
                        pMessage(L"\r\n"); k+=2;# e. b# E& |* }% n! t: b

for(j=0; j<n; j++)/ Y7 _6 \/ e) x0 Q! _

{ 
, N/ P* Y! p4 x' H9 a% \: |0 j
                                _gcvt_s(chNum,pa[i*n+j],16);1 A: W* ]! ^5 a% W8 S! D

for(u=0;chNum[u];u++) {wchNum[u]=chNum[u]; k++;}8 c  I* }! z5 [4 k6 O

wchNum[u]='\0';2 M6 e4 U! f) W' p

pMessage(wchNum); pMessage(L"  "); k+=2;  Z\\" W6 B0 [8 ^6 \% `1 p% g) x

} 
2 ]# ]) {# S1 M% D1 [1 _
                } 
- N, K/ q6 b9 j) o, c5 N
                pMessage(L"\r\n"); k+=2; 
5 N) h4 u& T4 |& }/ d) V/ X: r
                a.BType=luStaData_int64; a.VType=luStaData_int64; a.x=k;        //按函数o的要求，返回输出的字符总数 
3 q6 l% H* W& f- E
                break; 
  b8 h; ^. ]  U) C
        default:+ m6 J& S, ?: s3 |' {8 W) M/ G2 n

break; 
- X0 O0 `\\" z1 \
        }6 l/ \9 |2 D7 L7 @0 r8 I, ?6 x

return a;( `3 l0 a7 P7 j6 p$ O( q* _8 \1 l

} 
  u# b* x, y. y5 }2 q& h+ X
void main(void)* E7 z0 C, e$ }& a, o- C4 E3 e

{7 M. Z: y1 U9 u' ]

void *hFor;                //表达式句柄 
/ S/ ^; U8 Q8 L/ q
        luINT nPara;                //存放表达式的自变量个数 
/ x0 b# ^/ [\\" }# `
        LuData *pPara;                //存放输入自变量的数组指针 
2 N2 y- w\\" t; K- Q( e. @! o9 i
        luINT ErrBegin,ErrEnd;        //表达式编译出错的初始位置和结束位置1 x& J2 A: g' J

int ErrCode;                //错误代码. P' t' o/ L0 |7 p\\" ]

void *v; 
- M! q' I) T% a: x, |2 h& p9 M
        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.]}";//字符串表达式，矩阵乘 
5 U8 t& X& U  K8 P5 k1 ~
        //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.]}";//字符串表达式，矩阵点乘/ Y$ ~* ?% B' F. C4 x

LuData Val; 
2 d  C* Z/ T2 @1 [9 C2 X8 Z2 e3 B
        if(!InitLu()) return;        //初始化Lu$ y0 p  M5 v* l8 |1 F/ y; C( t4 p; O

while(LockKey(Matrix,DelMatrix,OpMatrix)){Matrix++;}        //锁定一个键，用于存储矩阵扩展类型 
) J+ ~+ f) b, p
 
& B$ a, e0 X8 N8 ^
        Val.BType=luStaData_int64; Val.VType=luStaData_int64; Val.x=Matrix;        //定义整数常量 
- Q\\" B2 o. p\\" ~/ x
        SetConst(L"matrix",&Val);        //设置整数常量 
, E3 f0 C8 S  i& I  c
        InsertKey("\0\0\0\0",4,luPubKey_User,LuMessage,NULL,NULL,1,v); //使Lu运行时可输出函数信息# e5 h0 X& f+ U/ c+ m  w2 P+ {5 D

wcout.imbue(locale("chs"));        //设置输出的locale为中文( |# h3 M4 E$ C) T' E

9 P9 k7 e  u* f' P: b5 i6 F
        ErrCode=LuCom(ForStr,0,0,0,hFor,nPara,pPara,ErrBegin,ErrEnd); //编译表达式  E5 N4 A& S) g4 q# c

if(ErrCode)# D# G1 [8 ^; z! I

{  H; p) a5 @( R0 ~6 ?# ]9 ^

wcout<<L"表达式有错误！错误代码："<<ErrCode<<endl; 
+ k& u4 E' d) k9 f# l
        }3 W5 Q8 u8 q) R3 k

else0 E, V6 v: d& f* S2 h: r' ]% w

{ 
' }9 w6 N5 E+ B- ~' R
                LuCal(hFor,pPara);        //计算表达式的值 
& ?* t( Z$ d6 R. v
        }( Y& A+ z! n1 v6 N3 x\\" X: c\\" f6 j' S) }

LockKey(Matrix,NULL,OpMatrix);//解锁键Matrix，本例中，该函数可以不用 
5 s+ ?. l+ g. M, a- U
        FreeLu();                        //释放Lu 
- v+ U6 A0 n' J- @/ w$ ?( o( L
}

习题：

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

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

main(:a,b,c,d,t,i)=0 x5 e& b0 } \/ K$ ]
a=new[matrix,2,2,data:1.,2.,2.,1.],
$ l( c. H: t) }. f9 ?( f
b=new[matrix,2,2,data:2.,1.,1.,2.],
8 A$ o# `/ W1 X) \5 Q- d
c=new[matrix,2,2,data:2/3.,-1/3.,-1/3.,2/3.],
9 K+ I) ~* M$ g+ K
t=clock(),
; n% W* d& M. |' @# [
d=a*b, i=0, while{i<1000000, d=d*c*b, i++},
4 L3 q7 q5 N N5 u0 o# z8 {
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\"}";//字符串表达式

复制代码

结果：