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

查看: 8675|回复: 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> E! u+ g h6 u2 C7 [
#include <iostream>9 B* \( A6 [( A) ^) R$ X; {, E9 f
#include <math.h>5 G. a4 H6 L8 d6 @- ^0 q* R* q
#include "lu32.h"# D# D, w% @6 J1 ^4 V
#pragma comment( lib, "lu32.lib" )# q: f; U1 m, G2 l' u$ O
using namespace std;8 T6 J; u+ M' a. y- ~' n9 O
//自定义矩阵/ ^9 e; r2 Z Q8 a k1 R4 r' O
class myMatrix
3 N' k$ a1 W1 ]& Y
{9 m1 c! z. y6 j3 q6 R
public:8 |% ]+ H6 i p! }, J0 U: T2 _
double *Array; //数据缓冲区7 W* ]1 m I7 v% J( k
luVOID ArrayLen; //数据缓冲区长度9 P\\" k. s5 n. H
luVOID Dim[2]; //矩阵维数4 ~! u! t9 u; L. R/ S6 u
myMatrix(){Array=NULL; ArrayLen=0; Dim[0]=0; Dim[1]=0;}- k2 {9 t7 q. z l! P9 v7 R. E
~myMatrix()$ u! z# r0 y+ L }7 A; d4 ^
{+ m x8 B6 Y7 o' B* f
if(Array) delete[] Array;
' `7 T3 f+ |8 M; p( P- Q
}( c0 |) F& ~2 p9 J; Y
};
) }' h, K0 e/ C2 \0 c. v
luKEY Matrix=-1000; //标识矩阵类型，最终的Matrix由LockKey决定\\" |0 }$ E- M& h. b8 z7 T% g! k- O\\" }$ Y
void _stdcall LuMessage(wchar_t *pch)//输出动态库信息，该函数注册到Lu，由Lu二级函数调用 . E% N0 O. x6 l& d! D* s
{2 }2 C\\" e. Q0 O) P* A7 U: z
wcout<<pch;. Q1 l5 y& t. y8 x$ X
}3 O0 A5 M9 X\\" K l+ X: [
void _stdcall DelMatrix(void *me) //用于LockKey函数及InsertKey函数，使Lu能自动销毁myMatrix对象
, W Q9 N/ y5 y0 s# D' L
{
5 N# |- {\\" i! ]3 Q3 n
delete (myMatrix *)me;$ m+ B5 v\\" W( M, g+ R5 D
}
& o. C0 I: T$ S' q& s7 n; H. f
myMatrix * _stdcall NewMatrix(luVOID m,luVOID n) //生成一个myMatrix对象0 q\\" o/ ^7 t; G6 [8 @- F1 F1 z4 |
{
: q, ^5 l\\" M3 Z4 D7 @% s
myMatrix *pMatrix;
luVOID k;, P! o, V2 x f4 M/ \2 s* |9 Q
double *pa;* N8 @7 ^: x( K& z4 H$ i1 W
char keyname[sizeof(luVOID)];: e' a+ {4 D. R2 w\\" E, d: l+ c
void *NowKey;' V8 ~* Z, }5 E
k=m*n;
& W: Y$ f8 M9 J! ]
pMatrix=(myMatrix *)GetBufObj(Matrix,keyname);//先尝试从缓冲区中获取一个矩阵对象
6 Y4 \; i; M* Y0 x
if(pMatrix)
$ r; U& V1 B\\" |* k% K5 x* o, V+ |
{& `5 X* z1 [9 K/ B& ` y7 u( J
if(pMatrix->ArrayLen!=k) //重置矩阵的大小
* e. z; L4 F* B) J
{' P4 ^5 C ^$ q- j3 p
pa=new double[k];! B% z! v. A: @: o { ^4 x
if(!pa)
4 G1 T& q6 w& r7 ^1 m
{
: W3 m) u: u4 |, N, U$ w
DeleteKey(keyname,sizeof(luVOID),Matrix,DelMatrix,1); //将矩阵对象放回缓冲区
5 x# W v' Z* F# D
return NULL; c, M2 f6 Y1 _. D9 x
}4 d. ]! ^; {9 K( p) \\\" ?
delete[] pMatrix->Array;& R! e& _# T$ c' Z$ z0 e) B0 j8 z
pMatrix->Array=pa;
( M u\\" B$ ]! F4 @$ c# r
}
\\" I' N5 W$ I! {9 _) H+ d: c\\" E, U
}
- i# K' y6 f* @# F* I; g
else: R8 f9 s0 o+ N
{
/ ], i/ [. H, H) o: e
pMatrix=new myMatrix; //创建矩阵对象$ @+ p6 f' `2 l# p1 }
if(!pMatrix) return NULL;
9 [4 V/ ~\\" `* ]8 w
pMatrix->Array=new double[k];7 t8 ~. V7 y1 v4 c3 g
if(!pMatrix->Array)9 i! B) ]1 o$ O6 ^\\" c5 V4 e6 f\\" A
{
; A) u$ n2 Q+ e, ^( n) s4 T
delete pMatrix;
' @$ U% c+ x\\" d, E7 p( ^
return NULL;
h& s+ t9 Q- J4 X2 Q% L; M2 h; D
}
p: g0 R+ L5 t' r [
if(InsertKey((char *)&pMatrix,-1,Matrix,pMatrix,DelMatrix,NULL,0,NowKey)) //将矩阵对象注册到Lu5 f\\" ]9 }\\" l% z% u0 E8 |
{
! U, E9 J, Z' Q5 s4 t% z
delete pMatrix;# U( c# j8 ]: B c8 ~\\" e- _\\" T
return NULL;, G; l& g4 Z\\" W- X\\" L\\" R% D/ x
}
! b' a! H\\" j* D5 A
}* g+ o, U0 s6 B4 H+ z; K( @
pMatrix->ArrayLen=k; pMatrix->Dim[0]=m; pMatrix->Dim[1]=n;
! G) _8 [3 K) |
return pMatrix;
}8 L5 Y/ A1 F( T/ X% P3 G$ G( p& e
LuData _stdcall OpMatrix(luINT mm,LuData *xx,void *hFor,int theOperator) //运算符重载函数，用于LockKey函数
1 ]. v/ |' ]: k, d c: y0 H; k, D( Q
{) h; S) E; y8 q# z0 E l( E
LuData a;
' f7 E2 T( r8 j* M3 I
myMatrix *pMatrix1,*pMatrix2,*pMatrix3;
5 [1 _ N; P: L% d
luVOID i,j,k,m,n,u,v;
7 u9 {! `% x5 p
double *pa,*pb,*pc;; a* r, d0 L/ J. N. C5 C. x! ]& B
luMessage pMessage;
( p8 W* m- k; F
wchar_t wchNum[32];
8 h6 Q& s3 o; z4 ?5 P2 F; y- l5 x
char chNum[32];
8 @, d* x2 H* J
a.BType=luStaData_nil; a.VType=luStaData_nil; a.x=0;
% P% Q; N8 q% c3 S7 b4 o- L2 E
switch(theOperator), H' K: F; m B) o( d4 U$ j- _
{
case 2: //重载运算符** |: `! U F& m7 ^2 {* [# f- {
pMatrix1=(myMatrix *)SearchKey((char *)&(xx->x),sizeof(luVOID),Matrix);+ r6 z& Z6 V6 x3 Q
pMatrix2=(myMatrix *)SearchKey((char *)&((xx+1)->x),sizeof(luVOID),Matrix);
9 y2 u; o& `; q2 B; r I# [& Z
if(!pMatrix1 || !pMatrix2) break; //对象句柄无效，不是矩阵3 w2 ]3 g% x6 E! v
if(pMatrix1->Dim[1]!=pMatrix2->Dim[0]) break; //维数不匹配
8 e/ I2 b- C+ y- P. E4 }9 I
pMatrix3=NewMatrix(pMatrix1->Dim[0],pMatrix2->Dim[1]); //生成新矩阵
' Y% K0 p\\" S( H9 ~. I) v$ C0 K
if(!pMatrix3) break;
) ~! w o$ H8 g
pa=pMatrix1->Array; pb=pMatrix2->Array; pc=pMatrix3->Array;9 o+ c z+ K9 L* N
m=pMatrix1->Dim[0]; n=pMatrix1->Dim[1]; k=pMatrix2->Dim[1];, u' X g# r, K( N) ]8 A2 F: q
for(i=0; i<m; i++) //矩阵乘 R3 j0 R! ]7 d2 n3 Y
{
% k2 \1 y% t! N6 q
for(j=0; j<k; j++)$ u4 v0 V7 o9 v
{8 G2 r6 {6 A' g0 A; b1 v) x8 H
u=i*k+j; pc[u]=0.0;: w8 j% M7 B7 c$ k& Z P+ G
for (v=0; v<n; v++)2 u8 \3 y, w7 r' S Q* \- M4 Z
{\\" j0 H* {1 A4 ?) d' p1 m2 B\\" k
pc[u]=pc[u]+pa[i*n+v]*pb[v*k+j];
}
( a& Z% `8 {2 x6 D( q5 m
}
8 r; e' _- u5 U( N( O
}
2 M6 w9 }0 p( P# v0 ^9 A! `7 l* T
FunReObj(hFor); //告诉Lu，返回一个动态对象. j& T( [# Q4 J# D# b! }6 R
a.BType=Matrix; a.VType=Matrix; a.x=0; *(luVOID *)&(a.x)=(luVOID)pMatrix3;* T& {1 u\\" G x
break;
) }. @$ p! w/ j B n
case 25: //重载运算符.*
# c, |9 @. l/ g! C
pMatrix1=(myMatrix *)SearchKey((char *)&(xx->x),sizeof(luVOID),Matrix);' u7 B9 D0 y9 F0 f0 ~( p
pMatrix2=(myMatrix *)SearchKey((char *)&((xx+1)->x),sizeof(luVOID),Matrix);
: @/ {+ `2 D d j. Y
if(!pMatrix1 || !pMatrix2) break; //对象句柄无效，不是矩阵% X/ }& Y, Q$ J. X\\" E$ l0 H
if(pMatrix1->Dim[0]!=pMatrix2->Dim[0] || pMatrix1->Dim[1]!=pMatrix2->Dim[1]) break; //维数不相同: } @4 B* _, H+ v& g
pMatrix3=NewMatrix(pMatrix1->Dim[0],pMatrix1->Dim[1]); //生成新矩阵# ]& w% z4 [( @% D8 N+ i
if(!pMatrix3) break;5 i% i8 V* U. [0 X' B\\" B% f
for(i=0;i<pMatrix1->ArrayLen;i++) pMatrix3->Array[i]=pMatrix1->Array[i]*pMatrix2->Array[i]; //矩阵点乘- _; q6 L: m0 z/ p, {! ?
FunReObj(hFor); //告诉Lu，返回一个动态对象
a.BType=Matrix; a.VType=Matrix; a.x=0; *(luVOID *)&(a.x)=(luVOID)pMatrix3;
, [& B& }+ L3 Y% D4 o7 k
break;# h# B7 r# u# Z8 z! x! `; E
case 46: //重载函数new
r+ d% {. }5 r# w! n
if(mm<2) break;9 p3 x' R# s3 S7 H
if((xx+1)->x<1 || (xx+2)->x<1 || (xx+1)->BType!=luStaData_int64 || (xx+2)->BType!=luStaData_int64) break;
5 z& B5 X. W$ m! x
pMatrix3=NewMatrix((luVOID)(xx+1)->x,(luVOID)(xx+2)->x);//生成新矩阵
% ]! y' D( t* E F$ }
if(!pMatrix3) break;( E* F8 J! W0 y9 P0 d# N\\" V+ Y
for(j=0,i=3;i<=mm;i++,j++) //赋初值# U* W- Z5 Z* n
{ y4 @. f0 q\\" B1 P8 p% h
if(j>=pMatrix3->ArrayLen) break; z0 v8 D6 m6 U
if((xx+i)->BType!=luStaData_double) break; //只接受实数参数
& i0 q& a4 D3 ?- _: T; M
pMatrix3->Array[j]=*(double *)&((xx+i)->x);
) t Z; I$ i5 g, @# d
}
/ X( U* H \% J- {
FunReObj(hFor); //告诉Lu，返回一个动态对象
$ y/ |\\" ]* X6 }; [. ?' b* z
a.BType=Matrix; a.VType=Matrix; a.x=0; *(luVOID *)&(a.x)=(luVOID)pMatrix3;; N& `+ x, E( Q6 l6 y7 B
break;
) e6 [% Q- l% V! s
case 49: //重载函数o `/ q. y6 @% E/ E6 ?\\" _: } n
pMessage=(luMessage)SearchKey("\0\0\0\0",sizeof(luVOID),luPubKey_User);
' J- Y7 ~. ?7 u( O
if(!pMessage) break;8 B) m( G! C( z) P& j
pMatrix1=(myMatrix *)SearchKey((char *)&(xx->x),sizeof(luVOID),Matrix);* u0 s4 I; S7 a4 b3 j2 s! g5 r
if(!pMatrix1) break; //对象句柄无效，不是矩阵
- S2 \) O/ C2 F* G: q9 r' m/ h s
pa=pMatrix1->Array;
- `1 f; S( z4 V! Y% O: @
m=pMatrix1->Dim[0]; n=pMatrix1->Dim[1]; k=0;$ |* g' d; o# z) h. h3 A
for(i=0; i<m; i++) //输出矩阵
: L3 I4 Q( G6 S( B
{8 {$ P3 @! W8 x5 D4 F3 B
pMessage(L"\r\n"); k+=2;
/ M% A# f6 G0 |# ?; W6 {
for(j=0; j<n; j++)5 Y# v' u* i8 l7 C/ \3 H. _' p
{
; \! Y4 y( ]2 X, v- p5 }
_gcvt_s(chNum,pa[i*n+j],16);9 Z. x* L c# r
for(u=0;chNum[u];u++) {wchNum[u]=chNum[u]; k++;}
$ e9 f/ w\\" v, ?, s0 B\\" D
wchNum[u]='\0';
8 \5 I. W3 I! W' {1 x0 I
pMessage(wchNum); pMessage(L" "); k+=2;
7 c4 s z9 O: E& n O/ `; ^0 Q
}
, C% G: x, Y X; @
}. [: g& D/ @. _7 K. N+ m( t- J2 S
pMessage(L"\r\n"); k+=2;% h* I0 r: }. o* F7 B2 @
a.BType=luStaData_int64; a.VType=luStaData_int64; a.x=k; //按函数o的要求，返回输出的字符总数
! u' f$ Q( x) r5 i$ O+ S7 n: |
break;
( y, O3 H5 Y- d# ] S
default:! [* q1 [* J) F- `! T, c. W
break;( t, b$ C% s) t0 [
}% A5 I6 v6 d# J6 W
return a;
) t) |/ Q: e; L! G( g
}
; K8 i, _) x7 ?: f) e
void main(void)
' R) h\\" Y4 Y+ r. m& x
{* Z5 \. \' X8 @\\" ~\\" k
void *hFor; //表达式句柄+ U/ W! ~: V1 ^8 \
luINT nPara; //存放表达式的自变量个数
3 W5 k. l2 J! j7 M+ f% E5 c2 x$ \0 @$ x
LuData *pPara; //存放输入自变量的数组指针8 {1 _! }7 L$ l
luINT ErrBegin,ErrEnd; //表达式编译出错的初始位置和结束位置/ P6 p1 W' ?, d) z& x
int ErrCode; //错误代码2 W% S9 C* Z+ R, I$ r( d) y. s
void *v;
( t( T) H, c# W9 p$ ~ 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.]}";//字符串表达式，矩阵乘
4 D+ |/ R; d+ \7 k* y
//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.]}";//字符串表达式，矩阵点乘
- f3 h9 b0 a\\" k8 t- x% x3 R
LuData Val;
( N6 V' d+ _: {- M\\" z
if(!InitLu()) return; //初始化Lu. q' T X2 N; x5 ~ `. _3 D1 d
while(LockKey(Matrix,DelMatrix,OpMatrix)){Matrix--;} //锁定一个键，用于存储矩阵扩展类型2 g! i% L: a& [# ]2 a
/ j# Q M4 c- N4 r0 {/ D, R3 o
Val.BType=luStaData_int64; Val.VType=luStaData_int64; Val.x=Matrix; //定义整数常量$ `% l4 r5 |7 q; k& G |
SetConst(L"matrix",&Val); //设置整数常量
; m p8 k# Z& ^) u
InsertKey("\0\0\0\0",4,luPubKey_User,LuMessage,NULL,NULL,1,v); //使Lu运行时可输出函数信息3 D0 \8 Y1 A' H5 L! Q
wcout.imbue(locale("chs")); //设置输出的locale为中文
/ W: X4 A# ~' E; X9 M# d- \
0 j4 ~, P! v( G
ErrCode=LuCom(ForStr,0,0,0,hFor,nPara,pPara,ErrBegin,ErrEnd); //编译表达式
7 n- x# J c2 C4 \8 s
if(ErrCode)+ O% D' Y, D, P' D- B' I2 t\\" n
{% d, H! U) d9 P4 }' @, d
wcout<<L"表达式有错误！错误代码："<<ErrCode<<endl;+ m: A7 V9 C r6 W- W; o% d7 Q- m
}9 u, V) c9 J3 L4 G$ }0 F
else
3 T; ]% r0 Z+ m* h! r
{
# _# m+ p/ F3 Q; n0 ?
LuCal(hFor,pPara); //计算表达式的值- J9 n, L* b3 i. D! p! q6 y
}, M2 [2 U$ `8 |9 }% u: X
LockKey(Matrix,NULL,OpMatrix);//解锁键Matrix，本例中，该函数可以不用: _3 V% c$ v* d! E& `3 O& H) S
FreeLu(); //释放Lu
\\" `7 f6 N( q0 }
}

#include <windows.h>  E! u+ g  h6 u2 C7 [

#include <iostream>9 B* \( A6 [( A) ^) R$ X; {, E9 f

#include <math.h>5 G. a4 H6 L8 d6 @- ^0 q* R* q

#include "lu32.h"# D# D, w% @6 J1 ^4 V

#pragma comment( lib, "lu32.lib" )# q: f; U1 m, G2 l' u$ O

using namespace std;8 T6 J; u+ M' a. y- ~' n9 O

//自定义矩阵/ ^9 e; r2 Z  Q8 a  k1 R4 r' O

class myMatrix 
3 N' k$ a1 W1 ]& Y
{9 m1 c! z. y6 j3 q6 R

public:8 |% ]+ H6 i  p! }, J0 U: T2 _

double *Array;        //数据缓冲区7 W* ]1 m  I7 v% J( k

luVOID ArrayLen;        //数据缓冲区长度9 P\\" k. s5 n. H

luVOID Dim[2];        //矩阵维数4 ~! u! t9 u; L. R/ S6 u

myMatrix(){Array=NULL; ArrayLen=0; Dim[0]=0; Dim[1]=0;}- k2 {9 t7 q. z  l! P9 v7 R. E

~myMatrix()$ u! z# r0 y+ L  }7 A; d4 ^

{+ m  x8 B6 Y7 o' B* f

if(Array) delete[] Array; 
' `7 T3 f+ |8 M; p( P- Q
        }( c0 |) F& ~2 p9 J; Y

}; 
) }' h, K0 e/ C2 \0 c. v
luKEY Matrix=-1000;        //标识矩阵类型，最终的Matrix由LockKey决定\\" |0 }$ E- M& h. b8 z7 T% g! k- O\\" }$ Y

void _stdcall LuMessage(wchar_t *pch)//输出动态库信息，该函数注册到Lu，由Lu二级函数调用 . E% N0 O. x6 l& d! D* s

{2 }2 C\\" e. Q0 O) P* A7 U: z

wcout<<pch;. Q1 l5 y& t. y8 x$ X

}3 O0 A5 M9 X\\" K  l+ X: [

void _stdcall DelMatrix(void *me)        //用于LockKey函数及InsertKey函数，使Lu能自动销毁myMatrix对象 
, W  Q9 N/ y5 y0 s# D' L
{ 
5 N# |- {\\" i! ]3 Q3 n
        delete (myMatrix *)me;$ m+ B5 v\\" W( M, g+ R5 D

} 
& o. C0 I: T$ S' q& s7 n; H. f
myMatrix * _stdcall NewMatrix(luVOID m,luVOID n)        //生成一个myMatrix对象0 q\\" o/ ^7 t; G6 [8 @- F1 F1 z4 |

{ 
: q, ^5 l\\" M3 Z4 D7 @% s
        myMatrix *pMatrix; 
: k\\" t3 V. Z8 K6 z3 E' W) d- i  \! W
        luVOID k;, P! o, V2 x  f4 M/ \2 s* |9 Q

double *pa;* N8 @7 ^: x( K& z4 H$ i1 W

char keyname[sizeof(luVOID)];: e' a+ {4 D. R2 w\\" E, d: l+ c

void *NowKey;' V8 ~* Z, }5 E

k=m*n; 
& W: Y$ f8 M9 J! ]
        pMatrix=(myMatrix *)GetBufObj(Matrix,keyname);//先尝试从缓冲区中获取一个矩阵对象 
6 Y4 \; i; M* Y0 x
        if(pMatrix) 
$ r; U& V1 B\\" |* k% K5 x* o, V+ |
        {& `5 X* z1 [9 K/ B& `  y7 u( J

if(pMatrix->ArrayLen!=k)        //重置矩阵的大小 
* e. z; L4 F* B) J
                {' P4 ^5 C  ^$ q- j3 p

pa=new double[k];! B% z! v. A: @: o  {  ^4 x

if(!pa) 
4 G1 T& q6 w& r7 ^1 m
                        { 
: W3 m) u: u4 |, N, U$ w
                                DeleteKey(keyname,sizeof(luVOID),Matrix,DelMatrix,1);        //将矩阵对象放回缓冲区 
5 x# W  v' Z* F# D
                                return NULL;  c, M2 f6 Y1 _. D9 x

}4 d. ]! ^; {9 K( p) \\\" ?

delete[] pMatrix->Array;& R! e& _# T$ c' Z$ z0 e) B0 j8 z

pMatrix->Array=pa; 
( M  u\\" B$ ]! F4 @$ c# r
                } 
\\" I' N5 W$ I! {9 _) H+ d: c\\" E, U
        } 
- i# K' y6 f* @# F* I; g
        else: R8 f9 s0 o+ N

{ 
/ ], i/ [. H, H) o: e
                pMatrix=new myMatrix;        //创建矩阵对象$ @+ p6 f' `2 l# p1 }

if(!pMatrix) return NULL; 
9 [4 V/ ~\\" `* ]8 w
                pMatrix->Array=new double[k];7 t8 ~. V7 y1 v4 c3 g

if(!pMatrix->Array)9 i! B) ]1 o$ O6 ^\\" c5 V4 e6 f\\" A

{ 
; A) u$ n2 Q+ e, ^( n) s4 T
                        delete pMatrix; 
' @$ U% c+ x\\" d, E7 p( ^
                        return NULL; 
  h& s+ t9 Q- J4 X2 Q% L; M2 h; D
                } 
  p: g0 R+ L5 t' r  [
                if(InsertKey((char *)&pMatrix,-1,Matrix,pMatrix,DelMatrix,NULL,0,NowKey))        //将矩阵对象注册到Lu5 f\\" ]9 }\\" l% z% u0 E8 |

{ 
! U, E9 J, Z' Q5 s4 t% z
                        delete pMatrix;# U( c# j8 ]: B  c8 ~\\" e- _\\" T

return NULL;, G; l& g4 Z\\" W- X\\" L\\" R% D/ x

} 
! b' a! H\\" j* D5 A
        }* g+ o, U0 s6 B4 H+ z; K( @

pMatrix->ArrayLen=k; pMatrix->Dim[0]=m; pMatrix->Dim[1]=n; 
! G) _8 [3 K) |
        return pMatrix; 
4 v; H- D6 g; Y& V) {5 ]2 Q0 t\\" k8 R4 U
}8 L5 Y/ A1 F( T/ X% P3 G$ G( p& e

LuData _stdcall OpMatrix(luINT mm,LuData *xx,void *hFor,int theOperator)        //运算符重载函数，用于LockKey函数 
1 ]. v/ |' ]: k, d  c: y0 H; k, D( Q
{) h; S) E; y8 q# z0 E  l( E

LuData a; 
' f7 E2 T( r8 j* M3 I
        myMatrix *pMatrix1,*pMatrix2,*pMatrix3; 
5 [1 _  N; P: L% d
        luVOID i,j,k,m,n,u,v; 
7 u9 {! `% x5 p
        double *pa,*pb,*pc;; a* r, d0 L/ J. N. C5 C. x! ]& B

luMessage pMessage; 
( p8 W* m- k; F
        wchar_t wchNum[32]; 
8 h6 Q& s3 o; z4 ?5 P2 F; y- l5 x
        char chNum[32]; 
8 @, d* x2 H* J
        a.BType=luStaData_nil; a.VType=luStaData_nil; a.x=0; 
% P% Q; N8 q% c3 S7 b4 o- L2 E
        switch(theOperator), H' K: F; m  B) o( d4 U$ j- _

{ 
+ I* N1 o\\" |, Q  W' N) ~  o  i4 S
        case 2:        //重载运算符** |: `! U  F& m7 ^2 {* [# f- {

pMatrix1=(myMatrix *)SearchKey((char *)&(xx->x),sizeof(luVOID),Matrix);+ r6 z& Z6 V6 x3 Q

pMatrix2=(myMatrix *)SearchKey((char *)&((xx+1)->x),sizeof(luVOID),Matrix); 
9 y2 u; o& `; q2 B; r  I# [& Z
                if(!pMatrix1 || !pMatrix2) break;        //对象句柄无效，不是矩阵3 w2 ]3 g% x6 E! v

if(pMatrix1->Dim[1]!=pMatrix2->Dim[0]) break;        //维数不匹配 
8 e/ I2 b- C+ y- P. E4 }9 I
                pMatrix3=NewMatrix(pMatrix1->Dim[0],pMatrix2->Dim[1]);        //生成新矩阵 
' Y% K0 p\\" S( H9 ~. I) v$ C0 K
                if(!pMatrix3) break; 
) ~! w  o$ H8 g
                pa=pMatrix1->Array; pb=pMatrix2->Array; pc=pMatrix3->Array;9 o+ c  z+ K9 L* N

m=pMatrix1->Dim[0]; n=pMatrix1->Dim[1]; k=pMatrix2->Dim[1];, u' X  g# r, K( N) ]8 A2 F: q

for(i=0; i<m; i++)        //矩阵乘  R3 j0 R! ]7 d2 n3 Y

{ 
% k2 \1 y% t! N6 q
                        for(j=0; j<k; j++)$ u4 v0 V7 o9 v

{8 G2 r6 {6 A' g0 A; b1 v) x8 H

u=i*k+j; pc[u]=0.0;: w8 j% M7 B7 c$ k& Z  P+ G

for (v=0; v<n; v++)2 u8 \3 y, w7 r' S  Q* \- M4 Z

{\\" j0 H* {1 A4 ?) d' p1 m2 B\\" k

pc[u]=pc[u]+pa[i*n+v]*pb[v*k+j]; 
+ g. ^: J4 s+ k- r6 H$ Z: `\\" N\\" @\\" d
                                } 
( a& Z% `8 {2 x6 D( q5 m
                        } 
8 r; e' _- u5 U( N( O
                } 
2 M6 w9 }0 p( P# v0 ^9 A! `7 l* T
                FunReObj(hFor);        //告诉Lu，返回一个动态对象. j& T( [# Q4 J# D# b! }6 R

a.BType=Matrix; a.VType=Matrix; a.x=0; *(luVOID *)&(a.x)=(luVOID)pMatrix3;* T& {1 u\\" G  x

break; 
) }. @$ p! w/ j  B  n
        case 25:        //重载运算符.* 
# c, |9 @. l/ g! C
                pMatrix1=(myMatrix *)SearchKey((char *)&(xx->x),sizeof(luVOID),Matrix);' u7 B9 D0 y9 F0 f0 ~( p

pMatrix2=(myMatrix *)SearchKey((char *)&((xx+1)->x),sizeof(luVOID),Matrix); 
: @/ {+ `2 D  d  j. Y
                if(!pMatrix1 || !pMatrix2) break;        //对象句柄无效，不是矩阵% X/ }& Y, Q$ J. X\\" E$ l0 H

if(pMatrix1->Dim[0]!=pMatrix2->Dim[0] || pMatrix1->Dim[1]!=pMatrix2->Dim[1]) break;        //维数不相同: }  @4 B* _, H+ v& g

pMatrix3=NewMatrix(pMatrix1->Dim[0],pMatrix1->Dim[1]);        //生成新矩阵# ]& w% z4 [( @% D8 N+ i

if(!pMatrix3) break;5 i% i8 V* U. [0 X' B\\" B% f

for(i=0;i<pMatrix1->ArrayLen;i++) pMatrix3->Array[i]=pMatrix1->Array[i]*pMatrix2->Array[i];        //矩阵点乘- _; q6 L: m0 z/ p, {! ?

FunReObj(hFor);        //告诉Lu，返回一个动态对象 
  A1 v5 ?8 p# J- }7 H3 _  }\\" W\\" ]
                a.BType=Matrix; a.VType=Matrix; a.x=0; *(luVOID *)&(a.x)=(luVOID)pMatrix3; 
, [& B& }+ L3 Y% D4 o7 k
                break;# h# B7 r# u# Z8 z! x! `; E

case 46:        //重载函数new 
  r+ d% {. }5 r# w! n
                if(mm<2) break;9 p3 x' R# s3 S7 H

if((xx+1)->x<1 || (xx+2)->x<1 || (xx+1)->BType!=luStaData_int64 || (xx+2)->BType!=luStaData_int64) break; 
5 z& B5 X. W$ m! x
                pMatrix3=NewMatrix((luVOID)(xx+1)->x,(luVOID)(xx+2)->x);//生成新矩阵 
% ]! y' D( t* E  F$ }
                if(!pMatrix3) break;( E* F8 J! W0 y9 P0 d# N\\" V+ Y

for(j=0,i=3;i<=mm;i++,j++)        //赋初值# U* W- Z5 Z* n

{  y4 @. f0 q\\" B1 P8 p% h

if(j>=pMatrix3->ArrayLen) break;  z0 v8 D6 m6 U

if((xx+i)->BType!=luStaData_double) break;        //只接受实数参数 
& i0 q& a4 D3 ?- _: T; M
                        pMatrix3->Array[j]=*(double *)&((xx+i)->x); 
) t  Z; I$ i5 g, @# d
                } 
/ X( U* H  \% J- {
                FunReObj(hFor);        //告诉Lu，返回一个动态对象 
$ y/ |\\" ]* X6 }; [. ?' b* z
                a.BType=Matrix; a.VType=Matrix; a.x=0; *(luVOID *)&(a.x)=(luVOID)pMatrix3;; N& `+ x, E( Q6 l6 y7 B

break; 
) e6 [% Q- l% V! s
        case 49:        //重载函数o  `/ q. y6 @% E/ E6 ?\\" _: }  n

pMessage=(luMessage)SearchKey("\0\0\0\0",sizeof(luVOID),luPubKey_User); 
' J- Y7 ~. ?7 u( O
                if(!pMessage) break;8 B) m( G! C( z) P& j

pMatrix1=(myMatrix *)SearchKey((char *)&(xx->x),sizeof(luVOID),Matrix);* u0 s4 I; S7 a4 b3 j2 s! g5 r

if(!pMatrix1) break;        //对象句柄无效，不是矩阵 
- S2 \) O/ C2 F* G: q9 r' m/ h  s
                pa=pMatrix1->Array; 
- `1 f; S( z4 V! Y% O: @
                m=pMatrix1->Dim[0]; n=pMatrix1->Dim[1]; k=0;$ |* g' d; o# z) h. h3 A

for(i=0; i<m; i++)        //输出矩阵 
: L3 I4 Q( G6 S( B
                {8 {$ P3 @! W8 x5 D4 F3 B

pMessage(L"\r\n"); k+=2; 
/ M% A# f6 G0 |# ?; W6 {
                        for(j=0; j<n; j++)5 Y# v' u* i8 l7 C/ \3 H. _' p

{ 
; \! Y4 y( ]2 X, v- p5 }
                                _gcvt_s(chNum,pa[i*n+j],16);9 Z. x* L  c# r

for(u=0;chNum[u];u++) {wchNum[u]=chNum[u]; k++;} 
$ e9 f/ w\\" v, ?, s0 B\\" D
                                wchNum[u]='\0'; 
8 \5 I. W3 I! W' {1 x0 I
                                pMessage(wchNum); pMessage(L"  "); k+=2; 
7 c4 s  z9 O: E& n  O/ `; ^0 Q
                        } 
, C% G: x, Y  X; @
                }. [: g& D/ @. _7 K. N+ m( t- J2 S

pMessage(L"\r\n"); k+=2;% h* I0 r: }. o* F7 B2 @

a.BType=luStaData_int64; a.VType=luStaData_int64; a.x=k;        //按函数o的要求，返回输出的字符总数 
! u' f$ Q( x) r5 i$ O+ S7 n: |
                break; 
( y, O3 H5 Y- d# ]  S
        default:! [* q1 [* J) F- `! T, c. W

break;( t, b$ C% s) t0 [

}% A5 I6 v6 d# J6 W

return a; 
) t) |/ Q: e; L! G( g
} 
; K8 i, _) x7 ?: f) e
void main(void) 
' R) h\\" Y4 Y+ r. m& x
{* Z5 \. \' X8 @\\" ~\\" k

void *hFor;                //表达式句柄+ U/ W! ~: V1 ^8 \

luINT nPara;                //存放表达式的自变量个数 
3 W5 k. l2 J! j7 M+ f% E5 c2 x$ \0 @$ x
        LuData *pPara;                //存放输入自变量的数组指针8 {1 _! }7 L$ l

luINT ErrBegin,ErrEnd;        //表达式编译出错的初始位置和结束位置/ P6 p1 W' ?, d) z& x

int ErrCode;                //错误代码2 W% S9 C* Z+ R, I$ r( d) y. s

void *v; 
( t( T) H, c# W9 p$ ~  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.]}";//字符串表达式，矩阵乘 
4 D+ |/ R; d+ \7 k* y
        //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.]}";//字符串表达式，矩阵点乘 
- f3 h9 b0 a\\" k8 t- x% x3 R
        LuData Val; 
( N6 V' d+ _: {- M\\" z
        if(!InitLu()) return;        //初始化Lu. q' T  X2 N; x5 ~  `. _3 D1 d

while(LockKey(Matrix,DelMatrix,OpMatrix)){Matrix--;}        //锁定一个键，用于存储矩阵扩展类型2 g! i% L: a& [# ]2 a

/ j# Q  M4 c- N4 r0 {/ D, R3 o

Val.BType=luStaData_int64; Val.VType=luStaData_int64; Val.x=Matrix;        //定义整数常量$ `% l4 r5 |7 q; k& G  |

SetConst(L"matrix",&Val);        //设置整数常量 
; m  p8 k# Z& ^) u
        InsertKey("\0\0\0\0",4,luPubKey_User,LuMessage,NULL,NULL,1,v); //使Lu运行时可输出函数信息3 D0 \8 Y1 A' H5 L! Q

wcout.imbue(locale("chs"));        //设置输出的locale为中文 
/ W: X4 A# ~' E; X9 M# d- \
   
0 j4 ~, P! v( G
        ErrCode=LuCom(ForStr,0,0,0,hFor,nPara,pPara,ErrBegin,ErrEnd); //编译表达式 
7 n- x# J  c2 C4 \8 s
        if(ErrCode)+ O% D' Y, D, P' D- B' I2 t\\" n

{% d, H! U) d9 P4 }' @, d

wcout<<L"表达式有错误！错误代码："<<ErrCode<<endl;+ m: A7 V9 C  r6 W- W; o% d7 Q- m

}9 u, V) c9 J3 L4 G$ }0 F

else 
3 T; ]% r0 Z+ m* h! r
        { 
# _# m+ p/ F3 Q; n0 ?
                LuCal(hFor,pPara);        //计算表达式的值- J9 n, L* b3 i. D! p! q6 y

}, M2 [2 U$ `8 |9 }% u: X

LockKey(Matrix,NULL,OpMatrix);//解锁键Matrix，本例中，该函数可以不用: _3 V% c$ v* d! E& `3 O& H) S

FreeLu();                        //释放Lu 
\\" `7 f6 N( q0 }
}

习题：

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

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

main(:a,b,c,d,t,i)=
I9 V* B& v& `6 k\" z8 k
a=new[matrix,2,2: 1.,2.,2.,1.],
3 B# f V% e- p* @
b=new[matrix,2,2: 2.,1.,1.,2.],
# b: v5 p# _- a& |$ C
c=new[matrix,2,2: 2/3.,-1/3.,-1/3.,2/3.],
\" P9 q& o$ k7 g& x$ a; ^
t=clock(),5 [, X2 O) W$ P' K6 l\" z; H/ n, _
d=a*b, i=0, while{i<1000000, d=d*c*b, i++},9 Z. U1 `9 W0 ~; h
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\"}";//字符串表达式

复制代码

结果：