数学建模社区-数学中国»论坛 › 【编程区】语言讨论 › Forcal程序设计 › 在Lu中创建自定义数据类型，小矩阵乘效率测试

查看: 8461|回复: 0

在Lu中创建自定义数据类型，小矩阵乘效率测试

[复制链接]

字体大小: 正常放大

forcal

45 主题	3 听众	282 积分

升级 91%

TA的每日心情

	难过 2012-8-27 18:22

签到天数: 1 天

[LV.1]初来乍到

电梯直达

发表于 2011-10-24 18:54 |只看该作者 |正序浏览

|招呼Ta 关注Ta

本例中，我们将自定义矩阵（matrix）类型，基本类型和扩展类型均为matrix（标识矩阵）。

基本要点：

（1）编写生成矩阵（matrix）的函数NewMatrix和销毁矩阵的函数DelMatrix。

（2）为自定义类型matrix编写运算符重载函数OpMatrix。

（3）用函数LockKey将重载函数OpMatrix注册到Lu，锁定的键的类型即为matrix，要注册为常量，以便于使用。

（4）为自定义类型matrix编写其他操作函数（本例未提供）。

（5）用函数LockKey解锁键matrix（本例中，程序退出时会自动解锁，故可以不用）。

#include <windows.h>
9 E' D+ b9 b7 K( k2 J# m$ N\\" _+ g
#include <iostream>
' l. ?+ ~! n! u, u, @
#include <math.h>6 U, U! Q) X5 B6 Q7 p2 C8 Q8 K7 R
#include "lu32.h"8 Q/ }3 V\\" \0 D* i3 ^- V2 O% M$ y
#pragma comment( lib, "lu32.lib" )
$ v; T- ?# U+ j+ m. T) K1 _& R3 y( {
using namespace std;
+ ?) F& G4 _- w, O/ N1 ^6 ~6 L' y# O
//自定义矩阵
V\\" _+ T$ I2 X' t: H! ?
class myMatrix
\\" N- }! u$ v* n% \
{2 O7 v( `7 Z; G# k6 }: m, `9 W
public:' w7 g5 W4 @9 j% O; t
double *Array; //数据缓冲区
9 r3 p! X# A& i; g' M9 s
luVOID ArrayLen; //数据缓冲区长度
( b1 L8 P F3 M. W
luVOID Dim[2]; //矩阵维数4 i3 u- W8 n5 L4 D; i& X
myMatrix(){Array=NULL; ArrayLen=0; Dim[0]=0; Dim[1]=0;}# X4 q) m; J4 v+ \
~myMatrix()! t& o\\" |7 u0 R8 r) E
{# s: N3 W5 N+ M' e
if(Array) delete[] Array;5 Q3 K' @\\" ]; q, C# E; [
}. Q8 @3 \( s5 B7 d/ Y
}; o# y, e. ~: G4 f5 @9 ~
luKEY Matrix=-1000; //标识矩阵类型，最终的Matrix由LockKey决定
, P) \6 r9 H. [* c0 I
void _stdcall LuMessage(wchar_t *pch)//输出动态库信息，该函数注册到Lu，由Lu二级函数调用
\\" ~0 R/ W y\\" g2 u: ]3 ~+ }- z
{+ p8 q- M' |' U- Q
wcout<<pch;
4 c0 B! r- G) r5 O1 q
}. W6 {3 |) `2 R* y1 O
void _stdcall DelMatrix(void *me) //用于LockKey函数及InsertKey函数，使Lu能自动销毁myMatrix对象
4 {' E( t4 y0 c( ^: @2 q: s1 D
{
4 N% L/ q, y; v ^9 F
delete (myMatrix *)me;
4 W& }' Z3 q0 @2 d1 ]0 {( q
}
2 V5 a7 I& ?' m* x) c0 O1 ^
myMatrix * _stdcall NewMatrix(luVOID m,luVOID n) //生成一个myMatrix对象
/ y. C$ T) \# c& S$ d$ L
{
- d5 ]0 K9 p9 |; W- j5 [
myMatrix *pMatrix;
: G5 }3 p3 Y8 a
luVOID k;0 @& C2 m0 d4 J) f3 E$ A
double *pa;+ }4 _. A, n5 z; U
char keyname[sizeof(luVOID)];2 V, [* [; l! [\\" ?* M2 v
void *NowKey;
' Y1 A4 x+ D+ q# Z2 N/ B6 @
k=m*n;. c6 B) n2 |7 B! U' j- P
pMatrix=(myMatrix *)GetBufObj(Matrix,keyname);//先尝试从缓冲区中获取一个矩阵对象8 E9 U- Y+ ^% D. ^
if(pMatrix)
% T% w3 D2 r% k8 `, ] D\\" P4 }
{
/ G# g+ Z+ a @3 _1 o8 j, ~
if(pMatrix->ArrayLen!=k) //重置矩阵的大小; o- y, `7 _- c! Q7 L! D% q
{
4 \9 W7 C. G/ w7 [# C$ Q, T+ O% }
pa=new double[k];
: k& S/ z A+ G$ k! N1 k
if(!pa)
2 G& s! S5 u% t; ]( R; T* a
{6 O3 N; i$ b: L$ q
DeleteKey(keyname,sizeof(luVOID),Matrix,DelMatrix,1); //将矩阵对象放回缓冲区4 ^+ M# P) o$ O! f
return NULL;2 B' b\\" j7 b- }4 m. x7 Y
}, N* _( H+ d2 ^ @4 L
delete[] pMatrix->Array;
3 u1 g\\" A: P$ ]
pMatrix->Array=pa;9 t: b\\" u' e+ U
}8 ~& z* B; X0 `\\" L4 g' m
}
4 @, a$ Z& M5 H8 h, k& U
else0 t\\" y# B/ x( e: K6 w+ d4 M, L
{$ s7 u: @6 z! s' B3 ?. p. P
pMatrix=new myMatrix; //创建矩阵对象
0 p+ a0 p2 f, V# G3 S& ?) ^
if(!pMatrix) return NULL;: o\\" U\\" ^/ s. B
pMatrix->Array=new double[k];
8 z5 x! M1 E! A0 T& T
if(!pMatrix->Array)+ z) d5 u5 l\\" R
{
8 p& u I' T* O- k1 l
delete pMatrix;
9 ~9 Y2 {6 N1 |( T
return NULL;5 X* W$ d) f Z% E! I. T+ J
}
) ]4 D) K9 L4 v) {7 A
if(InsertKey((char *)&pMatrix,-1,Matrix,pMatrix,DelMatrix,NULL,0,NowKey)) //将矩阵对象注册到Lu# {, {7 t( e! v- `1 ^0 @
{# f& v$ K: S/ S+ @3 Q
delete pMatrix;
6 S. _5 c9 N7 B$ Q: m( B; p6 Q
return NULL;. ~\\" f% s1 W$ ?
}
- I7 P! @' _ a; J& Z
}4 \& q& h p% U T; L
pMatrix->ArrayLen=k; pMatrix->Dim[0]=m; pMatrix->Dim[1]=n;
; J' v }2 z3 q
return pMatrix;7 F: t- P0 Z- G
}\\" B; _0 |. }8 f9 _ ]' c5 O% H
LuData _stdcall OpMatrix(luINT mm,LuData *xx,void *hFor,int theOperator) //运算符重载函数，用于LockKey函数4 _8 F% Q* J+ }; T3 V: ?
{3 O4 {3 |! l: E2 z% b D0 A6 H+ I
LuData a;
O R- p7 X. s! a
myMatrix *pMatrix1,*pMatrix2,*pMatrix3;
! d7 }3 M0 l& K8 z
luVOID i,j,k,m,n,u,v;9 t3 i/ o+ [5 u, `\\" Z2 b+ b
double *pa,*pb,*pc;7 z* F0 @\\" C$ b+ a
luMessage pMessage;
: K1 g$ }2 `' h0 |3 x$ k
wchar_t wchNum[32];9 o8 r: o4 f\\" m9 O
char chNum[32];
( q) k: n0 R+ x) K6 }% ^# D
a.BType=luStaData_nil; a.VType=luStaData_nil; a.x=0;4 d1 e/ Z$ ^) T; _! f+ {: X- C
switch(theOperator)
f8 P, s( k6 Y
{3 A5 b5 V) z/ @! I
case 2: //重载运算符*/ b1 h) `0 r) u! f! X) ^% r8 w8 ?
pMatrix1=(myMatrix *)SearchKey((char *)&(xx->x),sizeof(luVOID),Matrix);$ t6 l5 n) \' f, c0 l
pMatrix2=(myMatrix *)SearchKey((char *)&((xx+1)->x),sizeof(luVOID),Matrix);
; } i1 @ R5 y
if(!pMatrix1 || !pMatrix2) break; //对象句柄无效，不是矩阵, y, y6 W( M- P
if(pMatrix1->Dim[1]!=pMatrix2->Dim[0]) break; //维数不匹配
\\" {; v! c! J. v
pMatrix3=NewMatrix(pMatrix1->Dim[0],pMatrix2->Dim[1]); //生成新矩阵\\" i5 h8 c8 V r; B& ?
if(!pMatrix3) break;1 H5 E3 ?) B, N$ T* p2 j
pa=pMatrix1->Array; pb=pMatrix2->Array; pc=pMatrix3->Array;
7 z. F% ~# D5 B' v$ o- A
m=pMatrix1->Dim[0]; n=pMatrix1->Dim[1]; k=pMatrix2->Dim[1];2 R; W3 s2 q6 G! E
for(i=0; i<m; i++) //矩阵乘
' g$ G* I1 `4 q
{+ z: c L( B8 i- d2 ~
for(j=0; j<k; j++)# I/ h4 L\\" a+ f) O8 I @
{! ~. ?' ^; e* ?# M# |! ]
u=i*k+j; pc[u]=0.0;) ~% S1 J2 {! B8 t9 S4 A, l
for (v=0; v<n; v++)) P q8 S# A' ^7 x- S7 p$ G- k\\" F% E
{
( }# `4 H' _- |6 G8 Z
pc[u]=pc[u]+pa[i*n+v]*pb[v*k+j];
Z) E( c5 H) F/ K
}\\" F6 U0 g% [: Y/ J, A7 J- T7 p& ^3 g8 h
}+ [/ D) c+ Z# ]4 ~
}
/ o1 B$ W0 G7 P, ]/ Z/ G3 V
FunReObj(hFor); //告诉Lu，返回一个动态对象
% J+ y1 L$ ` g$ |7 N7 a
a.BType=Matrix; a.VType=Matrix; a.x=0; *(luVOID *)&(a.x)=(luVOID)pMatrix3;! h @ X' \' R8 h3 q; ~ a
break;
6 ^; {* ]; R/ }3 Q1 D( I! V6 ^. S& t% {
case 25: //重载运算符.*4 l2 [% K, v3 W# p& R7 h
pMatrix1=(myMatrix *)SearchKey((char *)&(xx->x),sizeof(luVOID),Matrix);\\" Q4 Q0 z3 O4 r1 c: |
pMatrix2=(myMatrix *)SearchKey((char *)&((xx+1)->x),sizeof(luVOID),Matrix);
5 @6 z. L2 z' u0 |- _
if(!pMatrix1 || !pMatrix2) break; //对象句柄无效，不是矩阵
?. ^: i4 j5 @' t3 u3 w @
if(pMatrix1->Dim[0]!=pMatrix2->Dim[0] || pMatrix1->Dim[1]!=pMatrix2->Dim[1]) break; //维数不相同
+ _9 G% A+ d8 [9 j* J, Z( z6 j- M$ m
pMatrix3=NewMatrix(pMatrix1->Dim[0],pMatrix1->Dim[1]); //生成新矩阵! Q' |# g6 `; t) J$ R8 m
if(!pMatrix3) break;' b5 `: X, h% {\\" Y* u& q$ c! r
for(i=0;i<pMatrix1->ArrayLen;i++) pMatrix3->Array[i]=pMatrix1->Array[i]*pMatrix2->Array[i]; //矩阵点乘
* {' d3 g& g D( _ @2 J
FunReObj(hFor); //告诉Lu，返回一个动态对象) d2 N( _. E6 X6 N2 T
a.BType=Matrix; a.VType=Matrix; a.x=0; *(luVOID *)&(a.x)=(luVOID)pMatrix3;
+ D/ L# i8 N9 c2 E# Y2 d
break;$ o1 O0 y p6 r! C# j
case 46: //重载函数new, X& C% a \1 f1 G( {7 _
if(mm<2) break;% I: t1 ^6 t5 N; y/ T y
if((xx+1)->x<1 || (xx+2)->x<1 || (xx+1)->BType!=luStaData_int64 || (xx+2)->BType!=luStaData_int64) break;6 i L. o. o6 L& @) d
pMatrix3=NewMatrix((luVOID)(xx+1)->x,(luVOID)(xx+2)->x);//生成新矩阵6 Z/ l, D4 K% g1 {6 n
if(!pMatrix3) break;
& Z& ~6 V9 d# k9 C: o
for(j=0,i=3;i<=mm;i++,j++) //赋初值* [9 {; {8 N! T- n4 T$ k8 i
{
8 N1 l1 B1 d! ^0 @+ K s
if(j>=pMatrix3->ArrayLen) break;
0 l6 H. ?1 w: x C! {% A2 `5 k; W
if((xx+i)->BType!=luStaData_double) break; //只接受实数参数9 s; \* Y q8 c8 C4 W2 o8 i2 K9 Z
pMatrix3->Array[j]=*(double *)&((xx+i)->x);
- h2 Z\\" L( H3 Z; e) v7 c3 E
}- n' X Y' O: \* _ d' A8 J
FunReObj(hFor); //告诉Lu，返回一个动态对象
3 U6 o9 N8 R4 F$ B. Z\\" [! {6 O
a.BType=Matrix; a.VType=Matrix; a.x=0; *(luVOID *)&(a.x)=(luVOID)pMatrix3; F# e# ^- B\\" Z) g* b
break;
+ ^+ y0 @4 q8 Z3 P9 Q# l
case 49: //重载函数o: O& I: j4 R4 l* t* t% y
pMessage=(luMessage)SearchKey("\0\0\0\0",sizeof(luVOID),luPubKey_User);, r, M% a6 {( q
if(!pMessage) break;
+ j4 h# r% `+ L% l! C' J$ l! I
pMatrix1=(myMatrix *)SearchKey((char *)&(xx->x),sizeof(luVOID),Matrix);. V c9 j; l2 }3 @. }3 }* Q
if(!pMatrix1) break; //对象句柄无效，不是矩阵
! x; |& j# N A+ ~$ M6 g
pa=pMatrix1->Array;
; k7 w7 C r! i( o# M
m=pMatrix1->Dim[0]; n=pMatrix1->Dim[1]; k=0;
1 B4 ` \' i% E* O
for(i=0; i<m; i++) //输出矩阵
9 p\\" n7 Q/ \4 h% _
{& \5 ~; g/ o% R! C3 W
pMessage(L"\r\n"); k+=2;
8 n0 H- V( z- y4 A. I% Z
for(j=0; j<n; j++)# t A& ]1 X, g% ^6 R
{
5 j+ S+ R( [9 ^( {
_gcvt_s(chNum,pa[i*n+j],16);/ v! C2 ~4 i/ B z+ {
for(u=0;chNum[u];u++) {wchNum[u]=chNum[u]; k++;}+ w$ m# v; Y4 P+ z( h$ e$ v
wchNum[u]='\0';
: e# W$ Q! M7 H0 u- H\\" r8 ]
pMessage(wchNum); pMessage(L" "); k+=2;
% O* f3 t6 ]) Y) e/ a l
}
/ Q' G' j; I1 p6 u& }, k- {
}& P7 r! c4 V1 ^
pMessage(L"\r\n"); k+=2;
5 x$ u! @& k7 Y2 S. F6 c( M# E2 w
a.BType=luStaData_int64; a.VType=luStaData_int64; a.x=k; //按函数o的要求，返回输出的字符总数, l, r\\" [# d5 D9 S
break;
. a% c& z$ a1 `0 ~* n' R9 @- F
default:% @7 k: Y8 ~. r: j% {( D7 g, P3 m
break;
) t0 Q$ x8 C; J% j0 o0 h
}
/ Q& N3 x5 |) S; m% `$ k- K
return a;
3 F/ o' U8 ]2 B' J\\" j
}
\\" a# @, G! X1 C: _0 a. x8 ]
void main(void)
/ f- a- G. ~* i( R% u
{
0 Y; I- I. ^4 L R
void *hFor; //表达式句柄
4 j2 W5 F# n Y0 K d
luINT nPara; //存放表达式的自变量个数: f( z3 |6 @% B4 j7 A& P3 [( n
LuData *pPara; //存放输入自变量的数组指针0 [$ O- D4 l* a
luINT ErrBegin,ErrEnd; //表达式编译出错的初始位置和结束位置\\" i9 F& r; j9 U- a, Y\\" J
int ErrCode; //错误代码
4 p& u8 h; E( ?0 q4 h( D
void *v;. M% x1 d7 U( S4 e: {
wchar_t ForStr[]=L"o{new[matrix,2,3: 0.,1.,2.;3.,4.,5.]*new[matrix,3,2: 1.,2.;3.,4.;5.,6.]}";//字符串表达式，矩阵乘
5 ~4 L$ | D7 d2 G% E, [
//wchar_t ForStr[]=L"o{new[matrix,2,3: 0.,1.,2.;3.,4.,5.].*new[matrix,2,3: 1.,2.,3.;4.,5.,6.]}";//字符串表达式，矩阵点乘' a; K' O+ R2 s
LuData Val;
4 O: ^8 w, a) n D1 U L
if(!InitLu()) return; //初始化Lu\\" ]4 K7 d$ d- V) R% F3 f W9 G
while(LockKey(Matrix,DelMatrix,OpMatrix)){Matrix--;} //锁定一个键，用于存储矩阵扩展类型
4 \) i6 `1 p( w1 J
4 I& b' `6 m\\" N2 W7 N$ j
Val.BType=luStaData_int64; Val.VType=luStaData_int64; Val.x=Matrix; //定义整数常量* v8 }! r, S/ Q4 L( R2 l5 D
SetConst(L"matrix",&Val); //设置整数常量8 p$ y. |6 z# I% o0 b
InsertKey("\0\0\0\0",4,luPubKey_User,LuMessage,NULL,NULL,1,v); //使Lu运行时可输出函数信息( V3 g4 n' [+ C( e0 |9 { b( W# R
wcout.imbue(locale("chs")); //设置输出的locale为中文6 k1 E9 v/ C8 D; \
7 q7 P |- t0 \
ErrCode=LuCom(ForStr,0,0,0,hFor,nPara,pPara,ErrBegin,ErrEnd); //编译表达式
8 o7 T) }5 M. z
if(ErrCode)
6 m* L# u) Q5 Q1 L+ {3 [\\" |& w$ d
{
7 V; V3 e# `7 x* f9 B, W4 n
wcout<<L"表达式有错误！错误代码："<<ErrCode<<endl;
0 T0 H, E' @9 U7 k9 W7 V; G\\" j
}9 R% q) p$ j% _\\" w7 W0 t
else7 r! T& J8 u' _\\" G6 l4 Z
{' F2 G% k) g# C8 r B3 a' ~
LuCal(hFor,pPara); //计算表达式的值
2 |4 [5 }) C6 T* U8 M! Z5 y* u
}5 o {. W: O, ]0 ?1 q2 _
LockKey(Matrix,NULL,OpMatrix);//解锁键Matrix，本例中，该函数可以不用
( Z* G: V5 W' J4 r5 F
FreeLu(); //释放Lu2 M* Y5 | `* z! R/ E# t
}

#include <windows.h> 
9 E' D+ b9 b7 K( k2 J# m$ N\\" _+ g
#include <iostream> 
' l. ?+ ~! n! u, u, @
#include <math.h>6 U, U! Q) X5 B6 Q7 p2 C8 Q8 K7 R

#include "lu32.h"8 Q/ }3 V\\" \0 D* i3 ^- V2 O% M$ y

#pragma comment( lib, "lu32.lib" ) 
$ v; T- ?# U+ j+ m. T) K1 _& R3 y( {
using namespace std; 
+ ?) F& G4 _- w, O/ N1 ^6 ~6 L' y# O
//自定义矩阵 
  V\\" _+ T$ I2 X' t: H! ?
class myMatrix 
\\" N- }! u$ v* n% \
{2 O7 v( `7 Z; G# k6 }: m, `9 W

public:' w7 g5 W4 @9 j% O; t

double *Array;        //数据缓冲区 
9 r3 p! X# A& i; g' M9 s
        luVOID ArrayLen;        //数据缓冲区长度 
( b1 L8 P  F3 M. W
        luVOID Dim[2];        //矩阵维数4 i3 u- W8 n5 L4 D; i& X

myMatrix(){Array=NULL; ArrayLen=0; Dim[0]=0; Dim[1]=0;}# X4 q) m; J4 v+ \

~myMatrix()! t& o\\" |7 u0 R8 r) E

{# s: N3 W5 N+ M' e

if(Array) delete[] Array;5 Q3 K' @\\" ]; q, C# E; [

}. Q8 @3 \( s5 B7 d/ Y

};  o# y, e. ~: G4 f5 @9 ~

luKEY Matrix=-1000;        //标识矩阵类型，最终的Matrix由LockKey决定 
, P) \6 r9 H. [* c0 I
void _stdcall LuMessage(wchar_t *pch)//输出动态库信息，该函数注册到Lu，由Lu二级函数调用 
\\" ~0 R/ W  y\\" g2 u: ]3 ~+ }- z
{+ p8 q- M' |' U- Q

wcout<<pch; 
4 c0 B! r- G) r5 O1 q
}. W6 {3 |) `2 R* y1 O

void _stdcall DelMatrix(void *me)        //用于LockKey函数及InsertKey函数，使Lu能自动销毁myMatrix对象 
4 {' E( t4 y0 c( ^: @2 q: s1 D
{ 
4 N% L/ q, y; v  ^9 F
        delete (myMatrix *)me; 
4 W& }' Z3 q0 @2 d1 ]0 {( q
} 
2 V5 a7 I& ?' m* x) c0 O1 ^
myMatrix * _stdcall NewMatrix(luVOID m,luVOID n)        //生成一个myMatrix对象 
/ y. C$ T) \# c& S$ d$ L
{ 
- d5 ]0 K9 p9 |; W- j5 [
        myMatrix *pMatrix; 
: G5 }3 p3 Y8 a
        luVOID k;0 @& C2 m0 d4 J) f3 E$ A

double *pa;+ }4 _. A, n5 z; U

char keyname[sizeof(luVOID)];2 V, [* [; l! [\\" ?* M2 v

void *NowKey; 
' Y1 A4 x+ D+ q# Z2 N/ B6 @
        k=m*n;. c6 B) n2 |7 B! U' j- P

pMatrix=(myMatrix *)GetBufObj(Matrix,keyname);//先尝试从缓冲区中获取一个矩阵对象8 E9 U- Y+ ^% D. ^

if(pMatrix) 
% T% w3 D2 r% k8 `, ]  D\\" P4 }
        { 
/ G# g+ Z+ a  @3 _1 o8 j, ~
                if(pMatrix->ArrayLen!=k)        //重置矩阵的大小; o- y, `7 _- c! Q7 L! D% q

{ 
4 \9 W7 C. G/ w7 [# C$ Q, T+ O% }
                        pa=new double[k]; 
: k& S/ z  A+ G$ k! N1 k
                        if(!pa) 
2 G& s! S5 u% t; ]( R; T* a
                        {6 O3 N; i$ b: L$ q

DeleteKey(keyname,sizeof(luVOID),Matrix,DelMatrix,1);        //将矩阵对象放回缓冲区4 ^+ M# P) o$ O! f

return NULL;2 B' b\\" j7 b- }4 m. x7 Y

}, N* _( H+ d2 ^  @4 L

delete[] pMatrix->Array; 
3 u1 g\\" A: P$ ]
                        pMatrix->Array=pa;9 t: b\\" u' e+ U

}8 ~& z* B; X0 `\\" L4 g' m

} 
4 @, a$ Z& M5 H8 h, k& U
        else0 t\\" y# B/ x( e: K6 w+ d4 M, L

{$ s7 u: @6 z! s' B3 ?. p. P

pMatrix=new myMatrix;        //创建矩阵对象 
0 p+ a0 p2 f, V# G3 S& ?) ^
                if(!pMatrix) return NULL;: o\\" U\\" ^/ s. B

pMatrix->Array=new double[k]; 
8 z5 x! M1 E! A0 T& T
                if(!pMatrix->Array)+ z) d5 u5 l\\" R

{ 
8 p& u  I' T* O- k1 l
                        delete pMatrix; 
9 ~9 Y2 {6 N1 |( T
                        return NULL;5 X* W$ d) f  Z% E! I. T+ J

} 
) ]4 D) K9 L4 v) {7 A
                if(InsertKey((char *)&pMatrix,-1,Matrix,pMatrix,DelMatrix,NULL,0,NowKey))        //将矩阵对象注册到Lu# {, {7 t( e! v- `1 ^0 @

{# f& v$ K: S/ S+ @3 Q

delete pMatrix; 
6 S. _5 c9 N7 B$ Q: m( B; p6 Q
                        return NULL;. ~\\" f% s1 W$ ?

} 
- I7 P! @' _  a; J& Z
        }4 \& q& h  p% U  T; L

pMatrix->ArrayLen=k; pMatrix->Dim[0]=m; pMatrix->Dim[1]=n; 
; J' v  }2 z3 q
        return pMatrix;7 F: t- P0 Z- G

}\\" B; _0 |. }8 f9 _  ]' c5 O% H

LuData _stdcall OpMatrix(luINT mm,LuData *xx,void *hFor,int theOperator)        //运算符重载函数，用于LockKey函数4 _8 F% Q* J+ }; T3 V: ?

{3 O4 {3 |! l: E2 z% b  D0 A6 H+ I

LuData a; 
  O  R- p7 X. s! a
        myMatrix *pMatrix1,*pMatrix2,*pMatrix3; 
! d7 }3 M0 l& K8 z
        luVOID i,j,k,m,n,u,v;9 t3 i/ o+ [5 u, `\\" Z2 b+ b

double *pa,*pb,*pc;7 z* F0 @\\" C$ b+ a

luMessage pMessage; 
: K1 g$ }2 `' h0 |3 x$ k
        wchar_t wchNum[32];9 o8 r: o4 f\\" m9 O

char chNum[32]; 
( q) k: n0 R+ x) K6 }% ^# D
        a.BType=luStaData_nil; a.VType=luStaData_nil; a.x=0;4 d1 e/ Z$ ^) T; _! f+ {: X- C

switch(theOperator) 
  f8 P, s( k6 Y
        {3 A5 b5 V) z/ @! I

case 2:        //重载运算符*/ b1 h) `0 r) u! f! X) ^% r8 w8 ?

pMatrix1=(myMatrix *)SearchKey((char *)&(xx->x),sizeof(luVOID),Matrix);$ t6 l5 n) \' f, c0 l

pMatrix2=(myMatrix *)SearchKey((char *)&((xx+1)->x),sizeof(luVOID),Matrix); 
; }  i1 @  R5 y
                if(!pMatrix1 || !pMatrix2) break;        //对象句柄无效，不是矩阵, y, y6 W( M- P

if(pMatrix1->Dim[1]!=pMatrix2->Dim[0]) break;        //维数不匹配 
\\" {; v! c! J. v
                pMatrix3=NewMatrix(pMatrix1->Dim[0],pMatrix2->Dim[1]);        //生成新矩阵\\" i5 h8 c8 V  r; B& ?

if(!pMatrix3) break;1 H5 E3 ?) B, N$ T* p2 j

pa=pMatrix1->Array; pb=pMatrix2->Array; pc=pMatrix3->Array; 
7 z. F% ~# D5 B' v$ o- A
                m=pMatrix1->Dim[0]; n=pMatrix1->Dim[1]; k=pMatrix2->Dim[1];2 R; W3 s2 q6 G! E

for(i=0; i<m; i++)        //矩阵乘 
' g$ G* I1 `4 q
                {+ z: c  L( B8 i- d2 ~

for(j=0; j<k; j++)# I/ h4 L\\" a+ f) O8 I  @

{! ~. ?' ^; e* ?# M# |! ]

u=i*k+j; pc[u]=0.0;) ~% S1 J2 {! B8 t9 S4 A, l

for (v=0; v<n; v++)) P  q8 S# A' ^7 x- S7 p$ G- k\\" F% E

{ 
( }# `4 H' _- |6 G8 Z
                                        pc[u]=pc[u]+pa[i*n+v]*pb[v*k+j]; 
  Z) E( c5 H) F/ K
                                }\\" F6 U0 g% [: Y/ J, A7 J- T7 p& ^3 g8 h

}+ [/ D) c+ Z# ]4 ~

} 
/ o1 B$ W0 G7 P, ]/ Z/ G3 V
                FunReObj(hFor);        //告诉Lu，返回一个动态对象 
% J+ y1 L$ `  g$ |7 N7 a
                a.BType=Matrix; a.VType=Matrix; a.x=0; *(luVOID *)&(a.x)=(luVOID)pMatrix3;! h  @  X' \' R8 h3 q; ~  a

break; 
6 ^; {* ]; R/ }3 Q1 D( I! V6 ^. S& t% {
        case 25:        //重载运算符.*4 l2 [% K, v3 W# p& R7 h

pMatrix1=(myMatrix *)SearchKey((char *)&(xx->x),sizeof(luVOID),Matrix);\\" Q4 Q0 z3 O4 r1 c: |

pMatrix2=(myMatrix *)SearchKey((char *)&((xx+1)->x),sizeof(luVOID),Matrix); 
5 @6 z. L2 z' u0 |- _
                if(!pMatrix1 || !pMatrix2) break;        //对象句柄无效，不是矩阵 
  ?. ^: i4 j5 @' t3 u3 w  @
                if(pMatrix1->Dim[0]!=pMatrix2->Dim[0] || pMatrix1->Dim[1]!=pMatrix2->Dim[1]) break;        //维数不相同 
+ _9 G% A+ d8 [9 j* J, Z( z6 j- M$ m
                pMatrix3=NewMatrix(pMatrix1->Dim[0],pMatrix1->Dim[1]);        //生成新矩阵! Q' |# g6 `; t) J$ R8 m

if(!pMatrix3) break;' b5 `: X, h% {\\" Y* u& q$ c! r

for(i=0;i<pMatrix1->ArrayLen;i++) pMatrix3->Array[i]=pMatrix1->Array[i]*pMatrix2->Array[i];        //矩阵点乘 
* {' d3 g& g  D( _  @2 J
                FunReObj(hFor);        //告诉Lu，返回一个动态对象) d2 N( _. E6 X6 N2 T

a.BType=Matrix; a.VType=Matrix; a.x=0; *(luVOID *)&(a.x)=(luVOID)pMatrix3; 
+ D/ L# i8 N9 c2 E# Y2 d
                break;$ o1 O0 y  p6 r! C# j

case 46:        //重载函数new, X& C% a  \1 f1 G( {7 _

if(mm<2) break;% I: t1 ^6 t5 N; y/ T  y

if((xx+1)->x<1 || (xx+2)->x<1 || (xx+1)->BType!=luStaData_int64 || (xx+2)->BType!=luStaData_int64) break;6 i  L. o. o6 L& @) d

pMatrix3=NewMatrix((luVOID)(xx+1)->x,(luVOID)(xx+2)->x);//生成新矩阵6 Z/ l, D4 K% g1 {6 n

if(!pMatrix3) break; 
& Z& ~6 V9 d# k9 C: o
                for(j=0,i=3;i<=mm;i++,j++)        //赋初值* [9 {; {8 N! T- n4 T$ k8 i

{ 
8 N1 l1 B1 d! ^0 @+ K  s
                        if(j>=pMatrix3->ArrayLen) break; 
0 l6 H. ?1 w: x  C! {% A2 `5 k; W
                        if((xx+i)->BType!=luStaData_double) break;        //只接受实数参数9 s; \* Y  q8 c8 C4 W2 o8 i2 K9 Z

pMatrix3->Array[j]=*(double *)&((xx+i)->x); 
- h2 Z\\" L( H3 Z; e) v7 c3 E
                }- n' X  Y' O: \* _  d' A8 J

FunReObj(hFor);        //告诉Lu，返回一个动态对象 
3 U6 o9 N8 R4 F$ B. Z\\" [! {6 O
                a.BType=Matrix; a.VType=Matrix; a.x=0; *(luVOID *)&(a.x)=(luVOID)pMatrix3;  F# e# ^- B\\" Z) g* b

break; 
+ ^+ y0 @4 q8 Z3 P9 Q# l
        case 49:        //重载函数o: O& I: j4 R4 l* t* t% y

pMessage=(luMessage)SearchKey("\0\0\0\0",sizeof(luVOID),luPubKey_User);, r, M% a6 {( q

if(!pMessage) break; 
+ j4 h# r% `+ L% l! C' J$ l! I
                pMatrix1=(myMatrix *)SearchKey((char *)&(xx->x),sizeof(luVOID),Matrix);. V  c9 j; l2 }3 @. }3 }* Q

if(!pMatrix1) break;        //对象句柄无效，不是矩阵 
! x; |& j# N  A+ ~$ M6 g
                pa=pMatrix1->Array; 
; k7 w7 C  r! i( o# M
                m=pMatrix1->Dim[0]; n=pMatrix1->Dim[1]; k=0; 
1 B4 `  \' i% E* O
                for(i=0; i<m; i++)        //输出矩阵 
9 p\\" n7 Q/ \4 h% _
                {& \5 ~; g/ o% R! C3 W

pMessage(L"\r\n"); k+=2; 
8 n0 H- V( z- y4 A. I% Z
                        for(j=0; j<n; j++)# t  A& ]1 X, g% ^6 R

{ 
5 j+ S+ R( [9 ^( {
                                _gcvt_s(chNum,pa[i*n+j],16);/ v! C2 ~4 i/ B  z+ {

for(u=0;chNum[u];u++) {wchNum[u]=chNum[u]; k++;}+ w$ m# v; Y4 P+ z( h$ e$ v

wchNum[u]='\0'; 
: e# W$ Q! M7 H0 u- H\\" r8 ]
                                pMessage(wchNum); pMessage(L"  "); k+=2; 
% O* f3 t6 ]) Y) e/ a  l
                        } 
/ Q' G' j; I1 p6 u& }, k- {
                }& P7 r! c4 V1 ^

pMessage(L"\r\n"); k+=2; 
5 x$ u! @& k7 Y2 S. F6 c( M# E2 w
                a.BType=luStaData_int64; a.VType=luStaData_int64; a.x=k;        //按函数o的要求，返回输出的字符总数, l, r\\" [# d5 D9 S

break; 
. a% c& z$ a1 `0 ~* n' R9 @- F
        default:% @7 k: Y8 ~. r: j% {( D7 g, P3 m

break; 
) t0 Q$ x8 C; J% j0 o0 h
        } 
/ Q& N3 x5 |) S; m% `$ k- K
        return a; 
3 F/ o' U8 ]2 B' J\\" j
} 
\\" a# @, G! X1 C: _0 a. x8 ]
void main(void) 
/ f- a- G. ~* i( R% u
{ 
0 Y; I- I. ^4 L  R
        void *hFor;                //表达式句柄 
4 j2 W5 F# n  Y0 K  d
        luINT nPara;                //存放表达式的自变量个数: f( z3 |6 @% B4 j7 A& P3 [( n

LuData *pPara;                //存放输入自变量的数组指针0 [$ O- D4 l* a

luINT ErrBegin,ErrEnd;        //表达式编译出错的初始位置和结束位置\\" i9 F& r; j9 U- a, Y\\" J

int ErrCode;                //错误代码 
4 p& u8 h; E( ?0 q4 h( D
        void *v;. M% x1 d7 U( S4 e: {

wchar_t ForStr[]=L"o{new[matrix,2,3: 0.,1.,2.;3.,4.,5.]*new[matrix,3,2: 1.,2.;3.,4.;5.,6.]}";//字符串表达式，矩阵乘 
5 ~4 L$ |  D7 d2 G% E, [
        //wchar_t ForStr[]=L"o{new[matrix,2,3: 0.,1.,2.;3.,4.,5.].*new[matrix,2,3: 1.,2.,3.;4.,5.,6.]}";//字符串表达式，矩阵点乘' a; K' O+ R2 s

LuData Val; 
4 O: ^8 w, a) n  D1 U  L
        if(!InitLu()) return;        //初始化Lu\\" ]4 K7 d$ d- V) R% F3 f  W9 G

while(LockKey(Matrix,DelMatrix,OpMatrix)){Matrix--;}        //锁定一个键，用于存储矩阵扩展类型 
4 \) i6 `1 p( w1 J
 
4 I& b' `6 m\\" N2 W7 N$ j
        Val.BType=luStaData_int64; Val.VType=luStaData_int64; Val.x=Matrix;        //定义整数常量* v8 }! r, S/ Q4 L( R2 l5 D

SetConst(L"matrix",&Val);        //设置整数常量8 p$ y. |6 z# I% o0 b

InsertKey("\0\0\0\0",4,luPubKey_User,LuMessage,NULL,NULL,1,v); //使Lu运行时可输出函数信息( V3 g4 n' [+ C( e0 |9 {  b( W# R

wcout.imbue(locale("chs"));        //设置输出的locale为中文6 k1 E9 v/ C8 D; \

7 q7 P  |- t0 \
        ErrCode=LuCom(ForStr,0,0,0,hFor,nPara,pPara,ErrBegin,ErrEnd); //编译表达式 
8 o7 T) }5 M. z
        if(ErrCode) 
6 m* L# u) Q5 Q1 L+ {3 [\\" |& w$ d
        { 
7 V; V3 e# `7 x* f9 B, W4 n
                wcout<<L"表达式有错误！错误代码："<<ErrCode<<endl; 
0 T0 H, E' @9 U7 k9 W7 V; G\\" j
        }9 R% q) p$ j% _\\" w7 W0 t

else7 r! T& J8 u' _\\" G6 l4 Z

{' F2 G% k) g# C8 r  B3 a' ~

LuCal(hFor,pPara);        //计算表达式的值 
2 |4 [5 }) C6 T* U8 M! Z5 y* u
        }5 o  {. W: O, ]0 ?1 q2 _

LockKey(Matrix,NULL,OpMatrix);//解锁键Matrix，本例中，该函数可以不用 
( Z* G: V5 W' J4 r5 F
        FreeLu();                        //释放Lu2 M* Y5 |  `* z! R/ E# t

}

习题：

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

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

main(:a,b,c,d,t,i)=0 O& }: }# I# K& w$ m4 o
a=new[matrix,2,2: 1.,2.,2.,1.],
0 A# S: ^; c5 y3 L2 R7 } E
b=new[matrix,2,2: 2.,1.,1.,2.],8 n, i3 l, K: r7 G0 f2 l2 h% _- r
c=new[matrix,2,2: 2/3.,-1/3.,-1/3.,2/3.],
\" Q9 N7 _% l: B4 @% ^3 r% z
t=clock(),1 I) H8 B( j3 Q
d=a*b, i=0, while{i<1000000, d=d*c*b, i++},7 t; w% Q4 I! J2 v
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: 1.,2.,2.,1.], b=new[matrix,2,2: 2.,1.,1.,2.], c=new[matrix,2,2: 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\"}";//字符串表达式

复制代码

结果：