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

查看: 8824|回复: 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>' B2 G$ g, d: O5 E2 z, J
#include <iostream>
. h* B2 ~4 @( ?* e. W5 C
#include <math.h>
# |# l; R1 Z: v3 f. ?
#include "lu32.h"
0 q- a# }- |# N& {% Z% j( ]5 Z D
$ v+ Y; V i0 G% d2 \3 D
#pragma comment( lib, "lu32.lib" )
5 ]5 O# Q1 |/ r
\\" u9 v% X: s! A4 G
using namespace std;
. [& Q2 C' V. A2 f, Y5 a5 n4 s
\\" O- Z, d0 o) D1 ^
luKEY Matrix=-1000; //标识矩阵类型，最终的Matrix由LockKey决定% G! O H; H$ W6 g
. ~/ M0 C; ?+ t7 c* M# m. {4 j! a
void _stdcall LuMessage(wchar_t *pch)//输出动态库信息，该函数注册到Lu，由Lu二级函数调用
8 J9 o- x( }; L3 R' X1 H- {- `
{
. ]: u+ W8 D0 W% f
wcout<<pch;# o/ ^, e% n) B9 u
}& Q: O0 ?: F2 w- p
void _stdcall DelMatrix(void *me) //用于LockKey函数，因为是基于系统内置实数数组创建矩阵，故该函数什么也不做 a9 E. d3 J\\" @$ R
{; Q A- |0 R& Y( C; G1 ]& o9 X- ~
}\\" z: c; o* l! T
LuData _stdcall OpMatrix(luINT mm,LuData *xx,void *hFor,int theOperator) //运算符重载函数，用于LockKey函数) O% N( L( G5 Q* ?( g
{# H- u; |3 a1 s* v; n6 ?0 }, ^
LuData a;
0 ~ O/ M; I- o) K
luRealArray *pRealArray1,*pRealArray2,*pRealArray3;
7 }1 B& ~7 m$ s8 ?! [+ h! `
luVOID i,j,k,m,n,u,v;3 @6 k/ [4 ~8 b( r$ X! Q
double *pa,*pb,*pc;
* y9 ]( J' o% c5 U
luMessage pMessage;. t- q7 B) u$ i+ R- n7 T1 B
wchar_t wchNum[32];
$ x0 {4 ^, U! p' w7 Y! [
char chNum[32];
) j3 I# A7 I+ Z% H B$ P
a.BType=luStaData_nil; a.VType=luStaData_nil; a.x=0;
5 l1 j6 R' [# r6 q0 Y( Y% Q
switch(theOperator)
' ], l6 B\\" \ A, w; m
{5 ~2 `; I& @5 H. |7 K! N
case 2: //重载运算符** x8 B( `* ~% H1 C
pRealArray1=(luRealArray *)SearchKey((char *)&(xx->x),sizeof(luVOID),luDynData_realarray);
$ d. |7 ]$ i1 L# X\\" x4 X+ M& @
pRealArray2=(luRealArray *)SearchKey((char *)&((xx+1)->x),sizeof(luVOID),luDynData_realarray);+ J* t' P' y. w. m8 s+ `/ w
if(!pRealArray1 || !pRealArray2) break; //对象句柄无效，不是实数数组
. j8 G3 Z% Y1 Q1 Q. x
if(pRealArray1->DimLen!=2 || pRealArray2->DimLen!=2) break; //不是二维实数数组（矩阵）! ^2 ^9 K8 Y. ^$ v2 t8 f) R1 b
if(pRealArray1->Dim[1]!=pRealArray2->Dim[0]) break; //维数不匹配. d) l; s0 |- S6 a+ M7 [9 n
pRealArray3=(luRealArray *)NewSysObj(luDynData_realarray,pRealArray1->Dim[0]*pRealArray2->Dim[1],2); //创建矩阵对象$ @9 a* Q& v# m& _ e8 x2 A' y3 r
if(!pRealArray3) break;9 Q, P, |, d( q! e9 B9 d; w
pRealArray3->Dim[0]=pRealArray1->Dim[0]; pRealArray3->Dim[1]=pRealArray2->Dim[1]; //设置矩阵维数大小4 v- Q' I( z$ j3 f
pa=pRealArray1->Array; pb=pRealArray2->Array; pc=pRealArray3->Array;2 B, k% n- I1 y! P& X
m=pRealArray1->Dim[0]; n=pRealArray1->Dim[1]; k=pRealArray2->Dim[1];7 e5 |- h0 e7 U0 w8 T. x0 Y
for(i=0; i<m; i++) //矩阵乘
\\" }& ~2 ` G7 P, t& t) R
{5 h: }' Y7 t# F5 q! F, W- Z
for(j=0; j<k; j++)
' g- u\\" R0 X! y) m
{# G6 Y! i( x, V# a
u=i*k+j; pc[u]=0.0;0 V, @6 y& s\\" C, _: e
for (v=0; v<n; v++)
0 [% o* i\\" a: Z; o) c' R( r, R
{
+ v/ h2 Q, @) t
pc[u]=pc[u]+pa[i*n+v]*pb[v*k+j];
4 I+ ]; C) N5 _: Z7 k; T1 i
}
: |, F- S5 |$ E
}9 w% c. {, f0 H4 K7 }1 Z
}0 Y9 Q# \- t* D4 J8 n# M\\" C; k0 {
FunReObj(hFor); //告诉Lu，返回一个动态对象! u$ S$ n* L' B$ Z3 R! N' G( J
a.BType=luDynData_realarray; a.VType=Matrix; a.x=0; *(luVOID *)&(a.x)=(luVOID)pRealArray3;) K+ E6 ?: [5 R0 K B; _
break;
5 w0 J! k f4 F' n1 H8 @# Q. \
case 25: //重载运算符.*3 K* \) E7 `1 E0 O
pRealArray1=(luRealArray *)SearchKey((char *)&(xx->x),sizeof(luVOID),luDynData_realarray);; ?! `$ k: s, w\\" z' E\\" B
pRealArray2=(luRealArray *)SearchKey((char *)&((xx+1)->x),sizeof(luVOID),luDynData_realarray);
( E\\" ?! N; o- a7 }
if(!pRealArray1 || !pRealArray2) break; //对象句柄无效，不是实数数组
) b! W/ U6 t2 H+ l: @& o
if(pRealArray1->DimLen!=2 || pRealArray2->DimLen!=2) break; //不是二维实数数组（矩阵） e0 Z+ `3 b V/ H2 u* T+ V
if(pRealArray1->Dim[0]!=pRealArray2->Dim[0] || pRealArray1->Dim[1]!=pRealArray2->Dim[1]) break; //维数不相同
7 J3 T! K1 l4 e( s
pRealArray3=(luRealArray *)NewSysObj(luDynData_realarray,pRealArray1->ArrayLen,2); //创建矩阵对象
$ n [) X: K4 T' O' q; ~
if(!pRealArray3) break;3 F4 G+ n: {' R& B) k6 q
pRealArray3->Dim[0]=pRealArray1->Dim[0]; pRealArray3->Dim[1]=pRealArray1->Dim[1]; //设置矩阵维数大小
- C* H) e# w: h
for(i=0;i<pRealArray1->ArrayLen;i++) pRealArray3->Array[i]=pRealArray1->Array[i]*pRealArray2->Array[i];//矩阵点乘
9 m) r, G: J- _! v+ x) ~% |
FunReObj(hFor); //告诉Lu，返回一个动态对象# N- ?! d4 f( W( ^! p7 ?& i
a.BType=luDynData_realarray; a.VType=Matrix; a.x=0; *(luVOID *)&(a.x)=(luVOID)pRealArray3;/ l' }' `, {' T; z$ `
break;/ Y- S8 x. \\\" N8 P. x
case 46: //重载函数new
# W2 T6 p2 T' y8 Y S
a=ExeOperator(mm,xx,hFor,theOperator,luDynData_realarray); //直接调用基本类型luDynData_realarray的new函数
1 Y% ^2 b0 X2 B
if(a.VType==luDynData_realarray) a.VType=Matrix; //设置扩展类型为自定义的Matrix类型
; W! S* }( n( }, x& W6 }4 b
break;$ s! A6 i/ _# W# @+ |\\" R. R2 c
case 49: //重载函数o
: @3 b5 N3 p4 E3 m; |5 A
pMessage=(luMessage)SearchKey("\0\0\0\0",sizeof(luVOID),luPubKey_User);
\\" T: j( o; E! \' ]$ l2 O
if(!pMessage) break;
0 U4 q8 L8 R. g7 D% x+ C
pRealArray1=(luRealArray *)SearchKey((char *)&(xx->x),sizeof(luVOID),luDynData_realarray);) Z X3 [) _\\" f: S: H. i' [5 x
if(!pRealArray1) break; //对象句柄无效，不是实数数组
) P- W, a4 C4 G, K. G; C
if(pRealArray1->DimLen!=2) break; //不是二维实数数组（矩阵）. {- f1 ]. O) E' e) w) m. p9 y, I\\" ]
pa=pRealArray1->Array;
0 |* F/ p( [8 i: a
m=pRealArray1->Dim[0]; n=pRealArray1->Dim[1]; k=0;& j# w* A; x; k7 x Z
for(i=0; i<m; i++) //输出矩阵; ~ }4 `' ^/ n9 K+ e( a
{
2 n8 q- U7 G, T) y
pMessage(L"\r\n"); k+=2;
6 w( [7 W( w% ~# a
for(j=0; j<n; j++)
( d' h0 S\\" }/ G
{0 K+ H5 h8 X6 b- Y; p* k' ~ W
_gcvt_s(chNum,pa[i*n+j],16);
8 }; Z' {: \6 S4 ^' ?
for(u=0;chNum[u];u++) {wchNum[u]=chNum[u]; k++;}+ D9 v0 V- R& u
wchNum[u]='\0';
y$ E; a; @8 o1 A$ y
pMessage(wchNum); pMessage(L" "); k+=2;
+ K8 ?, x8 l/ d O# d/ O* h
}# O5 u4 K' l; r- A
}
& w h) i1 }2 a\\" t, u% A6 o
pMessage(L"\r\n"); k+=2;
3 `0 u3 ]4 \3 v9 f, U
a.BType=luStaData_int64; a.VType=luStaData_int64; a.x=k; //按函数o的要求，返回输出的字符总数. z1 U$ I; T+ g6 ^) {! _/ ]
break;
, c0 H; N3 b+ @ Y$ g6 @
default:) v) H) t6 g( W+ u
break;
/ r* k3 ~: d- U% D! p/ f+ U- t
}( i: d; I# p t5 }8 x, n
return a;
5 |3 W# |! C4 `
}
\\" D2 Z$ }- v- ~# p
void main(void)5 d% w# u- Z% k! g+ E! d! V, y
{, g% ~; L- j' r4 T
void *hFor; //表达式句柄( y8 F, O4 U( i z2 c' I
luINT nPara; //存放表达式的自变量个数4 N: C3 b; a2 }% q# W
LuData *pPara; //存放输入自变量的数组指针
9 S& q4 i/ l5 T% Q: j% o
luINT ErrBegin,ErrEnd; //表达式编译出错的初始位置和结束位置, h9 L; W) ?! [. [
int ErrCode; //错误代码
. t0 B A0 x# U# w! z. O
void *v;8 ~& b6 m. |' }2 I9 q4 l5 M7 U3 Z
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.]}";//字符串表达式，矩阵乘( }\\" ]\\" i) a% B' m3 Q* g+ I0 h; X7 w
//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.]}";//字符串表达式，矩阵点乘/ J\\" l4 o, O+ a8 K [3 e4 v/ H: X
LuData Val;
7 Z( B! m O# S7 }
if(!InitLu()) return; //初始化Lu
# ]$ T( o- G8 z( E$ \
while(LockKey(Matrix,DelMatrix,OpMatrix)){Matrix++;} //锁定一个键，用于存储矩阵扩展类型
0 y8 I1 \$ z( H9 {
/ w! G9 B, b\\" I\\" D
Val.BType=luStaData_int64; Val.VType=luStaData_int64; Val.x=Matrix; //定义整数常量
! k g- ?* |4 V3 N* P J% P
SetConst(L"matrix",&Val); //设置整数常量
8 y/ Y$ R; S% e6 W) Y) ~/ t, Z: e
InsertKey("\0\0\0\0",4,luPubKey_User,LuMessage,NULL,NULL,1,v); //使Lu运行时可输出函数信息
# ?7 M2 |+ L l [0 a
wcout.imbue(locale("chs")); //设置输出的locale为中文! o% g/ Z- H( H& U/ y2 i! j
' g4 [+ S: K6 j7 u7 @' s
ErrCode=LuCom(ForStr,0,0,0,hFor,nPara,pPara,ErrBegin,ErrEnd); //编译表达式( E3 z X9 F; E, G4 L+ H7 Y) T
if(ErrCode)3 I2 w& ^9 t4 \+ C2 M x8 K; ]# O
{
. N. x. u4 Y2 g# T. Y) Z+ L
wcout<<L"表达式有错误！错误代码："<<ErrCode<<endl;* L4 y\\" m$ _6 X, H5 Y# n
}! \9 [, }4 L& h& K+ }: Q8 l
else
% ^ U) u, c# M) X1 J& N
{& u\\" k$ T8 w2 g) R. _2 N
LuCal(hFor,pPara); //计算表达式的值
6 R* w ^- X: a7 ~
}
: ]8 {; }+ j2 ^! g! s
LockKey(Matrix,NULL,OpMatrix);//解锁键Matrix，本例中，该函数可以不用
/ X' }: T x. {9 `
FreeLu(); //释放Lu
- R- I- c) n2 q) |
}

#include <windows.h>' B2 G$ g, d: O5 E2 z, J

#include <iostream> 
. h* B2 ~4 @( ?* e. W5 C
#include <math.h> 
# |# l; R1 Z: v3 f. ?
#include "lu32.h" 
0 q- a# }- |# N& {% Z% j( ]5 Z  D
$ v+ Y; V  i0 G% d2 \3 D

#pragma comment( lib, "lu32.lib" ) 
5 ]5 O# Q1 |/ r
\\" u9 v% X: s! A4 G

using namespace std; 
. [& Q2 C' V. A2 f, Y5 a5 n4 s
\\" O- Z, d0 o) D1 ^

luKEY Matrix=-1000;        //标识矩阵类型，最终的Matrix由LockKey决定% G! O  H; H$ W6 g

. ~/ M0 C; ?+ t7 c* M# m. {4 j! a

void _stdcall LuMessage(wchar_t *pch)//输出动态库信息，该函数注册到Lu，由Lu二级函数调用 
8 J9 o- x( }; L3 R' X1 H- {- `
{ 
. ]: u+ W8 D0 W% f
        wcout<<pch;# o/ ^, e% n) B9 u

}& Q: O0 ?: F2 w- p

void _stdcall DelMatrix(void *me)        //用于LockKey函数，因为是基于系统内置实数数组创建矩阵，故该函数什么也不做  a9 E. d3 J\\" @$ R

{; Q  A- |0 R& Y( C; G1 ]& o9 X- ~

}\\" z: c; o* l! T

LuData _stdcall OpMatrix(luINT mm,LuData *xx,void *hFor,int theOperator)        //运算符重载函数，用于LockKey函数) O% N( L( G5 Q* ?( g

{# H- u; |3 a1 s* v; n6 ?0 }, ^

LuData a; 
0 ~  O/ M; I- o) K
        luRealArray *pRealArray1,*pRealArray2,*pRealArray3; 
7 }1 B& ~7 m$ s8 ?! [+ h! `
        luVOID i,j,k,m,n,u,v;3 @6 k/ [4 ~8 b( r$ X! Q

double *pa,*pb,*pc; 
* y9 ]( J' o% c5 U
        luMessage pMessage;. t- q7 B) u$ i+ R- n7 T1 B

wchar_t wchNum[32]; 
$ x0 {4 ^, U! p' w7 Y! [
        char chNum[32]; 
) j3 I# A7 I+ Z% H  B$ P
        a.BType=luStaData_nil; a.VType=luStaData_nil; a.x=0; 
5 l1 j6 R' [# r6 q0 Y( Y% Q
        switch(theOperator) 
' ], l6 B\\" \  A, w; m
        {5 ~2 `; I& @5 H. |7 K! N

case 2:        //重载运算符** x8 B( `* ~% H1 C

pRealArray1=(luRealArray *)SearchKey((char *)&(xx->x),sizeof(luVOID),luDynData_realarray); 
$ d. |7 ]$ i1 L# X\\" x4 X+ M& @
                pRealArray2=(luRealArray *)SearchKey((char *)&((xx+1)->x),sizeof(luVOID),luDynData_realarray);+ J* t' P' y. w. m8 s+ `/ w

if(!pRealArray1 || !pRealArray2) break;        //对象句柄无效，不是实数数组 
. j8 G3 Z% Y1 Q1 Q. x
                if(pRealArray1->DimLen!=2 || pRealArray2->DimLen!=2) break;        //不是二维实数数组（矩阵）! ^2 ^9 K8 Y. ^$ v2 t8 f) R1 b

if(pRealArray1->Dim[1]!=pRealArray2->Dim[0]) break;        //维数不匹配. d) l; s0 |- S6 a+ M7 [9 n

pRealArray3=(luRealArray *)NewSysObj(luDynData_realarray,pRealArray1->Dim[0]*pRealArray2->Dim[1],2);        //创建矩阵对象$ @9 a* Q& v# m& _  e8 x2 A' y3 r

if(!pRealArray3) break;9 Q, P, |, d( q! e9 B9 d; w

pRealArray3->Dim[0]=pRealArray1->Dim[0]; pRealArray3->Dim[1]=pRealArray2->Dim[1];        //设置矩阵维数大小4 v- Q' I( z$ j3 f

pa=pRealArray1->Array; pb=pRealArray2->Array; pc=pRealArray3->Array;2 B, k% n- I1 y! P& X

m=pRealArray1->Dim[0]; n=pRealArray1->Dim[1]; k=pRealArray2->Dim[1];7 e5 |- h0 e7 U0 w8 T. x0 Y

for(i=0; i<m; i++)        //矩阵乘 
\\" }& ~2 `  G7 P, t& t) R
                {5 h: }' Y7 t# F5 q! F, W- Z

for(j=0; j<k; j++) 
' g- u\\" R0 X! y) m
                        {# G6 Y! i( x, V# a

u=i*k+j; pc[u]=0.0;0 V, @6 y& s\\" C, _: e

for (v=0; v<n; v++) 
0 [% o* i\\" a: Z; o) c' R( r, R
                                { 
+ v/ h2 Q, @) t
                                        pc[u]=pc[u]+pa[i*n+v]*pb[v*k+j]; 
4 I+ ]; C) N5 _: Z7 k; T1 i
                                } 
: |, F- S5 |$ E
                        }9 w% c. {, f0 H4 K7 }1 Z

}0 Y9 Q# \- t* D4 J8 n# M\\" C; k0 {

FunReObj(hFor);        //告诉Lu，返回一个动态对象! u$ S$ n* L' B$ Z3 R! N' G( J

a.BType=luDynData_realarray; a.VType=Matrix; a.x=0; *(luVOID *)&(a.x)=(luVOID)pRealArray3;) K+ E6 ?: [5 R0 K  B; _

break; 
5 w0 J! k  f4 F' n1 H8 @# Q. \
        case 25:        //重载运算符.*3 K* \) E7 `1 E0 O

pRealArray1=(luRealArray *)SearchKey((char *)&(xx->x),sizeof(luVOID),luDynData_realarray);; ?! `$ k: s, w\\" z' E\\" B

pRealArray2=(luRealArray *)SearchKey((char *)&((xx+1)->x),sizeof(luVOID),luDynData_realarray); 
( E\\" ?! N; o- a7 }
                if(!pRealArray1 || !pRealArray2) break;        //对象句柄无效，不是实数数组 
) b! W/ U6 t2 H+ l: @& o
                if(pRealArray1->DimLen!=2 || pRealArray2->DimLen!=2) break;        //不是二维实数数组（矩阵）  e0 Z+ `3 b  V/ H2 u* T+ V

if(pRealArray1->Dim[0]!=pRealArray2->Dim[0] || pRealArray1->Dim[1]!=pRealArray2->Dim[1]) break;        //维数不相同 
7 J3 T! K1 l4 e( s
                pRealArray3=(luRealArray *)NewSysObj(luDynData_realarray,pRealArray1->ArrayLen,2);        //创建矩阵对象 
$ n  [) X: K4 T' O' q; ~
                if(!pRealArray3) break;3 F4 G+ n: {' R& B) k6 q

pRealArray3->Dim[0]=pRealArray1->Dim[0]; pRealArray3->Dim[1]=pRealArray1->Dim[1];        //设置矩阵维数大小 
- C* H) e# w: h
                for(i=0;i<pRealArray1->ArrayLen;i++) pRealArray3->Array[i]=pRealArray1->Array[i]*pRealArray2->Array[i];//矩阵点乘 
9 m) r, G: J- _! v+ x) ~% |
                FunReObj(hFor);        //告诉Lu，返回一个动态对象# N- ?! d4 f( W( ^! p7 ?& i

a.BType=luDynData_realarray; a.VType=Matrix; a.x=0; *(luVOID *)&(a.x)=(luVOID)pRealArray3;/ l' }' `, {' T; z$ `

break;/ Y- S8 x. \\\" N8 P. x

case 46:        //重载函数new 
# W2 T6 p2 T' y8 Y  S
                a=ExeOperator(mm,xx,hFor,theOperator,luDynData_realarray);        //直接调用基本类型luDynData_realarray的new函数 
1 Y% ^2 b0 X2 B
                if(a.VType==luDynData_realarray) a.VType=Matrix;        //设置扩展类型为自定义的Matrix类型 
; W! S* }( n( }, x& W6 }4 b
                break;$ s! A6 i/ _# W# @+ |\\" R. R2 c

case 49:        //重载函数o 
: @3 b5 N3 p4 E3 m; |5 A
                pMessage=(luMessage)SearchKey("\0\0\0\0",sizeof(luVOID),luPubKey_User); 
\\" T: j( o; E! \' ]$ l2 O
                if(!pMessage) break; 
0 U4 q8 L8 R. g7 D% x+ C
                pRealArray1=(luRealArray *)SearchKey((char *)&(xx->x),sizeof(luVOID),luDynData_realarray);) Z  X3 [) _\\" f: S: H. i' [5 x

if(!pRealArray1) break;        //对象句柄无效，不是实数数组 
) P- W, a4 C4 G, K. G; C
                if(pRealArray1->DimLen!=2) break;        //不是二维实数数组（矩阵）. {- f1 ]. O) E' e) w) m. p9 y, I\\" ]

pa=pRealArray1->Array; 
0 |* F/ p( [8 i: a
                m=pRealArray1->Dim[0]; n=pRealArray1->Dim[1]; k=0;& j# w* A; x; k7 x  Z

for(i=0; i<m; i++)        //输出矩阵; ~  }4 `' ^/ n9 K+ e( a

{ 
2 n8 q- U7 G, T) y
                        pMessage(L"\r\n"); k+=2; 
6 w( [7 W( w% ~# a
                        for(j=0; j<n; j++) 
( d' h0 S\\" }/ G
                        {0 K+ H5 h8 X6 b- Y; p* k' ~  W

_gcvt_s(chNum,pa[i*n+j],16); 
8 }; Z' {: \6 S4 ^' ?
                                for(u=0;chNum[u];u++) {wchNum[u]=chNum[u]; k++;}+ D9 v0 V- R& u

wchNum[u]='\0'; 
  y$ E; a; @8 o1 A$ y
                                pMessage(wchNum); pMessage(L"  "); k+=2; 
+ K8 ?, x8 l/ d  O# d/ O* h
                        }# O5 u4 K' l; r- A

} 
& w  h) i1 }2 a\\" t, u% A6 o
                pMessage(L"\r\n"); k+=2; 
3 `0 u3 ]4 \3 v9 f, U
                a.BType=luStaData_int64; a.VType=luStaData_int64; a.x=k;        //按函数o的要求，返回输出的字符总数. z1 U$ I; T+ g6 ^) {! _/ ]

break; 
, c0 H; N3 b+ @  Y$ g6 @
        default:) v) H) t6 g( W+ u

break; 
/ r* k3 ~: d- U% D! p/ f+ U- t
        }( i: d; I# p  t5 }8 x, n

return a; 
5 |3 W# |! C4 `
} 
\\" D2 Z$ }- v- ~# p
void main(void)5 d% w# u- Z% k! g+ E! d! V, y

{, g% ~; L- j' r4 T

void *hFor;                //表达式句柄( y8 F, O4 U( i  z2 c' I

luINT nPara;                //存放表达式的自变量个数4 N: C3 b; a2 }% q# W

LuData *pPara;                //存放输入自变量的数组指针 
9 S& q4 i/ l5 T% Q: j% o
        luINT ErrBegin,ErrEnd;        //表达式编译出错的初始位置和结束位置, h9 L; W) ?! [. [

int ErrCode;                //错误代码 
. t0 B  A0 x# U# w! z. O
        void *v;8 ~& b6 m. |' }2 I9 q4 l5 M7 U3 Z

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.]}";//字符串表达式，矩阵乘( }\\" ]\\" i) a% B' m3 Q* g+ I0 h; X7 w

//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.]}";//字符串表达式，矩阵点乘/ J\\" l4 o, O+ a8 K  [3 e4 v/ H: X

LuData Val; 
7 Z( B! m  O# S7 }
        if(!InitLu()) return;        //初始化Lu 
# ]$ T( o- G8 z( E$ \
        while(LockKey(Matrix,DelMatrix,OpMatrix)){Matrix++;}        //锁定一个键，用于存储矩阵扩展类型 
0 y8 I1 \$ z( H9 {
 
/ w! G9 B, b\\" I\\" D
        Val.BType=luStaData_int64; Val.VType=luStaData_int64; Val.x=Matrix;        //定义整数常量 
! k  g- ?* |4 V3 N* P  J% P
        SetConst(L"matrix",&Val);        //设置整数常量 
8 y/ Y$ R; S% e6 W) Y) ~/ t, Z: e
        InsertKey("\0\0\0\0",4,luPubKey_User,LuMessage,NULL,NULL,1,v); //使Lu运行时可输出函数信息 
# ?7 M2 |+ L  l  [0 a
        wcout.imbue(locale("chs"));        //设置输出的locale为中文! o% g/ Z- H( H& U/ y2 i! j

' g4 [+ S: K6 j7 u7 @' s

ErrCode=LuCom(ForStr,0,0,0,hFor,nPara,pPara,ErrBegin,ErrEnd); //编译表达式( E3 z  X9 F; E, G4 L+ H7 Y) T

if(ErrCode)3 I2 w& ^9 t4 \+ C2 M  x8 K; ]# O

{ 
. N. x. u4 Y2 g# T. Y) Z+ L
                wcout<<L"表达式有错误！错误代码："<<ErrCode<<endl;* L4 y\\" m$ _6 X, H5 Y# n

}! \9 [, }4 L& h& K+ }: Q8 l

else 
% ^  U) u, c# M) X1 J& N
        {& u\\" k$ T8 w2 g) R. _2 N

LuCal(hFor,pPara);        //计算表达式的值 
6 R* w  ^- X: a7 ~
        } 
: ]8 {; }+ j2 ^! g! s
        LockKey(Matrix,NULL,OpMatrix);//解锁键Matrix，本例中，该函数可以不用 
/ X' }: T  x. {9 `
        FreeLu();                        //释放Lu 
- R- I- c) n2 q) |
}

习题：

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

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

main(:a,b,c,d,t,i)=# m, e1 [. |5 D0 w2 o$ m& v4 U: r\" _
a=new[matrix,2,2,data:1.,2.,2.,1.],
T! w- @$ ^' K+ B3 ?3 e
b=new[matrix,2,2,data:2.,1.,1.,2.],; \ z' j: M( e: K
c=new[matrix,2,2,data:2/3.,-1/3.,-1/3.,2/3.],# @5 ?9 L5 _9 g
t=clock(),) b' v1 H& u$ `+ q8 b: x0 f
d=a*b, i=0, while{i<1000000, d=d*c*b, i++},% { F) ~7 G+ u O
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\"}";//字符串表达式

复制代码

结果：