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

查看: 8749|回复: 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>
#include <iostream>
/ E# ^2 l; ^: a% u) p7 K
#include <math.h>0 o N' s: e8 Q+ H
#include "lu32.h"
' }$ H, X* j5 _2 }( p8 w
- n8 c! t) L- F
#pragma comment( lib, "lu32.lib" )
3 @$ B5 ~ ?# d9 x# v# T/ M/ F% i8 k
( L/ K* _' f# V. f
using namespace std;/ X0 A$ o4 Y# v6 e- @' W
\\" w: F# Z4 A# b E6 Q
luKEY Matrix=-1000; //标识矩阵类型，最终的Matrix由LockKey决定
! [& Z6 E- v2 ?- P h
) x2 g* T. K e7 p3 M1 V+ c
void _stdcall LuMessage(wchar_t *pch)//输出动态库信息，该函数注册到Lu，由Lu二级函数调用
8 _4 ~- k. O; L4 ~8 y) @7 T4 d. ~
{
4 T# Z2 | e% F! ^
wcout<<pch;' r+ L W$ G q; r
}
void _stdcall DelMatrix(void *me) //用于LockKey函数，因为是基于系统内置实数数组创建矩阵，故该函数什么也不做$ B9 C6 D! Q$ m6 {' f( r
{+ j0 e/ n# q! d8 D+ M0 R
}\\" N\\" u$ k5 _1 }( k
LuData _stdcall OpMatrix(luINT mm,LuData *xx,void *hFor,int theOperator) //运算符重载函数，用于LockKey函数
/ e1 t1 W# ?/ A9 v3 V
{ D8 t. H1 T1 J, l, B
LuData a;4 E& c! W, z, u/ p: k* z8 Q
luRealArray *pRealArray1,*pRealArray2,*pRealArray3;/ |3 {2 K) ?: L }\\" e
luVOID i,j,k,m,n,u,v;
& ]' K# I5 q4 j8 b: a6 t2 i) S
double *pa,*pb,*pc;' Q\\" `+ Z1 x! t# s
luMessage pMessage;
: s& V! I( w\\" a$ [
wchar_t wchNum[32];
- |1 {5 U) b% N; S. j0 k
char chNum[32]; u( X [1 Z) e; p2 M
a.BType=luStaData_nil; a.VType=luStaData_nil; a.x=0;/ \7 W- `1 `' a
switch(theOperator); `3 x) Y3 f/ I/ ^; q8 I
{
( ?8 |+ K4 e! y
case 2: //重载运算符*# O' p) R' x n4 R: V& Z
pRealArray1=(luRealArray *)SearchKey((char *)&(xx->x),sizeof(luVOID),luDynData_realarray);
, s+ h6 D\\" C( R7 Q; t
pRealArray2=(luRealArray *)SearchKey((char *)&((xx+1)->x),sizeof(luVOID),luDynData_realarray);4 P0 _! d5 ?+ u1 I! Y) J3 o- t f
if(!pRealArray1 || !pRealArray2) break; //对象句柄无效，不是实数数组
0 z# Z' r: s7 ~0 c7 y. q
if(pRealArray1->DimLen!=2 || pRealArray2->DimLen!=2) break; //不是二维实数数组（矩阵）7 H5 D$ C' {: I1 z: k( e2 N
if(pRealArray1->Dim[1]!=pRealArray2->Dim[0]) break; //维数不匹配\\" U8 K, P5 e4 b, P
pRealArray3=(luRealArray *)NewSysObj(luDynData_realarray,pRealArray1->Dim[0]*pRealArray2->Dim[1],2); //创建矩阵对象: O$ E1 G! p6 `4 }1 N% _/ `
if(!pRealArray3) break;+ l( Y$ \- \# g; H# b' n( w4 o3 ?
pRealArray3->Dim[0]=pRealArray1->Dim[0]; pRealArray3->Dim[1]=pRealArray2->Dim[1]; //设置矩阵维数大小
: b3 {7 V9 n# F\\" B
pa=pRealArray1->Array; pb=pRealArray2->Array; pc=pRealArray3->Array;
# L: D1 {7 M7 ~/ B' t
m=pRealArray1->Dim[0]; n=pRealArray1->Dim[1]; k=pRealArray2->Dim[1];
- ^8 J$ H4 c$ j6 N
for(i=0; i<m; i++) //矩阵乘
{
* m$ H) g3 W% i! k7 K- h
for(j=0; j<k; j++)
3 P) \) p: |* r
{) A6 n' { `& ]+ M3 h. ?
u=i*k+j; pc[u]=0.0;
7 i3 {+ V* j. g1 l
for (v=0; v<n; v++)+ ?' |. _6 U, w j+ D
{
0 k! \* U% r, y\\" u/ F/ `+ m& _
pc[u]=pc[u]+pa[i*n+v]*pb[v*k+j];
\\" b) \- ^2 v( B0 l! `
}
1 ?5 K% W: J+ _# Z; Q\\" E. ~8 g
}! p7 B2 Y+ |6 ]\\" \$ _
}4 Z/ z f+ a1 ?6 V& W }
FunReObj(hFor); //告诉Lu，返回一个动态对象
4 Q\\" n0 {$ O& |1 V* ?
a.BType=luDynData_realarray; a.VType=Matrix; a.x=0; *(luVOID *)&(a.x)=(luVOID)pRealArray3;
- D6 k% m& n8 H; D4 T8 B
break;
4 R4 E- w% ~& e. G4 k
case 25: //重载运算符.*
6 S& H) f( d) S6 j
pRealArray1=(luRealArray *)SearchKey((char *)&(xx->x),sizeof(luVOID),luDynData_realarray);
7 Z- n8 U; `* [9 T. G+ I- ^( u% K
pRealArray2=(luRealArray *)SearchKey((char *)&((xx+1)->x),sizeof(luVOID),luDynData_realarray);5 {3 T/ z+ G# r) [/ _1 l
if(!pRealArray1 || !pRealArray2) break; //对象句柄无效，不是实数数组) ?8 V1 _. y, H; f
if(pRealArray1->DimLen!=2 || pRealArray2->DimLen!=2) break; //不是二维实数数组（矩阵）
# C- c: @& n( ?, y& ]( i% O8 l\\" t
if(pRealArray1->Dim[0]!=pRealArray2->Dim[0] || pRealArray1->Dim[1]!=pRealArray2->Dim[1]) break; //维数不相同
6 y7 `4 {* z4 {: W
pRealArray3=(luRealArray *)NewSysObj(luDynData_realarray,pRealArray1->ArrayLen,2); //创建矩阵对象
: g) W\\" f0 m\\" o3 r, s! S
if(!pRealArray3) break;8 D6 i9 e* u8 l! B
pRealArray3->Dim[0]=pRealArray1->Dim[0]; pRealArray3->Dim[1]=pRealArray1->Dim[1]; //设置矩阵维数大小3 U d. c: u7 S- p
for(i=0;i<pRealArray1->ArrayLen;i++) pRealArray3->Array[i]=pRealArray1->Array[i]*pRealArray2->Array[i];//矩阵点乘
; W\\" ?9 [8 t: `9 G8 Y4 U
FunReObj(hFor); //告诉Lu，返回一个动态对象
! ]8 _& R& Y5 d- x9 r, T# a/ E
a.BType=luDynData_realarray; a.VType=Matrix; a.x=0; *(luVOID *)&(a.x)=(luVOID)pRealArray3;$ D ^, B- Z2 N! P
break;\\" {+ `6 B/ i4 _. y7 h2 Q) n
case 46: //重载函数new
4 w4 |3 D5 j! W8 P8 L6 i: F: Z\\" d
a=ExeOperator(mm,xx,hFor,theOperator,luDynData_realarray); //直接调用基本类型luDynData_realarray的new函数
3 c; X+ V o: P+ a+ C& F
if(a.VType==luDynData_realarray) a.VType=Matrix; //设置扩展类型为自定义的Matrix类型
break;; F+ k9 w9 `' \1 @
case 49: //重载函数o \0 C7 r3 O$ G& F) ?6 ?
pMessage=(luMessage)SearchKey("\0\0\0\0",sizeof(luVOID),luPubKey_User);
& C8 l& \9 y) V! Y2 C7 G+ A7 S
if(!pMessage) break;. q! S$ ?9 G l% `- [
pRealArray1=(luRealArray *)SearchKey((char *)&(xx->x),sizeof(luVOID),luDynData_realarray);
! M s3 `/ b n/ L- r- ]
if(!pRealArray1) break; //对象句柄无效，不是实数数组- e2 M6 H% Z8 D8 M8 D6 B1 \
if(pRealArray1->DimLen!=2) break; //不是二维实数数组（矩阵）4 U+ }& q9 Z9 \; j
pa=pRealArray1->Array;
5 T* j/ A* O6 N u$ d
m=pRealArray1->Dim[0]; n=pRealArray1->Dim[1]; k=0;! a$ \ ?& [+ V8 Q. o6 b
for(i=0; i<m; i++) //输出矩阵
. D2 x' }# g\\" F9 @6 o
{
+ C( `; M: x( g9 R; d( I: }' m7 `
pMessage(L"\r\n"); k+=2;
for(j=0; j<n; j++)+ K2 i* ] _0 T0 n' A
{& ^$ \2 b# U% l1 p1 q. {
_gcvt_s(chNum,pa[i*n+j],16);\\" h/ R/ S+ O2 l7 t1 ?2 I: O/ s/ d3 H0 {
for(u=0;chNum[u];u++) {wchNum[u]=chNum[u]; k++;}! s1 p7 @\\" \( w! r
wchNum[u]='\0';. K6 q i0 A7 h6 H
pMessage(wchNum); pMessage(L" "); k+=2;
d% P9 C\\" v1 @
}
7 ?! q2 t) l8 l x7 J7 j$ y
}
- V- Z7 H0 b& Q3 D' f* a2 I+ o
pMessage(L"\r\n"); k+=2;6 ^6 `+ h( }4 C- O' U- x
a.BType=luStaData_int64; a.VType=luStaData_int64; a.x=k; //按函数o的要求，返回输出的字符总数) y2 V# Z% X. \) f$ l0 J! R
break;
; m* k! q# Y0 I' x7 U( p
default:
. h; V+ m' Z9 w
break;2 W1 b! y+ y2 _0 b* \
}! {\\" c4 t; E1 z& {9 s
return a;0 L. g8 L3 n3 i. }6 g
}
) e+ T$ _5 p\\" b$ Q! o1 f\\" k
void main(void), G4 c' T/ P4 w! L/ e
{
3 x2 A& q) N. W( [! b4 G
void *hFor; //表达式句柄6 v4 @) O6 H4 q; i5 U' [
luINT nPara; //存放表达式的自变量个数
+ @6 @% @ K& a
LuData *pPara; //存放输入自变量的数组指针
) f/ @; d# ^+ B
luINT ErrBegin,ErrEnd; //表达式编译出错的初始位置和结束位置 i& e( _$ y! e5 j, o3 g$ F& S
int ErrCode; //错误代码7 l+ T& D$ y; t# i+ ^( u
void *v;0 v) s5 I9 A0 p' ^
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.]}";//字符串表达式，矩阵乘
8 f/ k* A& |8 W+ d4 r! f
//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.]}";//字符串表达式，矩阵点乘
8 _( S. V- \( X. Z1 c- M: m d$ j
LuData Val;
* j9 {# G0 @9 g\\" a9 B
if(!InitLu()) return; //初始化Lu
% b6 ~4 `4 p0 X C5 f; W& y; M
while(LockKey(Matrix,DelMatrix,OpMatrix)){Matrix++;} //锁定一个键，用于存储矩阵扩展类型
: m0 S* n; }8 y& z8 E, Q2 }$ P
0 b$ `( C+ S% r% T9 m+ ?. Y, A: x
Val.BType=luStaData_int64; Val.VType=luStaData_int64; Val.x=Matrix; //定义整数常量/ L- B# Y, T1 n
SetConst(L"matrix",&Val); //设置整数常量
; _; O) q! L* \/ m9 }6 Y, U* j
InsertKey("\0\0\0\0",4,luPubKey_User,LuMessage,NULL,NULL,1,v); //使Lu运行时可输出函数信息5 p/ [\\" _9 e9 y5 o0 t. T
wcout.imbue(locale("chs")); //设置输出的locale为中文 z- v+ y. \\\" C
( ^# @# B0 o& x$ P- l5 [8 D
ErrCode=LuCom(ForStr,0,0,0,hFor,nPara,pPara,ErrBegin,ErrEnd); //编译表达式' c1 h6 c0 Y' [% _5 t
if(ErrCode)
. U- \. p4 `3 f4 v: C9 a
{
! z x, }! ?' o, d `+ t3 p
wcout<<L"表达式有错误！错误代码："<<ErrCode<<endl;
. v% X. q S B& K$ G9 v
}7 D, N4 I* _+ i& R1 L) O0 [
else
h' x y; X, _5 L5 T& w
{
% I( o% M7 i! u3 Q6 C
LuCal(hFor,pPara); //计算表达式的值* ?' T+ |( G3 m2 l
}$ }- s5 x& C: V0 a/ n' v$ m
LockKey(Matrix,NULL,OpMatrix);//解锁键Matrix，本例中，该函数可以不用5 u, a2 L3 @0 s4 l$ i- h2 T; N+ ]
FreeLu(); //释放Lu
- W, ~% j. ~2 D9 [5 [( [
}

#include <windows.h> 
  N* v, U3 E' {. h  M! m+ g% h- l+ B, i
#include <iostream> 
/ E# ^2 l; ^: a% u) p7 K
#include <math.h>0 o  N' s: e8 Q+ H

#include "lu32.h" 
' }$ H, X* j5 _2 }( p8 w
 
- n8 c! t) L- F
#pragma comment( lib, "lu32.lib" ) 
3 @$ B5 ~  ?# d9 x# v# T/ M/ F% i8 k
 
( L/ K* _' f# V. f
using namespace std;/ X0 A$ o4 Y# v6 e- @' W

\\" w: F# Z4 A# b  E6 Q
luKEY Matrix=-1000;        //标识矩阵类型，最终的Matrix由LockKey决定 
! [& Z6 E- v2 ?- P  h
) x2 g* T. K  e7 p3 M1 V+ c

void _stdcall LuMessage(wchar_t *pch)//输出动态库信息，该函数注册到Lu，由Lu二级函数调用 
8 _4 ~- k. O; L4 ~8 y) @7 T4 d. ~
{ 
4 T# Z2 |  e% F! ^
        wcout<<pch;' r+ L  W$ G  q; r

} 
% @\\" t4 U4 V1 v( |5 x/ @: m$ l0 p\\" M
void _stdcall DelMatrix(void *me)        //用于LockKey函数，因为是基于系统内置实数数组创建矩阵，故该函数什么也不做$ B9 C6 D! Q$ m6 {' f( r

{+ j0 e/ n# q! d8 D+ M0 R

}\\" N\\" u$ k5 _1 }( k

LuData _stdcall OpMatrix(luINT mm,LuData *xx,void *hFor,int theOperator)        //运算符重载函数，用于LockKey函数 
/ e1 t1 W# ?/ A9 v3 V
{  D8 t. H1 T1 J, l, B

LuData a;4 E& c! W, z, u/ p: k* z8 Q

luRealArray *pRealArray1,*pRealArray2,*pRealArray3;/ |3 {2 K) ?: L  }\\" e

luVOID i,j,k,m,n,u,v; 
& ]' K# I5 q4 j8 b: a6 t2 i) S
        double *pa,*pb,*pc;' Q\\" `+ Z1 x! t# s

luMessage pMessage; 
: s& V! I( w\\" a$ [
        wchar_t wchNum[32]; 
- |1 {5 U) b% N; S. j0 k
        char chNum[32];  u( X  [1 Z) e; p2 M

a.BType=luStaData_nil; a.VType=luStaData_nil; a.x=0;/ \7 W- `1 `' a

switch(theOperator); `3 x) Y3 f/ I/ ^; q8 I

{ 
( ?8 |+ K4 e! y
        case 2:        //重载运算符*# O' p) R' x  n4 R: V& Z

pRealArray1=(luRealArray *)SearchKey((char *)&(xx->x),sizeof(luVOID),luDynData_realarray); 
, s+ h6 D\\" C( R7 Q; t
                pRealArray2=(luRealArray *)SearchKey((char *)&((xx+1)->x),sizeof(luVOID),luDynData_realarray);4 P0 _! d5 ?+ u1 I! Y) J3 o- t  f

if(!pRealArray1 || !pRealArray2) break;        //对象句柄无效，不是实数数组 
0 z# Z' r: s7 ~0 c7 y. q
                if(pRealArray1->DimLen!=2 || pRealArray2->DimLen!=2) break;        //不是二维实数数组（矩阵）7 H5 D$ C' {: I1 z: k( e2 N

if(pRealArray1->Dim[1]!=pRealArray2->Dim[0]) break;        //维数不匹配\\" U8 K, P5 e4 b, P

pRealArray3=(luRealArray *)NewSysObj(luDynData_realarray,pRealArray1->Dim[0]*pRealArray2->Dim[1],2);        //创建矩阵对象: O$ E1 G! p6 `4 }1 N% _/ `

if(!pRealArray3) break;+ l( Y$ \- \# g; H# b' n( w4 o3 ?

pRealArray3->Dim[0]=pRealArray1->Dim[0]; pRealArray3->Dim[1]=pRealArray2->Dim[1];        //设置矩阵维数大小 
: b3 {7 V9 n# F\\" B
                pa=pRealArray1->Array; pb=pRealArray2->Array; pc=pRealArray3->Array; 
# L: D1 {7 M7 ~/ B' t
                m=pRealArray1->Dim[0]; n=pRealArray1->Dim[1]; k=pRealArray2->Dim[1]; 
- ^8 J$ H4 c$ j6 N
                for(i=0; i<m; i++)        //矩阵乘 
\\" e$ u6 j. J& G) O\\" c5 E; r\\" {  y
                { 
* m$ H) g3 W% i! k7 K- h
                        for(j=0; j<k; j++) 
3 P) \) p: |* r
                        {) A6 n' {  `& ]+ M3 h. ?

u=i*k+j; pc[u]=0.0; 
7 i3 {+ V* j. g1 l
                                for (v=0; v<n; v++)+ ?' |. _6 U, w  j+ D

{ 
0 k! \* U% r, y\\" u/ F/ `+ m& _
                                        pc[u]=pc[u]+pa[i*n+v]*pb[v*k+j]; 
\\" b) \- ^2 v( B0 l! `
                                } 
1 ?5 K% W: J+ _# Z; Q\\" E. ~8 g
                        }! p7 B2 Y+ |6 ]\\" \$ _

}4 Z/ z  f+ a1 ?6 V& W  }

FunReObj(hFor);        //告诉Lu，返回一个动态对象 
4 Q\\" n0 {$ O& |1 V* ?
                a.BType=luDynData_realarray; a.VType=Matrix; a.x=0; *(luVOID *)&(a.x)=(luVOID)pRealArray3; 
- D6 k% m& n8 H; D4 T8 B
                break; 
4 R4 E- w% ~& e. G4 k
        case 25:        //重载运算符.* 
6 S& H) f( d) S6 j
                pRealArray1=(luRealArray *)SearchKey((char *)&(xx->x),sizeof(luVOID),luDynData_realarray); 
7 Z- n8 U; `* [9 T. G+ I- ^( u% K
                pRealArray2=(luRealArray *)SearchKey((char *)&((xx+1)->x),sizeof(luVOID),luDynData_realarray);5 {3 T/ z+ G# r) [/ _1 l

if(!pRealArray1 || !pRealArray2) break;        //对象句柄无效，不是实数数组) ?8 V1 _. y, H; f

if(pRealArray1->DimLen!=2 || pRealArray2->DimLen!=2) break;        //不是二维实数数组（矩阵） 
# C- c: @& n( ?, y& ]( i% O8 l\\" t
                if(pRealArray1->Dim[0]!=pRealArray2->Dim[0] || pRealArray1->Dim[1]!=pRealArray2->Dim[1]) break;        //维数不相同 
6 y7 `4 {* z4 {: W
                pRealArray3=(luRealArray *)NewSysObj(luDynData_realarray,pRealArray1->ArrayLen,2);        //创建矩阵对象 
: g) W\\" f0 m\\" o3 r, s! S
                if(!pRealArray3) break;8 D6 i9 e* u8 l! B

pRealArray3->Dim[0]=pRealArray1->Dim[0]; pRealArray3->Dim[1]=pRealArray1->Dim[1];        //设置矩阵维数大小3 U  d. c: u7 S- p

for(i=0;i<pRealArray1->ArrayLen;i++) pRealArray3->Array[i]=pRealArray1->Array[i]*pRealArray2->Array[i];//矩阵点乘 
; W\\" ?9 [8 t: `9 G8 Y4 U
                FunReObj(hFor);        //告诉Lu，返回一个动态对象 
! ]8 _& R& Y5 d- x9 r, T# a/ E
                a.BType=luDynData_realarray; a.VType=Matrix; a.x=0; *(luVOID *)&(a.x)=(luVOID)pRealArray3;$ D  ^, B- Z2 N! P

break;\\" {+ `6 B/ i4 _. y7 h2 Q) n

case 46:        //重载函数new 
4 w4 |3 D5 j! W8 P8 L6 i: F: Z\\" d
                a=ExeOperator(mm,xx,hFor,theOperator,luDynData_realarray);        //直接调用基本类型luDynData_realarray的new函数 
3 c; X+ V  o: P+ a+ C& F
                if(a.VType==luDynData_realarray) a.VType=Matrix;        //设置扩展类型为自定义的Matrix类型 
\\" h( O0 i- l1 [4 V. E9 A5 O! i' A8 f\\" r
                break;; F+ k9 w9 `' \1 @

case 49:        //重载函数o  \0 C7 r3 O$ G& F) ?6 ?

pMessage=(luMessage)SearchKey("\0\0\0\0",sizeof(luVOID),luPubKey_User); 
& C8 l& \9 y) V! Y2 C7 G+ A7 S
                if(!pMessage) break;. q! S$ ?9 G  l% `- [

pRealArray1=(luRealArray *)SearchKey((char *)&(xx->x),sizeof(luVOID),luDynData_realarray); 
! M  s3 `/ b  n/ L- r- ]
                if(!pRealArray1) break;        //对象句柄无效，不是实数数组- e2 M6 H% Z8 D8 M8 D6 B1 \

if(pRealArray1->DimLen!=2) break;        //不是二维实数数组（矩阵）4 U+ }& q9 Z9 \; j

pa=pRealArray1->Array; 
5 T* j/ A* O6 N  u$ d
                m=pRealArray1->Dim[0]; n=pRealArray1->Dim[1]; k=0;! a$ \  ?& [+ V8 Q. o6 b

for(i=0; i<m; i++)        //输出矩阵 
. D2 x' }# g\\" F9 @6 o
                { 
+ C( `; M: x( g9 R; d( I: }' m7 `
                        pMessage(L"\r\n"); k+=2; 
% U\\" b% E/ Y$ Q7 G. u4 d- u, D' F3 M! ]3 v
                        for(j=0; j<n; j++)+ K2 i* ]  _0 T0 n' A

{& ^$ \2 b# U% l1 p1 q. {

_gcvt_s(chNum,pa[i*n+j],16);\\" h/ R/ S+ O2 l7 t1 ?2 I: O/ s/ d3 H0 {

for(u=0;chNum[u];u++) {wchNum[u]=chNum[u]; k++;}! s1 p7 @\\" \( w! r

wchNum[u]='\0';. K6 q  i0 A7 h6 H

pMessage(wchNum); pMessage(L"  "); k+=2; 
  d% P9 C\\" v1 @
                        } 
7 ?! q2 t) l8 l  x7 J7 j$ y
                } 
- V- Z7 H0 b& Q3 D' f* a2 I+ o
                pMessage(L"\r\n"); k+=2;6 ^6 `+ h( }4 C- O' U- x

a.BType=luStaData_int64; a.VType=luStaData_int64; a.x=k;        //按函数o的要求，返回输出的字符总数) y2 V# Z% X. \) f$ l0 J! R

break; 
; m* k! q# Y0 I' x7 U( p
        default: 
. h; V+ m' Z9 w
                break;2 W1 b! y+ y2 _0 b* \

}! {\\" c4 t; E1 z& {9 s

return a;0 L. g8 L3 n3 i. }6 g

} 
) e+ T$ _5 p\\" b$ Q! o1 f\\" k
void main(void), G4 c' T/ P4 w! L/ e

{ 
3 x2 A& q) N. W( [! b4 G
        void *hFor;                //表达式句柄6 v4 @) O6 H4 q; i5 U' [

luINT nPara;                //存放表达式的自变量个数 
+ @6 @% @  K& a
        LuData *pPara;                //存放输入自变量的数组指针 
) f/ @; d# ^+ B
        luINT ErrBegin,ErrEnd;        //表达式编译出错的初始位置和结束位置  i& e( _$ y! e5 j, o3 g$ F& S

int ErrCode;                //错误代码7 l+ T& D$ y; t# i+ ^( u

void *v;0 v) s5 I9 A0 p' ^

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.]}";//字符串表达式，矩阵乘 
8 f/ k* A& |8 W+ d4 r! f
        //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.]}";//字符串表达式，矩阵点乘 
8 _( S. V- \( X. Z1 c- M: m  d$ j
        LuData Val; 
* j9 {# G0 @9 g\\" a9 B
        if(!InitLu()) return;        //初始化Lu 
% b6 ~4 `4 p0 X  C5 f; W& y; M
        while(LockKey(Matrix,DelMatrix,OpMatrix)){Matrix++;}        //锁定一个键，用于存储矩阵扩展类型 
: m0 S* n; }8 y& z8 E, Q2 }$ P
0 b$ `( C+ S% r% T9 m+ ?. Y, A: x

Val.BType=luStaData_int64; Val.VType=luStaData_int64; Val.x=Matrix;        //定义整数常量/ L- B# Y, T1 n

SetConst(L"matrix",&Val);        //设置整数常量 
; _; O) q! L* \/ m9 }6 Y, U* j
        InsertKey("\0\0\0\0",4,luPubKey_User,LuMessage,NULL,NULL,1,v); //使Lu运行时可输出函数信息5 p/ [\\" _9 e9 y5 o0 t. T

wcout.imbue(locale("chs"));        //设置输出的locale为中文  z- v+ y. \\\" C

( ^# @# B0 o& x$ P- l5 [8 D

ErrCode=LuCom(ForStr,0,0,0,hFor,nPara,pPara,ErrBegin,ErrEnd); //编译表达式' c1 h6 c0 Y' [% _5 t

if(ErrCode) 
. U- \. p4 `3 f4 v: C9 a
        { 
! z  x, }! ?' o, d  `+ t3 p
                wcout<<L"表达式有错误！错误代码："<<ErrCode<<endl; 
. v% X. q  S  B& K$ G9 v
        }7 D, N4 I* _+ i& R1 L) O0 [

else 
  h' x  y; X, _5 L5 T& w
        { 
% I( o% M7 i! u3 Q6 C
                LuCal(hFor,pPara);        //计算表达式的值* ?' T+ |( G3 m2 l

}$ }- s5 x& C: V0 a/ n' v$ m

LockKey(Matrix,NULL,OpMatrix);//解锁键Matrix，本例中，该函数可以不用5 u, a2 L3 @0 s4 l$ i- h2 T; N+ ]

FreeLu();                        //释放Lu 
- W, ~% j. ~2 D9 [5 [( [
}

习题：

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

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

main(:a,b,c,d,t,i)=
0 T# u! H+ b! w3 h
a=new[matrix,2,2,data:1.,2.,2.,1.],\" q1 V) x' _7 d- Y! O
b=new[matrix,2,2,data:2.,1.,1.,2.],
) ^; S, B, u# s+ Y# Q! z
c=new[matrix,2,2,data:2/3.,-1/3.,-1/3.,2/3.],
/ n\" T! B3 ]$ ^9 ^5 M
t=clock(),* Y0 V! s- S8 e$ S) U
d=a*b, i=0, while{i<1000000, d=d*c*b, i++},
& ^) g# f, y# h/ D( |( L
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\"}";//字符串表达式

复制代码

结果：