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

查看: 8689|回复: 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> ~5 j6 E4 E\\" K+ B+ `5 E
#include <iostream>1 H% m4 \$ M* a5 W
#include <math.h>6 K. v; g4 W+ C: E
#include "lu32.h"1 j$ U5 \- C( ^2 ]5 i- f, c
0 H5 Z\\" _9 D1 L# ?$ u$ g
#pragma comment( lib, "lu32.lib" )
5 [0 |& s' P$ U6 j3 t\\" B( j
6 t3 ?5 g) @2 g, N L! g4 k# T% ^
using namespace std;
+ u2 H0 W' x7 P( l
4 h# c4 J$ C# y3 n) I( z1 A$ z4 D2 G
luKEY Matrix=-1000; //标识矩阵类型，最终的Matrix由LockKey决定4 [9 ?: p& T5 e
$ d\\" s+ F8 J2 V0 r
void _stdcall LuMessage(wchar_t *pch)//输出动态库信息，该函数注册到Lu，由Lu二级函数调用 * T6 F* I2 }0 m+ g: D7 D% K
{
- p* ?! d% c: v4 o6 G/ A\\" T
wcout<<pch;
) w( a2 L2 \ m+ c% K6 M
} d) v3 ?$ c$ B- E\\" m
void _stdcall DelMatrix(void *me) //用于LockKey函数，因为是基于系统内置实数数组创建矩阵，故该函数什么也不做6 U\\" t* S) R4 T {3 a
{! A/ `2 t, q- @8 t
}3 H7 q% P4 k2 g9 d) a- {- ?2 b9 l
LuData _stdcall OpMatrix(luINT mm,LuData *xx,void *hFor,int theOperator) //运算符重载函数，用于LockKey函数( T6 V; r. z5 O$ Y* [
{4 n& y7 s, E/ x8 S
LuData a;! t) c& C+ e0 C& H# N
luRealArray *pRealArray1,*pRealArray2,*pRealArray3;7 e+ {' a4 W0 E2 P. ]* S- i( A
luVOID i,j,k,m,n,u,v;6 l* V% F9 r% {. k L
double *pa,*pb,*pc;; s- T- _5 R7 D0 f8 ^0 f
luMessage pMessage;7 ]4 [# C% y+ P$ u
wchar_t wchNum[32];& F9 N6 U/ s( }' \
char chNum[32];* l6 c1 s$ j* M$ i2 w! l0 V6 x\\" _
a.BType=luStaData_nil; a.VType=luStaData_nil; a.x=0;
5 y; _ n |\\" L$ u; v& H! @
switch(theOperator)
. x! I, e; P' {1 N# K5 ]+ d
{& z: F2 \+ u( k5 ]! ]
case 2: //重载运算符*$ @7 M! D: h- T: b. ]' Z
pRealArray1=(luRealArray *)SearchKey((char *)&(xx->x),sizeof(luVOID),luDynData_realarray); |- D: _. D' k) o7 g4 d* f* C
pRealArray2=(luRealArray *)SearchKey((char *)&((xx+1)->x),sizeof(luVOID),luDynData_realarray);
, h5 L m+ A' V$ i
if(!pRealArray1 || !pRealArray2) break; //对象句柄无效，不是实数数组8 v! Z+ U0 u% S
if(pRealArray1->DimLen!=2 || pRealArray2->DimLen!=2) break; //不是二维实数数组（矩阵）
/ [) m' s4 D a, S' T1 M
if(pRealArray1->Dim[1]!=pRealArray2->Dim[0]) break; //维数不匹配3 j4 M) {; y4 V: c* C
pRealArray3=(luRealArray *)NewSysObj(luDynData_realarray,pRealArray1->Dim[0]*pRealArray2->Dim[1],2); //创建矩阵对象
1 B# d1 b# a) @' D1 Z
if(!pRealArray3) break;( z- f: L3 U% J, |# K, L
pRealArray3->Dim[0]=pRealArray1->Dim[0]; pRealArray3->Dim[1]=pRealArray2->Dim[1]; //设置矩阵维数大小
/ R: I/ z8 o* W0 T
pa=pRealArray1->Array; pb=pRealArray2->Array; pc=pRealArray3->Array;( n4 P2 X6 Y% j9 L
m=pRealArray1->Dim[0]; n=pRealArray1->Dim[1]; k=pRealArray2->Dim[1];
4 i4 |- q+ [ ~2 m# C
for(i=0; i<m; i++) //矩阵乘7 Y4 k/ }/ X2 z* ^3 e
{
c- {( z1 g' @- E/ Q
for(j=0; j<k; j++)
/ G( o' V9 G6 V
{
+ ]5 j, d( U# T1 Z% U; V2 `
u=i*k+j; pc[u]=0.0;/ p) q5 y9 t, J! T d. j
for (v=0; v<n; v++)% @, q; l6 X2 j r4 g* }' r L3 Z
{
& h8 |\\" @1 ?' J0 ^5 M# @/ p\\" I
pc[u]=pc[u]+pa[i*n+v]*pb[v*k+j];
* g$ z% n8 O! v8 O/ Y' t
}
# p$ m) U1 e9 H: {
}
1 ?3 p1 g+ B6 a. @7 q1 Y; z
}' c& S( p: J$ o# E) ~
FunReObj(hFor); //告诉Lu，返回一个动态对象. B/ G4 Z* K7 o
a.BType=luDynData_realarray; a.VType=Matrix; a.x=0; *(luVOID *)&(a.x)=(luVOID)pRealArray3;
$ M7 m! M8 _- j\\" U, W7 [\\" J3 I
break;
7 q) e1 z) y5 {$ J9 s7 l G
case 25: //重载运算符.*. s) ?4 G1 Q& {& I' a. \+ O) G
pRealArray1=(luRealArray *)SearchKey((char *)&(xx->x),sizeof(luVOID),luDynData_realarray);
- V$ |6 d$ ~0 i4 i: E6 G
pRealArray2=(luRealArray *)SearchKey((char *)&((xx+1)->x),sizeof(luVOID),luDynData_realarray);0 Y- ^7 u2 W: A
if(!pRealArray1 || !pRealArray2) break; //对象句柄无效，不是实数数组: d, p0 `5 Y9 N3 t8 L
if(pRealArray1->DimLen!=2 || pRealArray2->DimLen!=2) break; //不是二维实数数组（矩阵）' X/ u9 e T5 I\\" V2 A( Q1 |- C
if(pRealArray1->Dim[0]!=pRealArray2->Dim[0] || pRealArray1->Dim[1]!=pRealArray2->Dim[1]) break; //维数不相同
' o' t3 d2 {3 c
pRealArray3=(luRealArray *)NewSysObj(luDynData_realarray,pRealArray1->ArrayLen,2); //创建矩阵对象
0 a1 [4 m- {. v& J% I\\" {& L% T
if(!pRealArray3) break;
# X. O, J( W* ~
pRealArray3->Dim[0]=pRealArray1->Dim[0]; pRealArray3->Dim[1]=pRealArray1->Dim[1]; //设置矩阵维数大小
0 y- |2 d4 @ \+ ] A9 H
for(i=0;i<pRealArray1->ArrayLen;i++) pRealArray3->Array[i]=pRealArray1->Array[i]*pRealArray2->Array[i];//矩阵点乘, c H) \7 o\\" v
FunReObj(hFor); //告诉Lu，返回一个动态对象2 C* @. d/ n8 @* W- q5 y+ i
a.BType=luDynData_realarray; a.VType=Matrix; a.x=0; *(luVOID *)&(a.x)=(luVOID)pRealArray3;( [4 q3 |+ p; x+ v( Z
break;
# M\\" p6 W& g& V3 O& _. J' U! d' @
case 46: //重载函数new
: U; y7 k0 k+ l4 {1 x
a=ExeOperator(mm,xx,hFor,theOperator,luDynData_realarray); //直接调用基本类型luDynData_realarray的new函数' |! p3 x\\" b4 B
if(a.VType==luDynData_realarray) a.VType=Matrix; //设置扩展类型为自定义的Matrix类型) w# `' J% Q3 F! m\\" g
break;
% ?4 P3 d6 j2 N3 s! m6 a- g: z
case 49: //重载函数o. b) i) F& G* _' _\\" ^2 i
pMessage=(luMessage)SearchKey("\0\0\0\0",sizeof(luVOID),luPubKey_User);
6 f9 F& v/ v2 m( Z0 C
if(!pMessage) break;
! o. ~3 Q8 u/ r0 {2 Y/ W
pRealArray1=(luRealArray *)SearchKey((char *)&(xx->x),sizeof(luVOID),luDynData_realarray);/ U$ G# h* _) |) a( w$ h$ j
if(!pRealArray1) break; //对象句柄无效，不是实数数组
0 s9 m$ h0 ^ c! w- T) [/ [
if(pRealArray1->DimLen!=2) break; //不是二维实数数组（矩阵）) z0 W k5 I5 z8 H; V+ a
pa=pRealArray1->Array;
' z$ @! {: j* X- V' _/ v
m=pRealArray1->Dim[0]; n=pRealArray1->Dim[1]; k=0;
7 v+ ?5 T$ l! S5 X
for(i=0; i<m; i++) //输出矩阵! F( b# y z+ z# \
{ |# n: }3 K9 r& y% i y3 t
pMessage(L"\r\n"); k+=2;
; v; h7 T& A; \% v: D
for(j=0; j<n; j++)
2 |, A+ Q ^7 ^5 p3 ^6 X
{- A% ?# y6 ^/ v5 z
_gcvt_s(chNum,pa[i*n+j],16);
( e# S- M& L* I2 ^
for(u=0;chNum[u];u++) {wchNum[u]=chNum[u]; k++;} d. {, t. W9 R4 w7 C1 w0 a
wchNum[u]='\0';
' h- n( C2 h$ x! X% @
pMessage(wchNum); pMessage(L" "); k+=2;
7 o, P. {/ t/ J
}( L% X; x) z7 m9 c* R G
}2 D* A' g4 c$ ]5 \: |
pMessage(L"\r\n"); k+=2;
* J3 M$ }8 w$ @ @ X7 F
a.BType=luStaData_int64; a.VType=luStaData_int64; a.x=k; //按函数o的要求，返回输出的字符总数
1 Z9 v) V: U f7 ~: c4 y p
break;
; m, [' ~3 z\\" J\\" ^
default:
break;4 n7 Y/ d6 E. l e5 _0 l
}8 ]; r( U+ i\\" c0 t2 H9 _\\" `* N9 H
return a;; y! k2 | D A* B0 ~( M! l
}& b! x* u& f2 |. N$ [
void main(void)- U' Y& M7 C6 M k
{
4 k) t9 v4 ]* W9 W$ r) {
void *hFor; //表达式句柄
, L& B, \. l+ P) e5 g& i
luINT nPara; //存放表达式的自变量个数
U% ~/ `% |\\" x% p
LuData *pPara; //存放输入自变量的数组指针
# A/ U9 p5 h& G6 N5 E% M7 e( r; u
luINT ErrBegin,ErrEnd; //表达式编译出错的初始位置和结束位置
8 ?/ ?\\" |; I/ k$ h, P+ Y1 C
int ErrCode; //错误代码 O# N9 x5 _% X* L0 D! \! g. J\\" } w
void *v;
2 h8 |$ r1 m1 w, A
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.]}";//字符串表达式，矩阵乘# R# h4 w7 M\\" D. i\\" 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.]}";//字符串表达式，矩阵点乘
- V6 y. o2 H V1 H7 l3 z. u
LuData Val;6 _. s) D2 i* N
if(!InitLu()) return; //初始化Lu& p9 S6 c# H/ t! U\\" u
while(LockKey(Matrix,DelMatrix,OpMatrix)){Matrix++;} //锁定一个键，用于存储矩阵扩展类型
, a; U9 u$ l1 ]
$ F( H. L. Q4 [5 }# T6 I
Val.BType=luStaData_int64; Val.VType=luStaData_int64; Val.x=Matrix; //定义整数常量
9 S O# k2 N' R7 }+ O
SetConst(L"matrix",&Val); //设置整数常量
4 @4 G! H* V! U n
InsertKey("\0\0\0\0",4,luPubKey_User,LuMessage,NULL,NULL,1,v); //使Lu运行时可输出函数信息
0 ]: g4 n2 G$ I/ z6 R' A! i7 `
wcout.imbue(locale("chs")); //设置输出的locale为中文6 S- f- j& ~5 U2 n* R: r& S3 d
; h* G1 r: G2 y1 T1 T
ErrCode=LuCom(ForStr,0,0,0,hFor,nPara,pPara,ErrBegin,ErrEnd); //编译表达式$ i3 m. y1 R1 r% n6 j0 O0 g
if(ErrCode)
. `. g$ p6 m6 D$ ^* C7 }) h
{& x% s$ k6 R' X. h8 c5 x1 I- @! C
wcout<<L"表达式有错误！错误代码："<<ErrCode<<endl;& {! i! |& t# b/ `# ?
}
. u( x4 w- }$ [; Y
else
g* K* z* R3 @5 O( g/ Q
{
9 d2 Y\\" c3 [5 w' O
LuCal(hFor,pPara); //计算表达式的值
' L1 U1 Y$ c! G+ \. ?
}# X9 Q# h s# H8 I, H& B- \6 G
LockKey(Matrix,NULL,OpMatrix);//解锁键Matrix，本例中，该函数可以不用: S0 @5 Q6 M6 r. B
FreeLu(); //释放Lu
\\" N5 u1 ^0 y/ \; {8 g9 b, g
}

#include <windows.h>  ~5 j6 E4 E\\" K+ B+ `5 E

#include <iostream>1 H% m4 \$ M* a5 W

#include <math.h>6 K. v; g4 W+ C: E

#include "lu32.h"1 j$ U5 \- C( ^2 ]5 i- f, c

0 H5 Z\\" _9 D1 L# ?$ u$ g

#pragma comment( lib, "lu32.lib" ) 
5 [0 |& s' P$ U6 j3 t\\" B( j
6 t3 ?5 g) @2 g, N  L! g4 k# T% ^

using namespace std; 
+ u2 H0 W' x7 P( l
4 h# c4 J$ C# y3 n) I( z1 A$ z4 D2 G

luKEY Matrix=-1000;        //标识矩阵类型，最终的Matrix由LockKey决定4 [9 ?: p& T5 e

$ d\\" s+ F8 J2 V0 r

void _stdcall LuMessage(wchar_t *pch)//输出动态库信息，该函数注册到Lu，由Lu二级函数调用 * T6 F* I2 }0 m+ g: D7 D% K

{ 
- p* ?! d% c: v4 o6 G/ A\\" T
        wcout<<pch; 
) w( a2 L2 \  m+ c% K6 M
}  d) v3 ?$ c$ B- E\\" m

void _stdcall DelMatrix(void *me)        //用于LockKey函数，因为是基于系统内置实数数组创建矩阵，故该函数什么也不做6 U\\" t* S) R4 T  {3 a

{! A/ `2 t, q- @8 t

}3 H7 q% P4 k2 g9 d) a- {- ?2 b9 l

LuData _stdcall OpMatrix(luINT mm,LuData *xx,void *hFor,int theOperator)        //运算符重载函数，用于LockKey函数( T6 V; r. z5 O$ Y* [

{4 n& y7 s, E/ x8 S

LuData a;! t) c& C+ e0 C& H# N

luRealArray *pRealArray1,*pRealArray2,*pRealArray3;7 e+ {' a4 W0 E2 P. ]* S- i( A

luVOID i,j,k,m,n,u,v;6 l* V% F9 r% {. k  L

double *pa,*pb,*pc;; s- T- _5 R7 D0 f8 ^0 f

luMessage pMessage;7 ]4 [# C% y+ P$ u

wchar_t wchNum[32];& F9 N6 U/ s( }' \

char chNum[32];* l6 c1 s$ j* M$ i2 w! l0 V6 x\\" _

a.BType=luStaData_nil; a.VType=luStaData_nil; a.x=0; 
5 y; _  n  |\\" L$ u; v& H! @
        switch(theOperator) 
. x! I, e; P' {1 N# K5 ]+ d
        {& z: F2 \+ u( k5 ]! ]

case 2:        //重载运算符*$ @7 M! D: h- T: b. ]' Z

pRealArray1=(luRealArray *)SearchKey((char *)&(xx->x),sizeof(luVOID),luDynData_realarray);  |- D: _. D' k) o7 g4 d* f* C

pRealArray2=(luRealArray *)SearchKey((char *)&((xx+1)->x),sizeof(luVOID),luDynData_realarray); 
, h5 L  m+ A' V$ i
                if(!pRealArray1 || !pRealArray2) break;        //对象句柄无效，不是实数数组8 v! Z+ U0 u% S

if(pRealArray1->DimLen!=2 || pRealArray2->DimLen!=2) break;        //不是二维实数数组（矩阵） 
/ [) m' s4 D  a, S' T1 M
                if(pRealArray1->Dim[1]!=pRealArray2->Dim[0]) break;        //维数不匹配3 j4 M) {; y4 V: c* C

pRealArray3=(luRealArray *)NewSysObj(luDynData_realarray,pRealArray1->Dim[0]*pRealArray2->Dim[1],2);        //创建矩阵对象 
1 B# d1 b# a) @' D1 Z
                if(!pRealArray3) break;( z- f: L3 U% J, |# K, L

pRealArray3->Dim[0]=pRealArray1->Dim[0]; pRealArray3->Dim[1]=pRealArray2->Dim[1];        //设置矩阵维数大小 
/ R: I/ z8 o* W0 T
                pa=pRealArray1->Array; pb=pRealArray2->Array; pc=pRealArray3->Array;( n4 P2 X6 Y% j9 L

m=pRealArray1->Dim[0]; n=pRealArray1->Dim[1]; k=pRealArray2->Dim[1]; 
4 i4 |- q+ [  ~2 m# C
                for(i=0; i<m; i++)        //矩阵乘7 Y4 k/ }/ X2 z* ^3 e

{ 
  c- {( z1 g' @- E/ Q
                        for(j=0; j<k; j++) 
/ G( o' V9 G6 V
                        { 
+ ]5 j, d( U# T1 Z% U; V2 `
                                u=i*k+j; pc[u]=0.0;/ p) q5 y9 t, J! T  d. j

for (v=0; v<n; v++)% @, q; l6 X2 j  r4 g* }' r  L3 Z

{ 
& h8 |\\" @1 ?' J0 ^5 M# @/ p\\" I
                                        pc[u]=pc[u]+pa[i*n+v]*pb[v*k+j]; 
* g$ z% n8 O! v8 O/ Y' t
                                } 
# p$ m) U1 e9 H: {
                        } 
1 ?3 p1 g+ B6 a. @7 q1 Y; z
                }' c& S( p: J$ o# E) ~

FunReObj(hFor);        //告诉Lu，返回一个动态对象. B/ G4 Z* K7 o

a.BType=luDynData_realarray; a.VType=Matrix; a.x=0; *(luVOID *)&(a.x)=(luVOID)pRealArray3; 
$ M7 m! M8 _- j\\" U, W7 [\\" J3 I
                break; 
7 q) e1 z) y5 {$ J9 s7 l  G
        case 25:        //重载运算符.*. s) ?4 G1 Q& {& I' a. \+ O) G

pRealArray1=(luRealArray *)SearchKey((char *)&(xx->x),sizeof(luVOID),luDynData_realarray); 
- V$ |6 d$ ~0 i4 i: E6 G
                pRealArray2=(luRealArray *)SearchKey((char *)&((xx+1)->x),sizeof(luVOID),luDynData_realarray);0 Y- ^7 u2 W: A

if(!pRealArray1 || !pRealArray2) break;        //对象句柄无效，不是实数数组: d, p0 `5 Y9 N3 t8 L

if(pRealArray1->DimLen!=2 || pRealArray2->DimLen!=2) break;        //不是二维实数数组（矩阵）' X/ u9 e  T5 I\\" V2 A( Q1 |- C

if(pRealArray1->Dim[0]!=pRealArray2->Dim[0] || pRealArray1->Dim[1]!=pRealArray2->Dim[1]) break;        //维数不相同 
' o' t3 d2 {3 c
                pRealArray3=(luRealArray *)NewSysObj(luDynData_realarray,pRealArray1->ArrayLen,2);        //创建矩阵对象 
0 a1 [4 m- {. v& J% I\\" {& L% T
                if(!pRealArray3) break; 
# X. O, J( W* ~
                pRealArray3->Dim[0]=pRealArray1->Dim[0]; pRealArray3->Dim[1]=pRealArray1->Dim[1];        //设置矩阵维数大小 
0 y- |2 d4 @  \+ ]  A9 H
                for(i=0;i<pRealArray1->ArrayLen;i++) pRealArray3->Array[i]=pRealArray1->Array[i]*pRealArray2->Array[i];//矩阵点乘, c  H) \7 o\\" v

FunReObj(hFor);        //告诉Lu，返回一个动态对象2 C* @. d/ n8 @* W- q5 y+ i

a.BType=luDynData_realarray; a.VType=Matrix; a.x=0; *(luVOID *)&(a.x)=(luVOID)pRealArray3;( [4 q3 |+ p; x+ v( Z

break; 
# M\\" p6 W& g& V3 O& _. J' U! d' @
        case 46:        //重载函数new 
: U; y7 k0 k+ l4 {1 x
                a=ExeOperator(mm,xx,hFor,theOperator,luDynData_realarray);        //直接调用基本类型luDynData_realarray的new函数' |! p3 x\\" b4 B

if(a.VType==luDynData_realarray) a.VType=Matrix;        //设置扩展类型为自定义的Matrix类型) w# `' J% Q3 F! m\\" g

break; 
% ?4 P3 d6 j2 N3 s! m6 a- g: z
        case 49:        //重载函数o. b) i) F& G* _' _\\" ^2 i

pMessage=(luMessage)SearchKey("\0\0\0\0",sizeof(luVOID),luPubKey_User); 
6 f9 F& v/ v2 m( Z0 C
                if(!pMessage) break; 
! o. ~3 Q8 u/ r0 {2 Y/ W
                pRealArray1=(luRealArray *)SearchKey((char *)&(xx->x),sizeof(luVOID),luDynData_realarray);/ U$ G# h* _) |) a( w$ h$ j

if(!pRealArray1) break;        //对象句柄无效，不是实数数组 
0 s9 m$ h0 ^  c! w- T) [/ [
                if(pRealArray1->DimLen!=2) break;        //不是二维实数数组（矩阵）) z0 W  k5 I5 z8 H; V+ a

pa=pRealArray1->Array; 
' z$ @! {: j* X- V' _/ v
                m=pRealArray1->Dim[0]; n=pRealArray1->Dim[1]; k=0; 
7 v+ ?5 T$ l! S5 X
                for(i=0; i<m; i++)        //输出矩阵! F( b# y  z+ z# \

{  |# n: }3 K9 r& y% i  y3 t

pMessage(L"\r\n"); k+=2; 
; v; h7 T& A; \% v: D
                        for(j=0; j<n; j++) 
2 |, A+ Q  ^7 ^5 p3 ^6 X
                        {- A% ?# y6 ^/ v5 z

_gcvt_s(chNum,pa[i*n+j],16); 
( e# S- M& L* I2 ^
                                for(u=0;chNum[u];u++) {wchNum[u]=chNum[u]; k++;}  d. {, t. W9 R4 w7 C1 w0 a

wchNum[u]='\0'; 
' h- n( C2 h$ x! X% @
                                pMessage(wchNum); pMessage(L"  "); k+=2; 
7 o, P. {/ t/ J
                        }( L% X; x) z7 m9 c* R  G

}2 D* A' g4 c$ ]5 \: |

pMessage(L"\r\n"); k+=2; 
* J3 M$ }8 w$ @  @  X7 F
                a.BType=luStaData_int64; a.VType=luStaData_int64; a.x=k;        //按函数o的要求，返回输出的字符总数 
1 Z9 v) V: U  f7 ~: c4 y  p
                break; 
; m, [' ~3 z\\" J\\" ^
        default: 
& W  z* w6 v% q6 P* x: d\\" g- @3 F: S
                break;4 n7 Y/ d6 E. l  e5 _0 l

}8 ]; r( U+ i\\" c0 t2 H9 _\\" `* N9 H

return a;; y! k2 |  D  A* B0 ~( M! l

}& b! x* u& f2 |. N$ [

void main(void)- U' Y& M7 C6 M  k

{ 
4 k) t9 v4 ]* W9 W$ r) {
        void *hFor;                //表达式句柄 
, L& B, \. l+ P) e5 g& i
        luINT nPara;                //存放表达式的自变量个数 
  U% ~/ `% |\\" x% p
        LuData *pPara;                //存放输入自变量的数组指针 
# A/ U9 p5 h& G6 N5 E% M7 e( r; u
        luINT ErrBegin,ErrEnd;        //表达式编译出错的初始位置和结束位置 
8 ?/ ?\\" |; I/ k$ h, P+ Y1 C
        int ErrCode;                //错误代码  O# N9 x5 _% X* L0 D! \! g. J\\" }  w

void *v; 
2 h8 |$ r1 m1 w, A
        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.]}";//字符串表达式，矩阵乘# R# h4 w7 M\\" D. i\\" 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.]}";//字符串表达式，矩阵点乘 
- V6 y. o2 H  V1 H7 l3 z. u
        LuData Val;6 _. s) D2 i* N

if(!InitLu()) return;        //初始化Lu& p9 S6 c# H/ t! U\\" u

while(LockKey(Matrix,DelMatrix,OpMatrix)){Matrix++;}        //锁定一个键，用于存储矩阵扩展类型 
, a; U9 u$ l1 ]
$ F( H. L. Q4 [5 }# T6 I

Val.BType=luStaData_int64; Val.VType=luStaData_int64; Val.x=Matrix;        //定义整数常量 
9 S  O# k2 N' R7 }+ O
        SetConst(L"matrix",&Val);        //设置整数常量 
4 @4 G! H* V! U  n
        InsertKey("\0\0\0\0",4,luPubKey_User,LuMessage,NULL,NULL,1,v); //使Lu运行时可输出函数信息 
0 ]: g4 n2 G$ I/ z6 R' A! i7 `
        wcout.imbue(locale("chs"));        //设置输出的locale为中文6 S- f- j& ~5 U2 n* R: r& S3 d

; h* G1 r: G2 y1 T1 T
        ErrCode=LuCom(ForStr,0,0,0,hFor,nPara,pPara,ErrBegin,ErrEnd); //编译表达式$ i3 m. y1 R1 r% n6 j0 O0 g

if(ErrCode) 
. `. g$ p6 m6 D$ ^* C7 }) h
        {& x% s$ k6 R' X. h8 c5 x1 I- @! C

wcout<<L"表达式有错误！错误代码："<<ErrCode<<endl;& {! i! |& t# b/ `# ?

} 
. u( x4 w- }$ [; Y
        else 
  g* K* z* R3 @5 O( g/ Q
        { 
9 d2 Y\\" c3 [5 w' O
                LuCal(hFor,pPara);        //计算表达式的值 
' L1 U1 Y$ c! G+ \. ?
        }# X9 Q# h  s# H8 I, H& B- \6 G

LockKey(Matrix,NULL,OpMatrix);//解锁键Matrix，本例中，该函数可以不用: S0 @5 Q6 M6 r. B

FreeLu();                        //释放Lu 
\\" N5 u1 ^0 y/ \; {8 g9 b, g
}

习题：

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

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

main(:a,b,c,d,t,i)=
: T% J% W5 E3 ]; [
a=new[matrix,2,2,data:1.,2.,2.,1.],# X3 I5 J' p% A) l
b=new[matrix,2,2,data:2.,1.,1.,2.],
: t+ L, r* r0 N: t9 y# \
c=new[matrix,2,2,data:2/3.,-1/3.,-1/3.,2/3.],6 s T/ u0 l7 p, t/ u. R! x
t=clock(),
. w/ ?/ Y k- D3 Y1 S6 i
d=a*b, i=0, while{i<1000000, d=d*c*b, i++},& P; [' I% \) k8 |( J
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\"}";//字符串表达式

复制代码

结果：