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

查看: 8899|回复: 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>
1 b9 J\\" {+ f: J! M# c
#include <iostream>2 k% }) v V% A
#include <math.h>, T( Y/ r( D. @1 S
#include "lu32.h"( v1 t# q/ r9 L3 p D7 s
) y+ [6 ]' A! f5 T7 Z. q
#pragma comment( lib, "lu32.lib" )$ N3 f: a, l8 z) \
. Q% \; Y4 {* b0 t; l
using namespace std;
\\" `6 ~* @( t9 l3 K7 O5 P( P
2 T( v% Q R2 C
luKEY Matrix=-1000; //标识矩阵类型，最终的Matrix由LockKey决定$ r0 y- _7 R9 P6 S! E- A/ k
1 W$ C7 P9 `1 s5 l4 K) H\\" K* \
void _stdcall LuMessage(wchar_t *pch)//输出动态库信息，该函数注册到Lu，由Lu二级函数调用
. {# o, O. q\\" h3 m0 B
{
2 q8 R( I* a; [5 {) H
wcout<<pch;5 t: r# D+ G% h
}
\\" B0 r: _0 H: S: G
void _stdcall DelMatrix(void *me) //用于LockKey函数，因为是基于系统内置实数数组创建矩阵，故该函数什么也不做; n% W; N+ Q6 a4 |# ?' U9 J
{
* k' W0 ?3 {9 ^\\" V9 Y
}
, K9 X3 @) V0 ?+ z
LuData _stdcall OpMatrix(luINT mm,LuData *xx,void *hFor,int theOperator) //运算符重载函数，用于LockKey函数1 h- M4 r% ~! t
{$ V' b U9 J; V9 w1 o* }' s, i
LuData a;$ X; M. t. R' ^' }. [
luRealArray *pRealArray1,*pRealArray2,*pRealArray3;
5 k: D1 p8 Q3 V4 _4 u9 ], X
luVOID i,j,k,m,n,u,v;
' L }( R; v8 v$ k! m2 U1 z
double *pa,*pb,*pc;
0 G6 q) T, x( C5 B1 ]9 m' Y! a
luMessage pMessage;, f: ?9 A& W s1 ~% S
wchar_t wchNum[32];\\" S/ d4 V- y5 f) R) w' M\\" x
char chNum[32]; ?% l; w$ z% h& `% H _
a.BType=luStaData_nil; a.VType=luStaData_nil; a.x=0;
3 r7 u) H6 h3 X\\" l1 B\\" m
switch(theOperator)/ z6 Y2 n4 ]7 B/ o, F\\" v9 U9 U- T
{
% Y' e% U0 m2 Q
case 2: //重载运算符*+ \# w t! Q; _9 e$ e! i; G9 N
pRealArray1=(luRealArray *)SearchKey((char *)&(xx->x),sizeof(luVOID),luDynData_realarray);0 i/ ?7 H! s F5 R
pRealArray2=(luRealArray *)SearchKey((char *)&((xx+1)->x),sizeof(luVOID),luDynData_realarray);
- E% u- N4 E3 w, t3 m, b5 ]
if(!pRealArray1 || !pRealArray2) break; //对象句柄无效，不是实数数组8 w* R9 M9 @( c! x8 v3 H. f
if(pRealArray1->DimLen!=2 || pRealArray2->DimLen!=2) break; //不是二维实数数组（矩阵）
& [2 o8 I# ?/ f+ i9 r1 a5 z: i
if(pRealArray1->Dim[1]!=pRealArray2->Dim[0]) break; //维数不匹配
, \, a\\" a& a1 b/ h; A* D0 O
pRealArray3=(luRealArray *)NewSysObj(luDynData_realarray,pRealArray1->Dim[0]*pRealArray2->Dim[1],2); //创建矩阵对象% X2 r- ?7 _% ]7 c1 U3 G
if(!pRealArray3) break;% I9 R& Z5 i# c
pRealArray3->Dim[0]=pRealArray1->Dim[0]; pRealArray3->Dim[1]=pRealArray2->Dim[1]; //设置矩阵维数大小% c+ `6 F7 x* Z# M' R6 G0 h K
pa=pRealArray1->Array; pb=pRealArray2->Array; pc=pRealArray3->Array;
/ z3 [3 t\\" w2 P& F5 I& ~
m=pRealArray1->Dim[0]; n=pRealArray1->Dim[1]; k=pRealArray2->Dim[1];6 ^\\" `7 E) k3 T: u& p
for(i=0; i<m; i++) //矩阵乘/ Q8 }' y0 y g* Y2 {% \' I
{0 j2 q) V/ e0 h2 P
for(j=0; j<k; j++)
+ U7 t5 A8 Y: d
{0 {+ J( U/ ` a4 U2 S# J
u=i*k+j; pc[u]=0.0;9 E3 A4 [) k9 u: m) T, q
for (v=0; v<n; v++)
0 h4 v# y' T& }9 E* z N7 c
{
' N- F5 M8 A6 J$ M) B
pc[u]=pc[u]+pa[i*n+v]*pb[v*k+j];
2 F6 G1 Y9 k& V4 B) G
}
8 ^% X! F0 _+ Q9 f' X5 Z6 [
}
' R3 R3 _: }: E4 w5 a k
}$ u; N* \4 h6 ~9 Q$ R0 g) M6 j
FunReObj(hFor); //告诉Lu，返回一个动态对象% j7 a, B. i5 {# s0 A, r
a.BType=luDynData_realarray; a.VType=Matrix; a.x=0; *(luVOID *)&(a.x)=(luVOID)pRealArray3; b- k. m3 Z. T\\" d$ d1 l5 n. I
break;0 e\\" q/ O1 e( g# d3 D; C
case 25: //重载运算符.*1 U% O7 j7 H: a3 X
pRealArray1=(luRealArray *)SearchKey((char *)&(xx->x),sizeof(luVOID),luDynData_realarray);
5 y3 W4 r\\" z+ D: V
pRealArray2=(luRealArray *)SearchKey((char *)&((xx+1)->x),sizeof(luVOID),luDynData_realarray);, V U: W+ k0 Y/ h8 v/ p
if(!pRealArray1 || !pRealArray2) break; //对象句柄无效，不是实数数组% }1 e0 x: w0 u: A& }. L5 I
if(pRealArray1->DimLen!=2 || pRealArray2->DimLen!=2) break; //不是二维实数数组（矩阵）4 {! \5 V& k5 N |5 d' l7 T
if(pRealArray1->Dim[0]!=pRealArray2->Dim[0] || pRealArray1->Dim[1]!=pRealArray2->Dim[1]) break; //维数不相同
, {# O- ^9 B& i: V4 b0 Y) c
pRealArray3=(luRealArray *)NewSysObj(luDynData_realarray,pRealArray1->ArrayLen,2); //创建矩阵对象
! b0 W6 @0 U, X9 j- L9 ?2 v; |
if(!pRealArray3) break;1 D* K' W5 k: \3 C$ K7 M
pRealArray3->Dim[0]=pRealArray1->Dim[0]; pRealArray3->Dim[1]=pRealArray1->Dim[1]; //设置矩阵维数大小9 M7 A h: g1 ~; n( {6 M
for(i=0;i<pRealArray1->ArrayLen;i++) pRealArray3->Array[i]=pRealArray1->Array[i]*pRealArray2->Array[i];//矩阵点乘$ K3 e3 w! R' w\\" H
FunReObj(hFor); //告诉Lu，返回一个动态对象
- Q9 M( t; q2 }
a.BType=luDynData_realarray; a.VType=Matrix; a.x=0; *(luVOID *)&(a.x)=(luVOID)pRealArray3;
- G8 ~/ x) @6 P( S1 `1 A
break;
8 [! D9 A1 g% V! O: k
case 46: //重载函数new
. A/ J) l- T9 {: C
a=ExeOperator(mm,xx,hFor,theOperator,luDynData_realarray); //直接调用基本类型luDynData_realarray的new函数- [$ Q) l5 m9 w% n
if(a.VType==luDynData_realarray) a.VType=Matrix; //设置扩展类型为自定义的Matrix类型\\" @8 d; \0 Z U! M, L
break;+ r7 J9 ~: o\\" P+ o+ W: q& e
case 49: //重载函数o8 z- [# t- ~\\" N; f, F! e7 Y\\" W- f
pMessage=(luMessage)SearchKey("\0\0\0\0",sizeof(luVOID),luPubKey_User);
7 T& U2 B( N' X: l7 H( f' d# X7 b- |
if(!pMessage) break;' c! `$ L$ O8 s5 a1 u2 M- W
pRealArray1=(luRealArray *)SearchKey((char *)&(xx->x),sizeof(luVOID),luDynData_realarray);. g6 w. p/ ]4 D\\" z; F* }# W
if(!pRealArray1) break; //对象句柄无效，不是实数数组
( E s9 C! j* ]( t+ r4 D+ ]
if(pRealArray1->DimLen!=2) break; //不是二维实数数组（矩阵）
\\" j, o4 V! {; }0 u) p
pa=pRealArray1->Array;
' u1 ~/ |\\" P/ |$ j% p1 H V p
m=pRealArray1->Dim[0]; n=pRealArray1->Dim[1]; k=0;
: m2 \: x8 Z. h2 [! Z# C4 P, ~
for(i=0; i<m; i++) //输出矩阵6 [, `$ o) w, V) f1 ?
{
8 \8 t/ a/ B7 M3 C4 v; o5 s6 W
pMessage(L"\r\n"); k+=2;& j$ g% c+ j$ _$ T2 R. c2 A
for(j=0; j<n; j++)
& R S9 [* R+ W, @+ h$ y9 x
{. h' z5 H: G `6 A$ m$ D$ x4 j
_gcvt_s(chNum,pa[i*n+j],16);
- ]. n7 e+ z U. l) ]: `* M9 q
for(u=0;chNum[u];u++) {wchNum[u]=chNum[u]; k++;}
i0 T+ ^0 P% S
wchNum[u]='\0';
9 \0 v% @( K# R! ]
pMessage(wchNum); pMessage(L" "); k+=2;
4 V8 e9 }: y( h# f2 X5 P
}
/ E+ X' H7 S& R+ [% j
}+ h7 W9 T* g. M% D% k
pMessage(L"\r\n"); k+=2;
& J+ ?$ o7 J) x, b
a.BType=luStaData_int64; a.VType=luStaData_int64; a.x=k; //按函数o的要求，返回输出的字符总数) K. W# F: c* T6 C0 a. ]& ~
break;7 ^! n. K, l) F. N. R2 R
default:0 {* \\\" W, c$ R- k; W! a
break;
* o B. f* |. T7 N% T6 {
}
0 d6 k* ]* Q# `1 E& A* B; h; o
return a;9 @3 g+ X2 {\\" D# h9 g
}- A# ]9 \6 A! m9 F6 d
void main(void)5 G$ {' [2 v1 ~4 m- u. A
{
+ b5 J+ I& c* n3 e* y a
void *hFor; //表达式句柄
8 i9 I4 h# Q8 H
luINT nPara; //存放表达式的自变量个数
3 \- O$ _; A) z0 t& @
LuData *pPara; //存放输入自变量的数组指针+ c) O% h: S# ?# x( X4 h
luINT ErrBegin,ErrEnd; //表达式编译出错的初始位置和结束位置
* I8 A- b9 n5 B# u0 O: l
int ErrCode; //错误代码
1 n' y' }& a4 o: W- B
void *v;4 V! `' B0 N# J! [, ?
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; @$ N9 @( I5 A) Y+ I
//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 w# w# L7 j7 v8 y6 W
LuData Val;' C. j! }8 I* B$ t( d
if(!InitLu()) return; //初始化Lu
7 s0 g( ^- w\\" H: a- a9 R7 ^, q
while(LockKey(Matrix,DelMatrix,OpMatrix)){Matrix++;} //锁定一个键，用于存储矩阵扩展类型7 h+ I' I0 q9 q: m
1 I5 o\\" B% e+ W- @% \# R
Val.BType=luStaData_int64; Val.VType=luStaData_int64; Val.x=Matrix; //定义整数常量
* y8 A. R$ M7 x' Y/ b
SetConst(L"matrix",&Val); //设置整数常量
0 P( U& F! }1 K
InsertKey("\0\0\0\0",4,luPubKey_User,LuMessage,NULL,NULL,1,v); //使Lu运行时可输出函数信息
) a( v* u\\" u% D/ j* }8 U
wcout.imbue(locale("chs")); //设置输出的locale为中文
' Q+ X a6 b. \* l/ }+ Z d9 d
, N% J9 [1 q# u5 W3 ~! C, P
ErrCode=LuCom(ForStr,0,0,0,hFor,nPara,pPara,ErrBegin,ErrEnd); //编译表达式
4 f2 X ?7 s, R; Q2 Q5 {- g8 [3 {
if(ErrCode)
\\" o9 _) I0 k Y/ \$ i7 t/ a
{- L7 R6 d7 b3 k* K
wcout<<L"表达式有错误！错误代码："<<ErrCode<<endl;
$ W D( g4 {4 c\\" n
}
* ]. o/ L; K# p* i7 s& r7 C+ w
else
- \. [4 H* I7 f8 a) f2 K( h: }6 g
{
% t: G. N1 T* y) H
LuCal(hFor,pPara); //计算表达式的值. J9 m2 K, u\\" l0 i: Y2 E5 h7 f
}9 j& u% w) F& k( x
LockKey(Matrix,NULL,OpMatrix);//解锁键Matrix，本例中，该函数可以不用
5 |3 M% M- Z/ L, d* k) p
FreeLu(); //释放Lu9 j* a/ K' c0 d, X
}

#include <windows.h> 
1 b9 J\\" {+ f: J! M# c
#include <iostream>2 k% }) v  V% A

#include <math.h>, T( Y/ r( D. @1 S

#include "lu32.h"( v1 t# q/ r9 L3 p  D7 s

) y+ [6 ]' A! f5 T7 Z. q
#pragma comment( lib, "lu32.lib" )$ N3 f: a, l8 z) \

. Q% \; Y4 {* b0 t; l

using namespace std; 
\\" `6 ~* @( t9 l3 K7 O5 P( P
2 T( v% Q  R2 C

luKEY Matrix=-1000;        //标识矩阵类型，最终的Matrix由LockKey决定$ r0 y- _7 R9 P6 S! E- A/ k

1 W$ C7 P9 `1 s5 l4 K) H\\" K* \
void _stdcall LuMessage(wchar_t *pch)//输出动态库信息，该函数注册到Lu，由Lu二级函数调用 
. {# o, O. q\\" h3 m0 B
{ 
2 q8 R( I* a; [5 {) H
        wcout<<pch;5 t: r# D+ G% h

} 
\\" B0 r: _0 H: S: G
void _stdcall DelMatrix(void *me)        //用于LockKey函数，因为是基于系统内置实数数组创建矩阵，故该函数什么也不做; n% W; N+ Q6 a4 |# ?' U9 J

{ 
* k' W0 ?3 {9 ^\\" V9 Y
} 
, K9 X3 @) V0 ?+ z
LuData _stdcall OpMatrix(luINT mm,LuData *xx,void *hFor,int theOperator)        //运算符重载函数，用于LockKey函数1 h- M4 r% ~! t

{$ V' b  U9 J; V9 w1 o* }' s, i

LuData a;$ X; M. t. R' ^' }. [

luRealArray *pRealArray1,*pRealArray2,*pRealArray3; 
5 k: D1 p8 Q3 V4 _4 u9 ], X
        luVOID i,j,k,m,n,u,v; 
' L  }( R; v8 v$ k! m2 U1 z
        double *pa,*pb,*pc; 
0 G6 q) T, x( C5 B1 ]9 m' Y! a
        luMessage pMessage;, f: ?9 A& W  s1 ~% S

wchar_t wchNum[32];\\" S/ d4 V- y5 f) R) w' M\\" x

char chNum[32];  ?% l; w$ z% h& `% H  _

a.BType=luStaData_nil; a.VType=luStaData_nil; a.x=0; 
3 r7 u) H6 h3 X\\" l1 B\\" m
        switch(theOperator)/ z6 Y2 n4 ]7 B/ o, F\\" v9 U9 U- T

{ 
% Y' e% U0 m2 Q
        case 2:        //重载运算符*+ \# w  t! Q; _9 e$ e! i; G9 N

pRealArray1=(luRealArray *)SearchKey((char *)&(xx->x),sizeof(luVOID),luDynData_realarray);0 i/ ?7 H! s  F5 R

pRealArray2=(luRealArray *)SearchKey((char *)&((xx+1)->x),sizeof(luVOID),luDynData_realarray); 
- E% u- N4 E3 w, t3 m, b5 ]
                if(!pRealArray1 || !pRealArray2) break;        //对象句柄无效，不是实数数组8 w* R9 M9 @( c! x8 v3 H. f

if(pRealArray1->DimLen!=2 || pRealArray2->DimLen!=2) break;        //不是二维实数数组（矩阵） 
& [2 o8 I# ?/ f+ i9 r1 a5 z: i
                if(pRealArray1->Dim[1]!=pRealArray2->Dim[0]) break;        //维数不匹配 
, \, a\\" a& a1 b/ h; A* D0 O
                pRealArray3=(luRealArray *)NewSysObj(luDynData_realarray,pRealArray1->Dim[0]*pRealArray2->Dim[1],2);        //创建矩阵对象% X2 r- ?7 _% ]7 c1 U3 G

if(!pRealArray3) break;% I9 R& Z5 i# c

pRealArray3->Dim[0]=pRealArray1->Dim[0]; pRealArray3->Dim[1]=pRealArray2->Dim[1];        //设置矩阵维数大小% c+ `6 F7 x* Z# M' R6 G0 h  K

pa=pRealArray1->Array; pb=pRealArray2->Array; pc=pRealArray3->Array; 
/ z3 [3 t\\" w2 P& F5 I& ~
                m=pRealArray1->Dim[0]; n=pRealArray1->Dim[1]; k=pRealArray2->Dim[1];6 ^\\" `7 E) k3 T: u& p

for(i=0; i<m; i++)        //矩阵乘/ Q8 }' y0 y  g* Y2 {% \' I

{0 j2 q) V/ e0 h2 P

for(j=0; j<k; j++) 
+ U7 t5 A8 Y: d
                        {0 {+ J( U/ `  a4 U2 S# J

u=i*k+j; pc[u]=0.0;9 E3 A4 [) k9 u: m) T, q

for (v=0; v<n; v++) 
0 h4 v# y' T& }9 E* z  N7 c
                                { 
' N- F5 M8 A6 J$ M) B
                                        pc[u]=pc[u]+pa[i*n+v]*pb[v*k+j]; 
2 F6 G1 Y9 k& V4 B) G
                                } 
8 ^% X! F0 _+ Q9 f' X5 Z6 [
                        } 
' R3 R3 _: }: E4 w5 a  k
                }$ u; N* \4 h6 ~9 Q$ R0 g) M6 j

FunReObj(hFor);        //告诉Lu，返回一个动态对象% j7 a, B. i5 {# s0 A, r

a.BType=luDynData_realarray; a.VType=Matrix; a.x=0; *(luVOID *)&(a.x)=(luVOID)pRealArray3;  b- k. m3 Z. T\\" d$ d1 l5 n. I

break;0 e\\" q/ O1 e( g# d3 D; C

case 25:        //重载运算符.*1 U% O7 j7 H: a3 X

pRealArray1=(luRealArray *)SearchKey((char *)&(xx->x),sizeof(luVOID),luDynData_realarray); 
5 y3 W4 r\\" z+ D: V
                pRealArray2=(luRealArray *)SearchKey((char *)&((xx+1)->x),sizeof(luVOID),luDynData_realarray);, V  U: W+ k0 Y/ h8 v/ p

if(!pRealArray1 || !pRealArray2) break;        //对象句柄无效，不是实数数组% }1 e0 x: w0 u: A& }. L5 I

if(pRealArray1->DimLen!=2 || pRealArray2->DimLen!=2) break;        //不是二维实数数组（矩阵）4 {! \5 V& k5 N  |5 d' l7 T

if(pRealArray1->Dim[0]!=pRealArray2->Dim[0] || pRealArray1->Dim[1]!=pRealArray2->Dim[1]) break;        //维数不相同 
, {# O- ^9 B& i: V4 b0 Y) c
                pRealArray3=(luRealArray *)NewSysObj(luDynData_realarray,pRealArray1->ArrayLen,2);        //创建矩阵对象 
! b0 W6 @0 U, X9 j- L9 ?2 v; |
                if(!pRealArray3) break;1 D* K' W5 k: \3 C$ K7 M

pRealArray3->Dim[0]=pRealArray1->Dim[0]; pRealArray3->Dim[1]=pRealArray1->Dim[1];        //设置矩阵维数大小9 M7 A  h: g1 ~; n( {6 M

for(i=0;i<pRealArray1->ArrayLen;i++) pRealArray3->Array[i]=pRealArray1->Array[i]*pRealArray2->Array[i];//矩阵点乘$ K3 e3 w! R' w\\" H

FunReObj(hFor);        //告诉Lu，返回一个动态对象 
- Q9 M( t; q2 }
                a.BType=luDynData_realarray; a.VType=Matrix; a.x=0; *(luVOID *)&(a.x)=(luVOID)pRealArray3; 
- G8 ~/ x) @6 P( S1 `1 A
                break; 
8 [! D9 A1 g% V! O: k
        case 46:        //重载函数new 
. A/ J) l- T9 {: C
                a=ExeOperator(mm,xx,hFor,theOperator,luDynData_realarray);        //直接调用基本类型luDynData_realarray的new函数- [$ Q) l5 m9 w% n

if(a.VType==luDynData_realarray) a.VType=Matrix;        //设置扩展类型为自定义的Matrix类型\\" @8 d; \0 Z  U! M, L

break;+ r7 J9 ~: o\\" P+ o+ W: q& e

case 49:        //重载函数o8 z- [# t- ~\\" N; f, F! e7 Y\\" W- f

pMessage=(luMessage)SearchKey("\0\0\0\0",sizeof(luVOID),luPubKey_User); 
7 T& U2 B( N' X: l7 H( f' d# X7 b- |
                if(!pMessage) break;' c! `$ L$ O8 s5 a1 u2 M- W

pRealArray1=(luRealArray *)SearchKey((char *)&(xx->x),sizeof(luVOID),luDynData_realarray);. g6 w. p/ ]4 D\\" z; F* }# W

if(!pRealArray1) break;        //对象句柄无效，不是实数数组 
( E  s9 C! j* ]( t+ r4 D+ ]
                if(pRealArray1->DimLen!=2) break;        //不是二维实数数组（矩阵） 
\\" j, o4 V! {; }0 u) p
                pa=pRealArray1->Array; 
' u1 ~/ |\\" P/ |$ j% p1 H  V  p
                m=pRealArray1->Dim[0]; n=pRealArray1->Dim[1]; k=0; 
: m2 \: x8 Z. h2 [! Z# C4 P, ~
                for(i=0; i<m; i++)        //输出矩阵6 [, `$ o) w, V) f1 ?

{ 
8 \8 t/ a/ B7 M3 C4 v; o5 s6 W
                        pMessage(L"\r\n"); k+=2;& j$ g% c+ j$ _$ T2 R. c2 A

for(j=0; j<n; j++) 
& R  S9 [* R+ W, @+ h$ y9 x
                        {. h' z5 H: G  `6 A$ m$ D$ x4 j

_gcvt_s(chNum,pa[i*n+j],16); 
- ]. n7 e+ z  U. l) ]: `* M9 q
                                for(u=0;chNum[u];u++) {wchNum[u]=chNum[u]; k++;} 
  i0 T+ ^0 P% S
                                wchNum[u]='\0'; 
9 \0 v% @( K# R! ]
                                pMessage(wchNum); pMessage(L"  "); k+=2; 
4 V8 e9 }: y( h# f2 X5 P
                        } 
/ E+ X' H7 S& R+ [% j
                }+ h7 W9 T* g. M% D% k

pMessage(L"\r\n"); k+=2; 
& J+ ?$ o7 J) x, b
                a.BType=luStaData_int64; a.VType=luStaData_int64; a.x=k;        //按函数o的要求，返回输出的字符总数) K. W# F: c* T6 C0 a. ]& ~

break;7 ^! n. K, l) F. N. R2 R

default:0 {* \\\" W, c$ R- k; W! a

break; 
* o  B. f* |. T7 N% T6 {
        } 
0 d6 k* ]* Q# `1 E& A* B; h; o
        return a;9 @3 g+ X2 {\\" D# h9 g

}- A# ]9 \6 A! m9 F6 d

void main(void)5 G$ {' [2 v1 ~4 m- u. A

{ 
+ b5 J+ I& c* n3 e* y  a
        void *hFor;                //表达式句柄 
8 i9 I4 h# Q8 H
        luINT nPara;                //存放表达式的自变量个数 
3 \- O$ _; A) z0 t& @
        LuData *pPara;                //存放输入自变量的数组指针+ c) O% h: S# ?# x( X4 h

luINT ErrBegin,ErrEnd;        //表达式编译出错的初始位置和结束位置 
* I8 A- b9 n5 B# u0 O: l
        int ErrCode;                //错误代码 
1 n' y' }& a4 o: W- B
        void *v;4 V! `' B0 N# J! [, ?

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; @$ N9 @( I5 A) Y+ I
        //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 w# w# L7 j7 v8 y6 W

LuData Val;' C. j! }8 I* B$ t( d

if(!InitLu()) return;        //初始化Lu 
7 s0 g( ^- w\\" H: a- a9 R7 ^, q
        while(LockKey(Matrix,DelMatrix,OpMatrix)){Matrix++;}        //锁定一个键，用于存储矩阵扩展类型7 h+ I' I0 q9 q: m

1 I5 o\\" B% e+ W- @% \# R

Val.BType=luStaData_int64; Val.VType=luStaData_int64; Val.x=Matrix;        //定义整数常量 
* y8 A. R$ M7 x' Y/ b
        SetConst(L"matrix",&Val);        //设置整数常量 
0 P( U& F! }1 K
        InsertKey("\0\0\0\0",4,luPubKey_User,LuMessage,NULL,NULL,1,v); //使Lu运行时可输出函数信息 
) a( v* u\\" u% D/ j* }8 U
        wcout.imbue(locale("chs"));        //设置输出的locale为中文 
' Q+ X  a6 b. \* l/ }+ Z  d9 d
  , N% J9 [1 q# u5 W3 ~! C, P

ErrCode=LuCom(ForStr,0,0,0,hFor,nPara,pPara,ErrBegin,ErrEnd); //编译表达式 
4 f2 X  ?7 s, R; Q2 Q5 {- g8 [3 {
        if(ErrCode) 
\\" o9 _) I0 k  Y/ \$ i7 t/ a
        {- L7 R6 d7 b3 k* K

wcout<<L"表达式有错误！错误代码："<<ErrCode<<endl; 
$ W  D( g4 {4 c\\" n
        } 
* ]. o/ L; K# p* i7 s& r7 C+ w
        else 
- \. [4 H* I7 f8 a) f2 K( h: }6 g
        { 
% t: G. N1 T* y) H
                LuCal(hFor,pPara);        //计算表达式的值. J9 m2 K, u\\" l0 i: Y2 E5 h7 f

}9 j& u% w) F& k( x

LockKey(Matrix,NULL,OpMatrix);//解锁键Matrix，本例中，该函数可以不用 
5 |3 M% M- Z/ L, d* k) p
        FreeLu();                        //释放Lu9 j* a/ K' c0 d, X

}

习题：

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

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

main(:a,b,c,d,t,i)=# T* H4 v* V J( H
a=new[matrix,2,2,data:1.,2.,2.,1.],
: P6 o0 k I; i$ Q- k( {
b=new[matrix,2,2,data:2.,1.,1.,2.],
+ Z1 z& X8 \& T- ~. D. C- Q
c=new[matrix,2,2,data:2/3.,-1/3.,-1/3.,2/3.],
1 M1 J$ n. ]& J+ e+ a, K
t=clock(),
\" \. H0 j9 Q6 q8 \( M
d=a*b, i=0, while{i<1000000, d=d*c*b, i++},
4 ]\" n- Q2 p0 M$ ?! G
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\"}";//字符串表达式

复制代码

结果：