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

查看: 8676|回复: 0

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

[复制链接]

字体大小: 正常放大

forcal

45 主题	3 听众	282 积分

升级 91%

TA的每日心情

	难过 2012-8-27 18:22

签到天数: 1 天

[LV.1]初来乍到

电梯直达

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>8 u$ R5 ?: V8 W/ N6 Q6 o: q
#include <iostream>
5 Y6 L8 ]# I) E d
#include <math.h>
d8 w& P$ k8 ~, B5 Q
#include "lu32.h"
, U2 l. E1 q3 C7 d+ x% j
#pragma comment( lib, "lu32.lib" )
! j9 b# }, ^$ O! u+ d7 f& h* t
using namespace std;
V& D/ ~: e% o
//自定义矩阵
n& d' F0 t) Y) x4 w0 G3 v
class myMatrix
* ]% J1 k* n$ g, u& U. h
{
1 Z) i0 D) z- i3 m3 \6 X# x% |0 x
public:5 h* {) e: {/ u' Z7 e* k8 M* Z
double *Array; //数据缓冲区
8 {, r# T: f, h2 A C. N7 B
luVOID ArrayLen; //数据缓冲区长度7 M8 D- F5 l2 C! j) }\\" F
luVOID Dim[2]; //矩阵维数
9 M U* ^, R) _$ u! X% }
myMatrix(){Array=NULL; ArrayLen=0; Dim[0]=0; Dim[1]=0;}6 g5 _1 X# u- N1 v, h% r8 q! t
~myMatrix()
% ?8 h0 t6 _6 N- v# F) {* ]7 p
{
) H! M- f\\" P0 d4 I2 T, m5 Q: r
if(Array) delete[] Array;
, O' t& M\\" D: H! ?5 j/ Q
}0 P9 ~. M- `2 k: C$ k
};8 D) F8 |2 e, F0 K) }8 s
luKEY Matrix=-1000; //标识矩阵类型，最终的Matrix由LockKey决定4 n! u$ [; d* \\\" u! W f$ K
void _stdcall LuMessage(wchar_t *pch)//输出动态库信息，该函数注册到Lu，由Lu二级函数调用
: s* v! ?/ ^! Y# C
{% R' b6 ]/ d* P' q- e
wcout<<pch;
) }1 ], p. x2 U, p
}6 `0 p# R+ x1 d0 Z' N% v' k5 {
void _stdcall DelMatrix(void *me) //用于LockKey函数及InsertKey函数，使Lu能自动销毁myMatrix对象
' e' i9 `6 _* y- i8 P
{- [( a$ x\\" F: X$ F7 d; N* b
delete (myMatrix *)me;
4 _2 b# q. P( L3 i
}7 [3 J, v/ z& r7 V* }8 `
myMatrix * _stdcall NewMatrix(luVOID m,luVOID n) //生成一个myMatrix对象. Y+ T# }- u( R5 n! `
{
3 c$ i/ L! }- ^# P& D3 b
myMatrix *pMatrix;$ \- ^( N( m6 Y- d7 Q4 V l) U9 x( \
luVOID k; P Z( }) I1 X7 r3 @
double *pa;
& s$ b% U: W' f: o- L8 T( x9 s
char keyname[sizeof(luVOID)];0 |- z4 k, V' @/ x' C
void *NowKey;6 R) [; I; }' g! v5 }$ J0 y
k=m*n; Z& x; z% R E& a9 y7 t
pMatrix=(myMatrix *)GetBufObj(Matrix,keyname);//先尝试从缓冲区中获取一个矩阵对象
\\" [+ w+ p8 u1 I- H, @$ H
if(pMatrix)# G& l6 c- I+ l( T3 _+ x1 q, i
{( g8 {$ d1 i- r7 t' @3 z' `6 w% y
if(pMatrix->ArrayLen!=k) //重置矩阵的大小1 L0 y) }6 ?- x$ p/ M7 i
{0 x( {: m( o$ e& {: L2 f
pa=new double[k];
2 k' H6 c X! e- q\\" [5 G
if(!pa)9 u! p; M- e\\" I5 ?% L0 T
{; M3 o4 \: C/ E) o$ F
DeleteKey(keyname,sizeof(luVOID),Matrix,DelMatrix,1); //将矩阵对象放回缓冲区
6 ?( ]+ f5 X1 o6 }$ U+ `- q
return NULL;# q: _& e5 v6 i5 g
}0 t+ h4 K; E' q4 }$ R9 _' K- C, y
delete[] pMatrix->Array;
6 C* C1 A3 a$ B3 T
pMatrix->Array=pa;
# d\\" K- R, `( G( A1 m4 p. ~
}, y$ D1 T6 ~; \
}
5 U8 ?( F @4 U& T% P* X6 W3 b. q
else, g W4 a4 Q- F7 h
{
+ \( }; k* x! C6 V: u
pMatrix=new myMatrix; //创建矩阵对象
4 [7 B' A5 S0 F& R
if(!pMatrix) return NULL;9 }/ ?1 X6 N- {) G
pMatrix->Array=new double[k];, @+ v$ L& I\\" k6 Q\\" C
if(!pMatrix->Array)
0 `: x4 c s. i/ b0 Z
{
$ c9 r4 ?. J+ X5 n
delete pMatrix;
9 N4 @* e$ F. s$ C2 x# n/ A
return NULL;
* {9 l3 N3 \& c; k* O
}& l9 ~' [\\" J9 ^6 L8 ]# l/ d/ X
if(InsertKey((char *)&pMatrix,-1,Matrix,pMatrix,DelMatrix,NULL,0,NowKey)) //将矩阵对象注册到Lu
$ h# ~' _6 `' J4 l& l3 I. {
{
1 _# {5 H2 A! c8 e. d# T
delete pMatrix;; |% p' L( V\\" Z5 A, e
return NULL;) q) b j\\" w# E1 q/ t3 }7 u
}. B+ E9 N/ c1 e
}3 O- @9 z. I3 H; q1 T: w
pMatrix->ArrayLen=k; pMatrix->Dim[0]=m; pMatrix->Dim[1]=n;( I! M+ H1 r4 N, i
return pMatrix;# K6 R1 J8 ~. p- h2 v
}1 @1 Z$ U5 x) T9 H! X% q
LuData _stdcall OpMatrix(luINT mm,LuData *xx,void *hFor,int theOperator) //运算符重载函数，用于LockKey函数
' @ S) V9 R6 j7 R3 T# W5 F7 X& m
{% K; H! t# j% u* ^
LuData a;9 q' `5 {, X/ L\\" G5 q: l$ R0 N
myMatrix *pMatrix1,*pMatrix2,*pMatrix3;, B9 n8 ~; w) d* l# r1 X$ n
luVOID i,j,k,m,n,u,v;
8 u% C# I# y0 o+ M7 U\\" F6 g
double *pa,*pb,*pc;
/ O; _# q* H O9 d\\" @1 y
luMessage pMessage;: _# F8 \\\" J8 f4 M
wchar_t wchNum[32];\\" ^. P7 V1 r) C$ E
char chNum[32];
* Q2 B- S: b& t- @2 [- M
a.BType=luStaData_nil; a.VType=luStaData_nil; a.x=0;6 N2 R0 E6 u- V
switch(theOperator)9 i\\" F; @) D( D* y\\" `
{5 e6 u: v D8 q w# G8 {
case 2: //重载运算符*: l4 g0 k' t7 Q R
pMatrix1=(myMatrix *)SearchKey((char *)&(xx->x),sizeof(luVOID),Matrix);+ H\\" G8 m7 u) W2 s/ Y6 K
pMatrix2=(myMatrix *)SearchKey((char *)&((xx+1)->x),sizeof(luVOID),Matrix); d) ~2 V) s6 H2 a9 [$ i
if(!pMatrix1 || !pMatrix2) break; //对象句柄无效，不是矩阵7 f% z( c, \1 ?2 h
if(pMatrix1->Dim[1]!=pMatrix2->Dim[0]) break; //维数不匹配6 X+ N/ b* p: m7 j' I3 w, i
pMatrix3=NewMatrix(pMatrix1->Dim[0],pMatrix2->Dim[1]); //生成新矩阵( I, P7 }4 I1 A\\" O7 }1 ]2 U
if(!pMatrix3) break;( |& z/ f' D% S# L; r% Z9 n
pa=pMatrix1->Array; pb=pMatrix2->Array; pc=pMatrix3->Array;
& G8 Y; j2 u$ F0 x }3 m2 z2 y$ g
m=pMatrix1->Dim[0]; n=pMatrix1->Dim[1]; k=pMatrix2->Dim[1];
2 y+ Q6 |& [. X) B. s\\" S; I
for(i=0; i<m; i++) //矩阵乘$ K# o8 C' U* v; T\\" ]( R5 k
{4 _7 s8 l* |: v; h$ T2 w. W
for(j=0; j<k; j++)\\" r+ ]7 {$ N+ r$ k
{
. z$ L4 `+ I0 p
u=i*k+j; pc[u]=0.0;7 e\\" {+ w t7 l8 M6 T G: N! F
for (v=0; v<n; v++)/ R0 Y) B3 K0 N# g
{
& i! I- r$ e0 G0 g2 Q- y0 E7 ^1 r
pc[u]=pc[u]+pa[i*n+v]*pb[v*k+j];
$ s0 y! K1 n/ v: K& I
}
2 g( j3 H, F) C y) \3 f2 i* @
}. X1 R$ K- `+ }0 K
}9 r$ E9 s: i6 h: y( U* j% q' v8 j
FunReObj(hFor); //告诉Lu，返回一个动态对象. e1 D; v8 M. l+ m
a.BType=Matrix; a.VType=Matrix; a.x=0; *(luVOID *)&(a.x)=(luVOID)pMatrix3;
. S9 F' y5 `' |5 R
break;5 `. x5 {/ A8 P1 Z9 H, I1 m1 I) D
case 25: //重载运算符.*
% n1 k, g. v1 o
pMatrix1=(myMatrix *)SearchKey((char *)&(xx->x),sizeof(luVOID),Matrix);. n) r, O8 {0 k6 m\\" F2 x {
pMatrix2=(myMatrix *)SearchKey((char *)&((xx+1)->x),sizeof(luVOID),Matrix);
- K, `, t$ s; J) z c2 k
if(!pMatrix1 || !pMatrix2) break; //对象句柄无效，不是矩阵
# j, b2 m* R8 e
if(pMatrix1->Dim[0]!=pMatrix2->Dim[0] || pMatrix1->Dim[1]!=pMatrix2->Dim[1]) break; //维数不相同
# l0 H3 X4 F2 z8 F1 N$ N7 O9 |
pMatrix3=NewMatrix(pMatrix1->Dim[0],pMatrix1->Dim[1]); //生成新矩阵6 ?/ d \) A' q7 e0 e, `6 m4 J
if(!pMatrix3) break;
$ ^7 H1 v- t. F! d
for(i=0;i<pMatrix1->ArrayLen;i++) pMatrix3->Array[i]=pMatrix1->Array[i]*pMatrix2->Array[i]; //矩阵点乘9 O: [; M& K6 l5 _ Q& r
FunReObj(hFor); //告诉Lu，返回一个动态对象
* F8 Q( `, x! w' N, n. X\\" S- a: D* i
a.BType=Matrix; a.VType=Matrix; a.x=0; *(luVOID *)&(a.x)=(luVOID)pMatrix3;, G1 R2 [. K/ t0 S- `; u
break;
- X, D, D4 b7 t0 a4 @4 {8 x4 C$ n& M
case 46: //重载函数new
5 U0 }3 w) B Z5 }\\" J
if(mm<2) break;\\" V3 A- ]7 h! K9 o. n E
if((xx+1)->x<1 || (xx+2)->x<1 || (xx+1)->BType!=luStaData_int64 || (xx+2)->BType!=luStaData_int64) break;' d# |8 m( _, C
pMatrix3=NewMatrix((luVOID)(xx+1)->x,(luVOID)(xx+2)->x);//生成新矩阵( R0 y; Q: f; I' V8 U Y( l
if(!pMatrix3) break;1 d. d8 g. S0 M( J8 P+ n
for(j=0,i=3;i<=mm;i++,j++) //赋初值
, F o\\" X# V& U! a
{
# K4 T6 w\\" K: d' ~. l
if(j>=pMatrix3->ArrayLen) break;
# P2 n# N+ n- l( l: g
if((xx+i)->BType!=luStaData_double) break; //只接受实数参数
\\" h' |+ u$ F' ~* H5 m
pMatrix3->Array[j]=*(double *)&((xx+i)->x);% }' W+ o# {7 I\\" I3 O4 o
} q; r5 S7 `) m; D! r6 ?
FunReObj(hFor); //告诉Lu，返回一个动态对象: d\\" O, M: @1 L6 V% i1 ~
a.BType=Matrix; a.VType=Matrix; a.x=0; *(luVOID *)&(a.x)=(luVOID)pMatrix3;
. y# G e, i I1 D$ _
break;
: N% x. f3 g/ Y7 g [
case 49: //重载函数o/ Q& L1 e4 d' Z( R- T\\" {
pMessage=(luMessage)SearchKey("\0\0\0\0",sizeof(luVOID),luPubKey_User);
5 @+ b4 ?0 o: R, P; Y( S) d8 d
if(!pMessage) break;0 S& }* O1 V; f t) \( }
pMatrix1=(myMatrix *)SearchKey((char *)&(xx->x),sizeof(luVOID),Matrix);( _0 @* x$ w( a1 Y8 w, {6 I
if(!pMatrix1) break; //对象句柄无效，不是矩阵
0 T& _\\" l$ o9 E0 q0 A
pa=pMatrix1->Array;
7 Q4 h* U0 O) L: I7 `7 D
m=pMatrix1->Dim[0]; n=pMatrix1->Dim[1]; k=0;
7 u( Y3 F5 s+ R\\" p/ j/ ]
for(i=0; i<m; i++) //输出矩阵% Z3 u( e, X- }+ n: L( n s5 l4 j
{$ w6 B# r3 c7 |6 Z
pMessage(L"\r\n"); k+=2;
9 ~8 R- G* N% v$ ~; X( m+ K. p- d: h
for(j=0; j<n; j++)
4 N% x1 n8 r* |% z& a
{) e( r9 y! Y/ K! p1 z
_gcvt_s(chNum,pa[i*n+j],16);
3 C$ M H8 W d y
for(u=0;chNum[u];u++) {wchNum[u]=chNum[u]; k++;}* f3 H% G9 h+ R8 s& n
wchNum[u]='\0';# s! _* K! |9 a8 L; J6 C$ Z
pMessage(wchNum); pMessage(L" "); k+=2;
1 B% P$ Z# r\\" m; ]# r* @' d
}& h- y3 S8 ]- M9 U# m3 F
}' a& z/ f; e1 V* ]& C* G2 c
pMessage(L"\r\n"); k+=2;5 {* |+ O; |0 |\\" z
a.BType=luStaData_int64; a.VType=luStaData_int64; a.x=k; //按函数o的要求，返回输出的字符总数
7 d9 b! t7 t+ K8 ~' z9 {
break;
; e4 O. L8 c- E1 ^
default:
' x5 f% Y1 N0 Q4 M; }0 v
break;
7 m- ^6 G' D8 h* p\\" p
}
- r8 r4 O a4 n
return a;
/ I9 K1 L( D+ x' y; @0 k/ a- t
}+ ]( l- C) Q' t/ A1 P$ r
void main(void)
; G3 ]) O9 I9 q# a
{2 O( z* f8 W& r
void *hFor; //表达式句柄
+ G& h6 S+ f% _ J! y1 T' |
luINT nPara; //存放表达式的自变量个数
5 s/ u- r! N8 x0 U- e
LuData *pPara; //存放输入自变量的数组指针
( c+ h. j4 r# ]- C& u; _& n) t2 S
luINT ErrBegin,ErrEnd; //表达式编译出错的初始位置和结束位置
8 ~2 J) I\\" l( C/ M6 h
int ErrCode; //错误代码
2 M6 h\\" k/ y: K( E: `$ y3 G
void *v;: n2 o3 {3 d# S1 g
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.]}";//字符串表达式，矩阵乘. Y1 R6 R* C6 J' i q$ L
//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.]}";//字符串表达式，矩阵点乘. O' u+ E1 e& v( p% \
LuData Val;9 Y# w; V( k8 c: f- b\\" E4 L
if(!InitLu()) return; //初始化Lu
7 k+ C# S! c' U
while(LockKey(Matrix,DelMatrix,OpMatrix)){Matrix--;} //锁定一个键，用于存储矩阵扩展类型 w0 t6 n( o9 S2 ?$ u7 l \
$ v4 U\\" @. Y8 u- u
Val.BType=luStaData_int64; Val.VType=luStaData_int64; Val.x=Matrix; //定义整数常量
3 U7 N S' C- G( f3 N
SetConst(L"matrix",&Val); //设置整数常量; K7 \3 m; H& C& e, M
InsertKey("\0\0\0\0",4,luPubKey_User,LuMessage,NULL,NULL,1,v); //使Lu运行时可输出函数信息. f/ W Z% L: g& f: k2 N
wcout.imbue(locale("chs")); //设置输出的locale为中文& u8 C/ D2 F6 C, W8 W
. @& j8 |5 e' \6 t2 |
ErrCode=LuCom(ForStr,0,0,0,hFor,nPara,pPara,ErrBegin,ErrEnd); //编译表达式. z5 |2 {5 [& f4 ?- ]
if(ErrCode)
0 j2 b& m4 }4 Z3 y; P
{8 [0 Q8 m# w$ g% T! e( b: y
wcout<<L"表达式有错误！错误代码："<<ErrCode<<endl;' h7 i' v; G/ O% p5 ^
}
4 {5 Z/ }/ m4 Z# r- S
else2 j) @+ G% X, K$ ~+ A( ]% H
{
0 l$ g8 F5 ` _* G: T2 p( S: T9 B
LuCal(hFor,pPara); //计算表达式的值
! Z! K9 z! `6 C8 }6 i d\\" a) U
}! Y% M* \\\" Y7 N! @9 t4 d2 N/ M# B
LockKey(Matrix,NULL,OpMatrix);//解锁键Matrix，本例中，该函数可以不用8 m: w' n V) h _1 r\\" E
FreeLu(); //释放Lu7 Q: T4 {# C# H\\" a$ ~9 \
}

#include <windows.h>8 u$ R5 ?: V8 W/ N6 Q6 o: q

#include <iostream> 
5 Y6 L8 ]# I) E  d
#include <math.h> 
  d8 w& P$ k8 ~, B5 Q
#include "lu32.h" 
, U2 l. E1 q3 C7 d+ x% j
#pragma comment( lib, "lu32.lib" ) 
! j9 b# }, ^$ O! u+ d7 f& h* t
using namespace std; 
  V& D/ ~: e% o
//自定义矩阵 
  n& d' F0 t) Y) x4 w0 G3 v
class myMatrix 
* ]% J1 k* n$ g, u& U. h
{ 
1 Z) i0 D) z- i3 m3 \6 X# x% |0 x
public:5 h* {) e: {/ u' Z7 e* k8 M* Z

double *Array;        //数据缓冲区 
8 {, r# T: f, h2 A  C. N7 B
        luVOID ArrayLen;        //数据缓冲区长度7 M8 D- F5 l2 C! j) }\\" F

luVOID Dim[2];        //矩阵维数 
9 M  U* ^, R) _$ u! X% }
        myMatrix(){Array=NULL; ArrayLen=0; Dim[0]=0; Dim[1]=0;}6 g5 _1 X# u- N1 v, h% r8 q! t

~myMatrix() 
% ?8 h0 t6 _6 N- v# F) {* ]7 p
        { 
) H! M- f\\" P0 d4 I2 T, m5 Q: r
                if(Array) delete[] Array; 
, O' t& M\\" D: H! ?5 j/ Q
        }0 P9 ~. M- `2 k: C$ k

};8 D) F8 |2 e, F0 K) }8 s

luKEY Matrix=-1000;        //标识矩阵类型，最终的Matrix由LockKey决定4 n! u$ [; d* \\\" u! W  f$ K

void _stdcall LuMessage(wchar_t *pch)//输出动态库信息，该函数注册到Lu，由Lu二级函数调用 
: s* v! ?/ ^! Y# C
{% R' b6 ]/ d* P' q- e

wcout<<pch; 
) }1 ], p. x2 U, p
}6 `0 p# R+ x1 d0 Z' N% v' k5 {

void _stdcall DelMatrix(void *me)        //用于LockKey函数及InsertKey函数，使Lu能自动销毁myMatrix对象 
' e' i9 `6 _* y- i8 P
{- [( a$ x\\" F: X$ F7 d; N* b

delete (myMatrix *)me; 
4 _2 b# q. P( L3 i
}7 [3 J, v/ z& r7 V* }8 `

myMatrix * _stdcall NewMatrix(luVOID m,luVOID n)        //生成一个myMatrix对象. Y+ T# }- u( R5 n! `

{ 
3 c$ i/ L! }- ^# P& D3 b
        myMatrix *pMatrix;$ \- ^( N( m6 Y- d7 Q4 V  l) U9 x( \

luVOID k;  P  Z( }) I1 X7 r3 @

double *pa; 
& s$ b% U: W' f: o- L8 T( x9 s
        char keyname[sizeof(luVOID)];0 |- z4 k, V' @/ x' C

void *NowKey;6 R) [; I; }' g! v5 }$ J0 y

k=m*n;  Z& x; z% R  E& a9 y7 t

pMatrix=(myMatrix *)GetBufObj(Matrix,keyname);//先尝试从缓冲区中获取一个矩阵对象 
\\" [+ w+ p8 u1 I- H, @$ H
        if(pMatrix)# G& l6 c- I+ l( T3 _+ x1 q, i

{( g8 {$ d1 i- r7 t' @3 z' `6 w% y

if(pMatrix->ArrayLen!=k)        //重置矩阵的大小1 L0 y) }6 ?- x$ p/ M7 i

{0 x( {: m( o$ e& {: L2 f

pa=new double[k]; 
2 k' H6 c  X! e- q\\" [5 G
                        if(!pa)9 u! p; M- e\\" I5 ?% L0 T

{; M3 o4 \: C/ E) o$ F

DeleteKey(keyname,sizeof(luVOID),Matrix,DelMatrix,1);        //将矩阵对象放回缓冲区 
6 ?( ]+ f5 X1 o6 }$ U+ `- q
                                return NULL;# q: _& e5 v6 i5 g

}0 t+ h4 K; E' q4 }$ R9 _' K- C, y

delete[] pMatrix->Array; 
6 C* C1 A3 a$ B3 T
                        pMatrix->Array=pa; 
# d\\" K- R, `( G( A1 m4 p. ~
                }, y$ D1 T6 ~; \

} 
5 U8 ?( F  @4 U& T% P* X6 W3 b. q
        else, g  W4 a4 Q- F7 h

{ 
+ \( }; k* x! C6 V: u
                pMatrix=new myMatrix;        //创建矩阵对象 
4 [7 B' A5 S0 F& R
                if(!pMatrix) return NULL;9 }/ ?1 X6 N- {) G

pMatrix->Array=new double[k];, @+ v$ L& I\\" k6 Q\\" C

if(!pMatrix->Array) 
0 `: x4 c  s. i/ b0 Z
                { 
$ c9 r4 ?. J+ X5 n
                        delete pMatrix; 
9 N4 @* e$ F. s$ C2 x# n/ A
                        return NULL; 
* {9 l3 N3 \& c; k* O
                }& l9 ~' [\\" J9 ^6 L8 ]# l/ d/ X

if(InsertKey((char *)&pMatrix,-1,Matrix,pMatrix,DelMatrix,NULL,0,NowKey))        //将矩阵对象注册到Lu 
$ h# ~' _6 `' J4 l& l3 I. {
                { 
1 _# {5 H2 A! c8 e. d# T
                        delete pMatrix;; |% p' L( V\\" Z5 A, e

return NULL;) q) b  j\\" w# E1 q/ t3 }7 u

}. B+ E9 N/ c1 e

}3 O- @9 z. I3 H; q1 T: w

pMatrix->ArrayLen=k; pMatrix->Dim[0]=m; pMatrix->Dim[1]=n;( I! M+ H1 r4 N, i

return pMatrix;# K6 R1 J8 ~. p- h2 v

}1 @1 Z$ U5 x) T9 H! X% q

LuData _stdcall OpMatrix(luINT mm,LuData *xx,void *hFor,int theOperator)        //运算符重载函数，用于LockKey函数 
' @  S) V9 R6 j7 R3 T# W5 F7 X& m
{% K; H! t# j% u* ^

LuData a;9 q' `5 {, X/ L\\" G5 q: l$ R0 N

myMatrix *pMatrix1,*pMatrix2,*pMatrix3;, B9 n8 ~; w) d* l# r1 X$ n

luVOID i,j,k,m,n,u,v; 
8 u% C# I# y0 o+ M7 U\\" F6 g
        double *pa,*pb,*pc; 
/ O; _# q* H  O9 d\\" @1 y
        luMessage pMessage;: _# F8 \\\" J8 f4 M

wchar_t wchNum[32];\\" ^. P7 V1 r) C$ E

char chNum[32]; 
* Q2 B- S: b& t- @2 [- M
        a.BType=luStaData_nil; a.VType=luStaData_nil; a.x=0;6 N2 R0 E6 u- V

switch(theOperator)9 i\\" F; @) D( D* y\\" `

{5 e6 u: v  D8 q  w# G8 {

case 2:        //重载运算符*: l4 g0 k' t7 Q  R

pMatrix1=(myMatrix *)SearchKey((char *)&(xx->x),sizeof(luVOID),Matrix);+ H\\" G8 m7 u) W2 s/ Y6 K

pMatrix2=(myMatrix *)SearchKey((char *)&((xx+1)->x),sizeof(luVOID),Matrix);  d) ~2 V) s6 H2 a9 [$ i

if(!pMatrix1 || !pMatrix2) break;        //对象句柄无效，不是矩阵7 f% z( c, \1 ?2 h

if(pMatrix1->Dim[1]!=pMatrix2->Dim[0]) break;        //维数不匹配6 X+ N/ b* p: m7 j' I3 w, i

pMatrix3=NewMatrix(pMatrix1->Dim[0],pMatrix2->Dim[1]);        //生成新矩阵( I, P7 }4 I1 A\\" O7 }1 ]2 U

if(!pMatrix3) break;( |& z/ f' D% S# L; r% Z9 n

pa=pMatrix1->Array; pb=pMatrix2->Array; pc=pMatrix3->Array; 
& G8 Y; j2 u$ F0 x  }3 m2 z2 y$ g
                m=pMatrix1->Dim[0]; n=pMatrix1->Dim[1]; k=pMatrix2->Dim[1]; 
2 y+ Q6 |& [. X) B. s\\" S; I
                for(i=0; i<m; i++)        //矩阵乘$ K# o8 C' U* v; T\\" ]( R5 k

{4 _7 s8 l* |: v; h$ T2 w. W

for(j=0; j<k; j++)\\" r+ ]7 {$ N+ r$ k

{ 
. z$ L4 `+ I0 p
                                u=i*k+j; pc[u]=0.0;7 e\\" {+ w  t7 l8 M6 T  G: N! F

for (v=0; v<n; v++)/ R0 Y) B3 K0 N# g

{ 
& i! I- r$ e0 G0 g2 Q- y0 E7 ^1 r
                                        pc[u]=pc[u]+pa[i*n+v]*pb[v*k+j]; 
$ s0 y! K1 n/ v: K& I
                                } 
2 g( j3 H, F) C  y) \3 f2 i* @
                        }. X1 R$ K- `+ }0 K

}9 r$ E9 s: i6 h: y( U* j% q' v8 j

FunReObj(hFor);        //告诉Lu，返回一个动态对象. e1 D; v8 M. l+ m

a.BType=Matrix; a.VType=Matrix; a.x=0; *(luVOID *)&(a.x)=(luVOID)pMatrix3; 
. S9 F' y5 `' |5 R
                break;5 `. x5 {/ A8 P1 Z9 H, I1 m1 I) D

case 25:        //重载运算符.* 
% n1 k, g. v1 o
                pMatrix1=(myMatrix *)SearchKey((char *)&(xx->x),sizeof(luVOID),Matrix);. n) r, O8 {0 k6 m\\" F2 x  {

pMatrix2=(myMatrix *)SearchKey((char *)&((xx+1)->x),sizeof(luVOID),Matrix); 
- K, `, t$ s; J) z  c2 k
                if(!pMatrix1 || !pMatrix2) break;        //对象句柄无效，不是矩阵 
# j, b2 m* R8 e
                if(pMatrix1->Dim[0]!=pMatrix2->Dim[0] || pMatrix1->Dim[1]!=pMatrix2->Dim[1]) break;        //维数不相同 
# l0 H3 X4 F2 z8 F1 N$ N7 O9 |
                pMatrix3=NewMatrix(pMatrix1->Dim[0],pMatrix1->Dim[1]);        //生成新矩阵6 ?/ d  \) A' q7 e0 e, `6 m4 J

if(!pMatrix3) break; 
$ ^7 H1 v- t. F! d
                for(i=0;i<pMatrix1->ArrayLen;i++) pMatrix3->Array[i]=pMatrix1->Array[i]*pMatrix2->Array[i];        //矩阵点乘9 O: [; M& K6 l5 _  Q& r

FunReObj(hFor);        //告诉Lu，返回一个动态对象 
* F8 Q( `, x! w' N, n. X\\" S- a: D* i
                a.BType=Matrix; a.VType=Matrix; a.x=0; *(luVOID *)&(a.x)=(luVOID)pMatrix3;, G1 R2 [. K/ t0 S- `; u

break; 
- X, D, D4 b7 t0 a4 @4 {8 x4 C$ n& M
        case 46:        //重载函数new 
5 U0 }3 w) B  Z5 }\\" J
                if(mm<2) break;\\" V3 A- ]7 h! K9 o. n  E

if((xx+1)->x<1 || (xx+2)->x<1 || (xx+1)->BType!=luStaData_int64 || (xx+2)->BType!=luStaData_int64) break;' d# |8 m( _, C

pMatrix3=NewMatrix((luVOID)(xx+1)->x,(luVOID)(xx+2)->x);//生成新矩阵( R0 y; Q: f; I' V8 U  Y( l

if(!pMatrix3) break;1 d. d8 g. S0 M( J8 P+ n

for(j=0,i=3;i<=mm;i++,j++)        //赋初值 
, F  o\\" X# V& U! a
                { 
# K4 T6 w\\" K: d' ~. l
                        if(j>=pMatrix3->ArrayLen) break; 
# P2 n# N+ n- l( l: g
                        if((xx+i)->BType!=luStaData_double) break;        //只接受实数参数 
\\" h' |+ u$ F' ~* H5 m
                        pMatrix3->Array[j]=*(double *)&((xx+i)->x);% }' W+ o# {7 I\\" I3 O4 o

}  q; r5 S7 `) m; D! r6 ?

FunReObj(hFor);        //告诉Lu，返回一个动态对象: d\\" O, M: @1 L6 V% i1 ~

a.BType=Matrix; a.VType=Matrix; a.x=0; *(luVOID *)&(a.x)=(luVOID)pMatrix3; 
. y# G  e, i  I1 D$ _
                break; 
: N% x. f3 g/ Y7 g  [
        case 49:        //重载函数o/ Q& L1 e4 d' Z( R- T\\" {

pMessage=(luMessage)SearchKey("\0\0\0\0",sizeof(luVOID),luPubKey_User); 
5 @+ b4 ?0 o: R, P; Y( S) d8 d
                if(!pMessage) break;0 S& }* O1 V; f  t) \( }

pMatrix1=(myMatrix *)SearchKey((char *)&(xx->x),sizeof(luVOID),Matrix);( _0 @* x$ w( a1 Y8 w, {6 I

if(!pMatrix1) break;        //对象句柄无效，不是矩阵 
0 T& _\\" l$ o9 E0 q0 A
                pa=pMatrix1->Array; 
7 Q4 h* U0 O) L: I7 `7 D
                m=pMatrix1->Dim[0]; n=pMatrix1->Dim[1]; k=0; 
7 u( Y3 F5 s+ R\\" p/ j/ ]
                for(i=0; i<m; i++)        //输出矩阵% Z3 u( e, X- }+ n: L( n  s5 l4 j

{$ w6 B# r3 c7 |6 Z

pMessage(L"\r\n"); k+=2; 
9 ~8 R- G* N% v$ ~; X( m+ K. p- d: h
                        for(j=0; j<n; j++) 
4 N% x1 n8 r* |% z& a
                        {) e( r9 y! Y/ K! p1 z

_gcvt_s(chNum,pa[i*n+j],16); 
3 C$ M  H8 W  d  y
                                for(u=0;chNum[u];u++) {wchNum[u]=chNum[u]; k++;}* f3 H% G9 h+ R8 s& n

wchNum[u]='\0';# s! _* K! |9 a8 L; J6 C$ Z

pMessage(wchNum); pMessage(L"  "); k+=2; 
1 B% P$ Z# r\\" m; ]# r* @' d
                        }& h- y3 S8 ]- M9 U# m3 F

}' a& z/ f; e1 V* ]& C* G2 c

pMessage(L"\r\n"); k+=2;5 {* |+ O; |0 |\\" z

a.BType=luStaData_int64; a.VType=luStaData_int64; a.x=k;        //按函数o的要求，返回输出的字符总数 
7 d9 b! t7 t+ K8 ~' z9 {
                break; 
; e4 O. L8 c- E1 ^
        default: 
' x5 f% Y1 N0 Q4 M; }0 v
                break; 
7 m- ^6 G' D8 h* p\\" p
        } 
- r8 r4 O  a4 n
        return a; 
/ I9 K1 L( D+ x' y; @0 k/ a- t
}+ ]( l- C) Q' t/ A1 P$ r

void main(void) 
; G3 ]) O9 I9 q# a
{2 O( z* f8 W& r

void *hFor;                //表达式句柄 
+ G& h6 S+ f% _  J! y1 T' |
        luINT nPara;                //存放表达式的自变量个数 
5 s/ u- r! N8 x0 U- e
        LuData *pPara;                //存放输入自变量的数组指针 
( c+ h. j4 r# ]- C& u; _& n) t2 S
        luINT ErrBegin,ErrEnd;        //表达式编译出错的初始位置和结束位置 
8 ~2 J) I\\" l( C/ M6 h
        int ErrCode;                //错误代码 
2 M6 h\\" k/ y: K( E: `$ y3 G
        void *v;: n2 o3 {3 d# S1 g

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.]}";//字符串表达式，矩阵乘. Y1 R6 R* C6 J' i  q$ L

//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.]}";//字符串表达式，矩阵点乘. O' u+ E1 e& v( p% \

LuData Val;9 Y# w; V( k8 c: f- b\\" E4 L

if(!InitLu()) return;        //初始化Lu 
7 k+ C# S! c' U
        while(LockKey(Matrix,DelMatrix,OpMatrix)){Matrix--;}        //锁定一个键，用于存储矩阵扩展类型  w0 t6 n( o9 S2 ?$ u7 l  \

$ v4 U\\" @. Y8 u- u
        Val.BType=luStaData_int64; Val.VType=luStaData_int64; Val.x=Matrix;        //定义整数常量 
3 U7 N  S' C- G( f3 N
        SetConst(L"matrix",&Val);        //设置整数常量; K7 \3 m; H& C& e, M

InsertKey("\0\0\0\0",4,luPubKey_User,LuMessage,NULL,NULL,1,v); //使Lu运行时可输出函数信息. f/ W  Z% L: g& f: k2 N

wcout.imbue(locale("chs"));        //设置输出的locale为中文& u8 C/ D2 F6 C, W8 W

. @& j8 |5 e' \6 t2 |

ErrCode=LuCom(ForStr,0,0,0,hFor,nPara,pPara,ErrBegin,ErrEnd); //编译表达式. z5 |2 {5 [& f4 ?- ]

if(ErrCode) 
0 j2 b& m4 }4 Z3 y; P
        {8 [0 Q8 m# w$ g% T! e( b: y

wcout<<L"表达式有错误！错误代码："<<ErrCode<<endl;' h7 i' v; G/ O% p5 ^

} 
4 {5 Z/ }/ m4 Z# r- S
        else2 j) @+ G% X, K$ ~+ A( ]% H

{ 
0 l$ g8 F5 `  _* G: T2 p( S: T9 B
                LuCal(hFor,pPara);        //计算表达式的值 
! Z! K9 z! `6 C8 }6 i  d\\" a) U
        }! Y% M* \\\" Y7 N! @9 t4 d2 N/ M# B

LockKey(Matrix,NULL,OpMatrix);//解锁键Matrix，本例中，该函数可以不用8 m: w' n  V) h  _1 r\\" E

FreeLu();                        //释放Lu7 Q: T4 {# C# H\\" a$ ~9 \

}

习题：

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

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

main(:a,b,c,d,t,i)=
+ z& E- n7 i2 U5 e' Y8 N2 n9 j
a=new[matrix,2,2: 1.,2.,2.,1.],
3 ?- w) L z2 S
b=new[matrix,2,2: 2.,1.,1.,2.],; N# K' L8 _\" n
c=new[matrix,2,2: 2/3.,-1/3.,-1/3.,2/3.],# g0 Q9 R8 v4 D+ w3 g0 e9 C' r5 ]
t=clock(),
# `3 t3 M/ z% g
d=a*b, i=0, while{i<1000000, d=d*c*b, i++},' r! m) `& L* N2 E# `9 U
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\"}";//字符串表达式

复制代码

结果：