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

查看: 8987|回复: 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>
$ ]\\" h( M5 z* w% ~* z0 d
#include <iostream>
4 b6 H4 p* Q U( N
#include <math.h>3 \+ j0 z, E: G# \0 ^! z5 J
#include "lu32.h"
, F\\" k% ~- B* ?
#pragma comment( lib, "lu32.lib" )
8 Q6 h6 ^, |4 I+ z$ G
using namespace std;
! r' z+ R\\" A2 h9 x
//自定义矩阵' f; q' Z @: o' I2 Q
class myMatrix) h/ R: n% Y& D1 h0 o
{6 N& j) o( J5 d) P5 f8 l
public:
9 N2 {8 [7 @8 @
double *Array; //数据缓冲区
' ^4 j. ?) B6 f* j# ~/ U/ ]- F
luVOID ArrayLen; //数据缓冲区长度\\" Z' V\\" ~, B* R* C% @( x7 {\\" ?
luVOID Dim[2]; //矩阵维数. M% F\\" p$ H$ F& E
myMatrix(){Array=NULL; ArrayLen=0; Dim[0]=0; Dim[1]=0;}' d2 D; @ b, A8 D' J' A
~myMatrix()
/ d- e! e5 Q8 a: ~
{
\\" O! X& ~\\" M1 h3 Y! f' F( Z
if(Array) delete[] Array;
- m. A; t: |& \7 N( h2 {
}
& M7 K6 c\\" x6 F/ v4 ^
};
\\" x( C$ b# l! H% }/ e
luKEY Matrix=-1000; //标识矩阵类型，最终的Matrix由LockKey决定! [- x$ f\\" f: q* S+ ]8 g' P
void _stdcall LuMessage(wchar_t *pch)//输出动态库信息，该函数注册到Lu，由Lu二级函数调用
2 U& O\\" i- Y; f3 J
{: B9 `5 J/ G# u2 t! H+ R2 X3 D
wcout<<pch;
& \\\" M+ Q& T1 W
}- @* K% n: Z- Y$ j$ ~( b6 f ?
void _stdcall DelMatrix(void *me) //用于LockKey函数及InsertKey函数，使Lu能自动销毁myMatrix对象\\" q$ ~\\" C8 V- Q
{
- V) D\\" j/ q) |( h
delete (myMatrix *)me;
8 w$ e3 B r7 J8 @0 V
} U& ~0 ?5 n- c\\" b: S\\" k- R\\" ?6 H- g
myMatrix * _stdcall NewMatrix(luVOID m,luVOID n) //生成一个myMatrix对象! u; ]$ \; @\\" D% w2 B
{
# S- [/ U, ]' v& i
myMatrix *pMatrix;4 o( M+ m5 K( T. o
luVOID k;
% E, X% ?$ ~% ]: ~) }& m
double *pa;
$ s* n7 L: e, L% r
char keyname[sizeof(luVOID)];
+ |! F, B9 Y. l* l q* u5 O
void *NowKey;0 v! ], p& b4 z! l% s, y! f( q\\" z
k=m*n;6 i\\" q3 d# g% I& O# x7 w% E d
pMatrix=(myMatrix *)GetBufObj(Matrix,keyname);//先尝试从缓冲区中获取一个矩阵对象' ~5 c$ k! J x& g\\" T
if(pMatrix)
' l$ b$ K5 _9 V0 O8 a, y
{
. x' ~6 n; N7 K$ Q; ]1 |
if(pMatrix->ArrayLen!=k) //重置矩阵的大小! x( ]3 X9 Y! ?2 m: g3 w
{6 j, {\\" d% G/ q8 q
pa=new double[k];! y/ i4 P5 o- _
if(!pa)* i4 N& A4 S\\" g% _
{
a- S: q, S2 n+ p
DeleteKey(keyname,sizeof(luVOID),Matrix,DelMatrix,1); //将矩阵对象放回缓冲区
- E) s' h6 V; s8 E\\" B
return NULL;
/ A7 F9 N% J; X+ e( | ^
}% z! h\\" [ a. S* [
delete[] pMatrix->Array;
$ ^+ r( L8 ?& i# |$ W
pMatrix->Array=pa;- q$ X! H0 U \8 \
}
\\" e! h\\" L r9 [8 D T1 s
}+ i8 n$ b7 h) z* u! A9 v* F
else1 O3 P3 L& g\\" `) H( m; M9 `
{6 y8 Y5 H2 ?' k
pMatrix=new myMatrix; //创建矩阵对象
2 a6 T G8 x# n; [3 a
if(!pMatrix) return NULL;
6 V6 G7 n$ d8 P, ~9 @8 |: @
pMatrix->Array=new double[k];6 V8 ] F, I) e( l: W9 c\\" d8 [
if(!pMatrix->Array)9 S! u' a- z3 }4 @! {3 Q
{; |$ e( f6 g1 E H, }
delete pMatrix;5 g# \' b& F0 E' u) j/ M3 _$ ~
return NULL;
$ c1 V1 s D$ w! s
}\\" C- y' `8 D g- z+ ~( n
if(InsertKey((char *)&pMatrix,-1,Matrix,pMatrix,DelMatrix,NULL,0,NowKey)) //将矩阵对象注册到Lu$ w ]! g( Z: R1 ~8 ?) z
{
K) |. _0 v$ I& {! `
delete pMatrix;: [: K% f% \& u/ F; c& q
return NULL;
( U: }, H0 o: b7 m
}
( H: q8 F. B/ H2 Y( [6 ]0 J
}
\\" ~: c8 Q% U# r! @
pMatrix->ArrayLen=k; pMatrix->Dim[0]=m; pMatrix->Dim[1]=n;( C2 t! m0 a5 \3 _6 @
return pMatrix;+ T( I9 r0 T2 A$ f' X
}. l+ d- \' K7 n& @% C$ o
LuData _stdcall OpMatrix(luINT mm,LuData *xx,void *hFor,int theOperator) //运算符重载函数，用于LockKey函数& R& f5 l2 E5 h& }5 ^) g$ O
{
' J) }8 H5 I/ E; E. e/ [! K, D/ |! D
LuData a;
6 l# }7 m% E/ M0 Y) N4 c( P/ P
myMatrix *pMatrix1,*pMatrix2,*pMatrix3;
, H% Q v- J6 l/ j }$ G\\" i
luVOID i,j,k,m,n,u,v;
0 Q* x% d2 Z0 Y( Y4 c% p
double *pa,*pb,*pc;
, v: `5 H6 l% s8 l& V5 ?4 W8 i$ K+ S
luMessage pMessage;
. L9 Y! I% h) u
wchar_t wchNum[32];) j9 o+ W& E7 L& }
char chNum[32];/ J# L& G5 h! h! `, I' R9 [\\" s
a.BType=luStaData_nil; a.VType=luStaData_nil; a.x=0;
) h( w5 X6 E1 O& h, J\\" h) S
switch(theOperator)
) h\\" H# E+ ^; E\\" m4 f0 a1 ~3 V5 d
{
3 v: J# y# p/ K3 e; u; ?3 Y
case 2: //重载运算符*/ F9 x2 K\\" d6 |3 h8 l$ v
pMatrix1=(myMatrix *)SearchKey((char *)&(xx->x),sizeof(luVOID),Matrix);& d3 F: F- v0 @1 P8 _) v% U/ W& c# J
pMatrix2=(myMatrix *)SearchKey((char *)&((xx+1)->x),sizeof(luVOID),Matrix);
* ^! T J U/ r% ]
if(!pMatrix1 || !pMatrix2) break; //对象句柄无效，不是矩阵, t E7 i\\" a. K; Q
if(pMatrix1->Dim[1]!=pMatrix2->Dim[0]) break; //维数不匹配
0 M$ i! O: _1 Y p3 t
pMatrix3=NewMatrix(pMatrix1->Dim[0],pMatrix2->Dim[1]); //生成新矩阵
8 J/ g8 P. z5 p0 n! F F
if(!pMatrix3) break; k6 x, A% h\\" m/ [
pa=pMatrix1->Array; pb=pMatrix2->Array; pc=pMatrix3->Array;
! f/ n6 g5 }' _1 Q, Y. q( L2 B
m=pMatrix1->Dim[0]; n=pMatrix1->Dim[1]; k=pMatrix2->Dim[1];
1 \0 @\\" u) {( ?6 @. @\\" I9 t* h
for(i=0; i<m; i++) //矩阵乘
% b. R+ s4 k a' T\\" E
{! F6 ~1 L6 W' m% _5 r
for(j=0; j<k; j++)+ g- L' [\\" u: j V- y% Y
{$ w* Y' `& b% _* v* m& n' R: f
u=i*k+j; pc[u]=0.0;4 d0 o2 M! h% Q* w# `
for (v=0; v<n; v++)3 j\\" n& [2 b1 Q$ f
{0 C$ F& T* I: a8 l, }
pc[u]=pc[u]+pa[i*n+v]*pb[v*k+j];% }% H, J g6 h! x8 X
}
' S. `% c) z: k3 O
}
+ n' |2 N0 e! m) V
}$ z9 W( H+ V8 }. b- ?7 _
FunReObj(hFor); //告诉Lu，返回一个动态对象# @: D' k8 `/ H# R0 @: F; b7 {+ [( g
a.BType=Matrix; a.VType=Matrix; a.x=0; *(luVOID *)&(a.x)=(luVOID)pMatrix3;# H, H! Q' Q0 B( Y3 c
break; ]/ T) ?) ^8 C% D8 ?8 o8 W5 B, E
case 25: //重载运算符.*
/ T9 P P5 z' A6 s- R
pMatrix1=(myMatrix *)SearchKey((char *)&(xx->x),sizeof(luVOID),Matrix);7 |* ^* Z0 K0 t- x0 m+ z
pMatrix2=(myMatrix *)SearchKey((char *)&((xx+1)->x),sizeof(luVOID),Matrix);
. U3 f7 [. |4 e8 D' c
if(!pMatrix1 || !pMatrix2) break; //对象句柄无效，不是矩阵+ B. H# ]9 F% o
if(pMatrix1->Dim[0]!=pMatrix2->Dim[0] || pMatrix1->Dim[1]!=pMatrix2->Dim[1]) break; //维数不相同 M ~7 W0 O+ J, ]; U# R\\" ]
pMatrix3=NewMatrix(pMatrix1->Dim[0],pMatrix1->Dim[1]); //生成新矩阵3 z8 o8 w q1 J; |. \; C% `
if(!pMatrix3) break;
7 \6 O% H+ y' [, O/ {
for(i=0;i<pMatrix1->ArrayLen;i++) pMatrix3->Array[i]=pMatrix1->Array[i]*pMatrix2->Array[i]; //矩阵点乘6 O1 {; V& h5 e4 ?+ w9 k: o. \
FunReObj(hFor); //告诉Lu，返回一个动态对象
8 f+ c: _2 H4 O6 I, M7 f: d
a.BType=Matrix; a.VType=Matrix; a.x=0; *(luVOID *)&(a.x)=(luVOID)pMatrix3;* f2 Z6 C% T6 D: ^! O; U. y, |' i8 `
break;
. Q5 w' w0 [* r0 u
case 46: //重载函数new
( n& a8 O4 z/ B
if(mm<2) break;
# a$ A9 Y* X2 u3 F/ R$ |$ G
if((xx+1)->x<1 || (xx+2)->x<1 || (xx+1)->BType!=luStaData_int64 || (xx+2)->BType!=luStaData_int64) break;
+ D0 W! D. l1 _& q
pMatrix3=NewMatrix((luVOID)(xx+1)->x,(luVOID)(xx+2)->x);//生成新矩阵
8 X* X& ^1 t. C5 {- x4 s! J' ?. H
if(!pMatrix3) break;* y M\\" Z4 C/ ]
for(j=0,i=3;i<=mm;i++,j++) //赋初值; i3 R4 H8 l9 V9 I7 o8 ?9 W) h/ `
{
; p8 d9 o6 C( R& ^. r. c2 m( F
if(j>=pMatrix3->ArrayLen) break;
6 K: e; W7 t7 x! w: l# l* M: X
if((xx+i)->BType!=luStaData_double) break; //只接受实数参数
5 }8 {2 p. i8 u+ F+ X! Q
pMatrix3->Array[j]=*(double *)&((xx+i)->x);- v u. D9 ?) h8 s& Z3 X$ w1 w
}
% O7 l9 L6 m; p1 g4 {( \; l
FunReObj(hFor); //告诉Lu，返回一个动态对象; u\\" p/ b7 `\\" r\\" Z, b
a.BType=Matrix; a.VType=Matrix; a.x=0; *(luVOID *)&(a.x)=(luVOID)pMatrix3;
. B) ^4 w- f/ T2 ~9 @* C5 q, f* d$ T
break;
9 H& |$ i7 g: ~- U5 I. \2 M
case 49: //重载函数o
/ b. e' {2 c! \+ J
pMessage=(luMessage)SearchKey("\0\0\0\0",sizeof(luVOID),luPubKey_User);\\" G! q* t5 B! W( k
if(!pMessage) break;
2 r/ Z\\" C# P2 E9 `4 P/ Y. r
pMatrix1=(myMatrix *)SearchKey((char *)&(xx->x),sizeof(luVOID),Matrix);1 b4 Y& W$ X/ t {
if(!pMatrix1) break; //对象句柄无效，不是矩阵
# T1 h\\" T! h( m2 ^
pa=pMatrix1->Array;/ U2 i& } Z/ n0 ]
m=pMatrix1->Dim[0]; n=pMatrix1->Dim[1]; k=0;
& v* `4 h9 g' k6 l; }
for(i=0; i<m; i++) //输出矩阵
* [' W& }& d6 K, z
{0 I0 `0 j) g6 t4 X; @& v6 Q
pMessage(L"\r\n"); k+=2;
) T2 m9 g X\\" J
for(j=0; j<n; j++)
( Z8 F2 T) Z4 t P) L+ ]
{
4 u) i* D\\" @3 v. B1 U
_gcvt_s(chNum,pa[i*n+j],16);
2 x5 y6 H% m0 l# v9 w) x* D% @; D
for(u=0;chNum[u];u++) {wchNum[u]=chNum[u]; k++;}
! T' ?2 h, W\\" l$ y6 g2 v
wchNum[u]='\0'; l. y& q$ g8 h5 a0 C8 e/ n
pMessage(wchNum); pMessage(L" "); k+=2;
/ K6 w3 E! D! O\\" Q
}
& S( z5 S3 C& _# L) c4 E* l3 n
}
0 n9 T5 W. s' Y; o1 k# @- E8 ]$ J
pMessage(L"\r\n"); k+=2;
9 w1 C. T& t V r% R
a.BType=luStaData_int64; a.VType=luStaData_int64; a.x=k; //按函数o的要求，返回输出的字符总数
/ a# O3 ^/ J' e$ |6 r1 L6 _. a
break;
* n* q$ i% R+ Y1 m. N5 J
default:
% s0 y7 t3 m: y- v0 X% d
break;
; X: T) r\\" o: Q) l& j
}/ L; U8 i8 J4 a2 {+ F\\" I
return a;/ N$ F4 t! q1 P2 a! b
}
# e, F# G) }$ W
void main(void)
: M9 y\\" M$ C0 I L
{
9 q8 K2 {( P) a
void *hFor; //表达式句柄
' ^# Z% F; U8 ]\\" g8 e
luINT nPara; //存放表达式的自变量个数
1 L# g; x; Z0 o( m m3 b5 T# w# H
LuData *pPara; //存放输入自变量的数组指针
# V7 `; ^& N* @. f5 [
luINT ErrBegin,ErrEnd; //表达式编译出错的初始位置和结束位置+ d6 t+ W2 V8 w# v+ U
int ErrCode; //错误代码
$ g1 u\\" h- i; W' ?; ]1 K: h\\" I' D
void *v;
0 p, f) y. b9 w7 ~% {
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.]}";//字符串表达式，矩阵乘
- P$ p& O0 Y! B8 o9 ^\\" y$ s
//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.]}";//字符串表达式，矩阵点乘
5 ` W4 d- d+ S$ v' y& ?
LuData Val;0 U) p- n6 f* B7 F) F# b
if(!InitLu()) return; //初始化Lu
( k, V; b5 b: I# b9 O
while(LockKey(Matrix,DelMatrix,OpMatrix)){Matrix--;} //锁定一个键，用于存储矩阵扩展类型/ u0 X9 ]\\" K7 H- x, ]) u: }
( {; N' `9 c. O
Val.BType=luStaData_int64; Val.VType=luStaData_int64; Val.x=Matrix; //定义整数常量- q& ?4 G) d* ]+ _7 r
SetConst(L"matrix",&Val); //设置整数常量
! d\\" ^+ a, Q: s: y! L, C- I& j
InsertKey("\0\0\0\0",4,luPubKey_User,LuMessage,NULL,NULL,1,v); //使Lu运行时可输出函数信息
0 _' l, y* @- R$ w+ g/ Z
wcout.imbue(locale("chs")); //设置输出的locale为中文
, z1 ]- j U6 u. E
( b3 [3 |+ ^- T
ErrCode=LuCom(ForStr,0,0,0,hFor,nPara,pPara,ErrBegin,ErrEnd); //编译表达式) z, s) e6 z( K
if(ErrCode)
. C5 `6 a0 F! O6 |. F, Y, X& X
{6 p' D: J\\" O X8 s
wcout<<L"表达式有错误！错误代码："<<ErrCode<<endl;
- R8 m8 Z3 t* M; q3 `! s
}
+ Y% `) K0 o6 W% t+ f7 r* B
else
2 o4 L/ L; K! n
{8 ~\\" U- O# z! {4 a\\" s- j
LuCal(hFor,pPara); //计算表达式的值
$ U; r2 A: l. R5 i
}$ H2 p0 m% v; X- ~, a. [
LockKey(Matrix,NULL,OpMatrix);//解锁键Matrix，本例中，该函数可以不用( @5 w! |, d/ {8 ]\\" V+ g
FreeLu(); //释放Lu
7 u% b) |+ x\\" G m3 g! ?) f) J
}

#include <windows.h> 
$ ]\\" h( M5 z* w% ~* z0 d
#include <iostream> 
4 b6 H4 p* Q  U( N
#include <math.h>3 \+ j0 z, E: G# \0 ^! z5 J

#include "lu32.h" 
, F\\" k% ~- B* ?
#pragma comment( lib, "lu32.lib" ) 
8 Q6 h6 ^, |4 I+ z$ G
using namespace std; 
! r' z+ R\\" A2 h9 x
//自定义矩阵' f; q' Z  @: o' I2 Q

class myMatrix) h/ R: n% Y& D1 h0 o

{6 N& j) o( J5 d) P5 f8 l

public: 
9 N2 {8 [7 @8 @
        double *Array;        //数据缓冲区 
' ^4 j. ?) B6 f* j# ~/ U/ ]- F
        luVOID ArrayLen;        //数据缓冲区长度\\" Z' V\\" ~, B* R* C% @( x7 {\\" ?

luVOID Dim[2];        //矩阵维数. M% F\\" p$ H$ F& E

myMatrix(){Array=NULL; ArrayLen=0; Dim[0]=0; Dim[1]=0;}' d2 D; @  b, A8 D' J' A

~myMatrix() 
/ d- e! e5 Q8 a: ~
        { 
\\" O! X& ~\\" M1 h3 Y! f' F( Z
                if(Array) delete[] Array; 
- m. A; t: |& \7 N( h2 {
        } 
& M7 K6 c\\" x6 F/ v4 ^
}; 
\\" x( C$ b# l! H% }/ e
luKEY Matrix=-1000;        //标识矩阵类型，最终的Matrix由LockKey决定! [- x$ f\\" f: q* S+ ]8 g' P

void _stdcall LuMessage(wchar_t *pch)//输出动态库信息，该函数注册到Lu，由Lu二级函数调用 
2 U& O\\" i- Y; f3 J
{: B9 `5 J/ G# u2 t! H+ R2 X3 D

wcout<<pch; 
& \\\" M+ Q& T1 W
}- @* K% n: Z- Y$ j$ ~( b6 f  ?

void _stdcall DelMatrix(void *me)        //用于LockKey函数及InsertKey函数，使Lu能自动销毁myMatrix对象\\" q$ ~\\" C8 V- Q

{ 
- V) D\\" j/ q) |( h
        delete (myMatrix *)me; 
8 w$ e3 B  r7 J8 @0 V
}  U& ~0 ?5 n- c\\" b: S\\" k- R\\" ?6 H- g

myMatrix * _stdcall NewMatrix(luVOID m,luVOID n)        //生成一个myMatrix对象! u; ]$ \; @\\" D% w2 B

{ 
# S- [/ U, ]' v& i
        myMatrix *pMatrix;4 o( M+ m5 K( T. o

luVOID k; 
% E, X% ?$ ~% ]: ~) }& m
        double *pa; 
$ s* n7 L: e, L% r
        char keyname[sizeof(luVOID)]; 
+ |! F, B9 Y. l* l  q* u5 O
        void *NowKey;0 v! ], p& b4 z! l% s, y! f( q\\" z

k=m*n;6 i\\" q3 d# g% I& O# x7 w% E  d

pMatrix=(myMatrix *)GetBufObj(Matrix,keyname);//先尝试从缓冲区中获取一个矩阵对象' ~5 c$ k! J  x& g\\" T

if(pMatrix) 
' l$ b$ K5 _9 V0 O8 a, y
        { 
. x' ~6 n; N7 K$ Q; ]1 |
                if(pMatrix->ArrayLen!=k)        //重置矩阵的大小! x( ]3 X9 Y! ?2 m: g3 w

{6 j, {\\" d% G/ q8 q

pa=new double[k];! y/ i4 P5 o- _

if(!pa)* i4 N& A4 S\\" g% _

{ 
  a- S: q, S2 n+ p
                                DeleteKey(keyname,sizeof(luVOID),Matrix,DelMatrix,1);        //将矩阵对象放回缓冲区 
- E) s' h6 V; s8 E\\" B
                                return NULL; 
/ A7 F9 N% J; X+ e( |  ^
                        }% z! h\\" [  a. S* [

delete[] pMatrix->Array; 
$ ^+ r( L8 ?& i# |$ W
                        pMatrix->Array=pa;- q$ X! H0 U  \8 \

} 
\\" e! h\\" L  r9 [8 D  T1 s
        }+ i8 n$ b7 h) z* u! A9 v* F

else1 O3 P3 L& g\\" `) H( m; M9 `

{6 y8 Y5 H2 ?' k

pMatrix=new myMatrix;        //创建矩阵对象 
2 a6 T  G8 x# n; [3 a
                if(!pMatrix) return NULL; 
6 V6 G7 n$ d8 P, ~9 @8 |: @
                pMatrix->Array=new double[k];6 V8 ]  F, I) e( l: W9 c\\" d8 [

if(!pMatrix->Array)9 S! u' a- z3 }4 @! {3 Q

{; |$ e( f6 g1 E  H, }

delete pMatrix;5 g# \' b& F0 E' u) j/ M3 _$ ~

return NULL; 
$ c1 V1 s  D$ w! s
                }\\" C- y' `8 D  g- z+ ~( n

if(InsertKey((char *)&pMatrix,-1,Matrix,pMatrix,DelMatrix,NULL,0,NowKey))        //将矩阵对象注册到Lu$ w  ]! g( Z: R1 ~8 ?) z

{ 
  K) |. _0 v$ I& {! `
                        delete pMatrix;: [: K% f% \& u/ F; c& q

return NULL; 
( U: }, H0 o: b7 m
                } 
( H: q8 F. B/ H2 Y( [6 ]0 J
        } 
\\" ~: c8 Q% U# r! @
        pMatrix->ArrayLen=k; pMatrix->Dim[0]=m; pMatrix->Dim[1]=n;( C2 t! m0 a5 \3 _6 @

return pMatrix;+ T( I9 r0 T2 A$ f' X

}. l+ d- \' K7 n& @% C$ o

LuData _stdcall OpMatrix(luINT mm,LuData *xx,void *hFor,int theOperator)        //运算符重载函数，用于LockKey函数& R& f5 l2 E5 h& }5 ^) g$ O

{ 
' J) }8 H5 I/ E; E. e/ [! K, D/ |! D
        LuData a; 
6 l# }7 m% E/ M0 Y) N4 c( P/ P
        myMatrix *pMatrix1,*pMatrix2,*pMatrix3; 
, H% Q  v- J6 l/ j  }$ G\\" i
        luVOID i,j,k,m,n,u,v; 
0 Q* x% d2 Z0 Y( Y4 c% p
        double *pa,*pb,*pc; 
, v: `5 H6 l% s8 l& V5 ?4 W8 i$ K+ S
        luMessage pMessage; 
. L9 Y! I% h) u
        wchar_t wchNum[32];) j9 o+ W& E7 L& }

char chNum[32];/ J# L& G5 h! h! `, I' R9 [\\" s

a.BType=luStaData_nil; a.VType=luStaData_nil; a.x=0; 
) h( w5 X6 E1 O& h, J\\" h) S
        switch(theOperator) 
) h\\" H# E+ ^; E\\" m4 f0 a1 ~3 V5 d
        { 
3 v: J# y# p/ K3 e; u; ?3 Y
        case 2:        //重载运算符*/ F9 x2 K\\" d6 |3 h8 l$ v

pMatrix1=(myMatrix *)SearchKey((char *)&(xx->x),sizeof(luVOID),Matrix);& d3 F: F- v0 @1 P8 _) v% U/ W& c# J

pMatrix2=(myMatrix *)SearchKey((char *)&((xx+1)->x),sizeof(luVOID),Matrix); 
* ^! T  J  U/ r% ]
                if(!pMatrix1 || !pMatrix2) break;        //对象句柄无效，不是矩阵, t  E7 i\\" a. K; Q

if(pMatrix1->Dim[1]!=pMatrix2->Dim[0]) break;        //维数不匹配 
0 M$ i! O: _1 Y  p3 t
                pMatrix3=NewMatrix(pMatrix1->Dim[0],pMatrix2->Dim[1]);        //生成新矩阵 
8 J/ g8 P. z5 p0 n! F  F
                if(!pMatrix3) break;  k6 x, A% h\\" m/ [

pa=pMatrix1->Array; pb=pMatrix2->Array; pc=pMatrix3->Array; 
! f/ n6 g5 }' _1 Q, Y. q( L2 B
                m=pMatrix1->Dim[0]; n=pMatrix1->Dim[1]; k=pMatrix2->Dim[1]; 
1 \0 @\\" u) {( ?6 @. @\\" I9 t* h
                for(i=0; i<m; i++)        //矩阵乘 
% b. R+ s4 k  a' T\\" E
                {! F6 ~1 L6 W' m% _5 r

for(j=0; j<k; j++)+ g- L' [\\" u: j  V- y% Y

{$ w* Y' `& b% _* v* m& n' R: f

u=i*k+j; pc[u]=0.0;4 d0 o2 M! h% Q* w# `

for (v=0; v<n; v++)3 j\\" n& [2 b1 Q$ f

{0 C$ F& T* I: a8 l, }

pc[u]=pc[u]+pa[i*n+v]*pb[v*k+j];% }% H, J  g6 h! x8 X

} 
' S. `% c) z: k3 O
                        } 
+ n' |2 N0 e! m) V
                }$ z9 W( H+ V8 }. b- ?7 _

FunReObj(hFor);        //告诉Lu，返回一个动态对象# @: D' k8 `/ H# R0 @: F; b7 {+ [( g

a.BType=Matrix; a.VType=Matrix; a.x=0; *(luVOID *)&(a.x)=(luVOID)pMatrix3;# H, H! Q' Q0 B( Y3 c

break;  ]/ T) ?) ^8 C% D8 ?8 o8 W5 B, E

case 25:        //重载运算符.* 
/ T9 P  P5 z' A6 s- R
                pMatrix1=(myMatrix *)SearchKey((char *)&(xx->x),sizeof(luVOID),Matrix);7 |* ^* Z0 K0 t- x0 m+ z

pMatrix2=(myMatrix *)SearchKey((char *)&((xx+1)->x),sizeof(luVOID),Matrix); 
. U3 f7 [. |4 e8 D' c
                if(!pMatrix1 || !pMatrix2) break;        //对象句柄无效，不是矩阵+ B. H# ]9 F% o

if(pMatrix1->Dim[0]!=pMatrix2->Dim[0] || pMatrix1->Dim[1]!=pMatrix2->Dim[1]) break;        //维数不相同  M  ~7 W0 O+ J, ]; U# R\\" ]

pMatrix3=NewMatrix(pMatrix1->Dim[0],pMatrix1->Dim[1]);        //生成新矩阵3 z8 o8 w  q1 J; |. \; C% `

if(!pMatrix3) break; 
7 \6 O% H+ y' [, O/ {
                for(i=0;i<pMatrix1->ArrayLen;i++) pMatrix3->Array[i]=pMatrix1->Array[i]*pMatrix2->Array[i];        //矩阵点乘6 O1 {; V& h5 e4 ?+ w9 k: o. \

FunReObj(hFor);        //告诉Lu，返回一个动态对象 
8 f+ c: _2 H4 O6 I, M7 f: d
                a.BType=Matrix; a.VType=Matrix; a.x=0; *(luVOID *)&(a.x)=(luVOID)pMatrix3;* f2 Z6 C% T6 D: ^! O; U. y, |' i8 `

break; 
. Q5 w' w0 [* r0 u
        case 46:        //重载函数new 
( n& a8 O4 z/ B
                if(mm<2) break; 
# a$ A9 Y* X2 u3 F/ R$ |$ G
                if((xx+1)->x<1 || (xx+2)->x<1 || (xx+1)->BType!=luStaData_int64 || (xx+2)->BType!=luStaData_int64) break; 
+ D0 W! D. l1 _& q
                pMatrix3=NewMatrix((luVOID)(xx+1)->x,(luVOID)(xx+2)->x);//生成新矩阵 
8 X* X& ^1 t. C5 {- x4 s! J' ?. H
                if(!pMatrix3) break;* y  M\\" Z4 C/ ]

for(j=0,i=3;i<=mm;i++,j++)        //赋初值; i3 R4 H8 l9 V9 I7 o8 ?9 W) h/ `

{ 
; p8 d9 o6 C( R& ^. r. c2 m( F
                        if(j>=pMatrix3->ArrayLen) break; 
6 K: e; W7 t7 x! w: l# l* M: X
                        if((xx+i)->BType!=luStaData_double) break;        //只接受实数参数 
5 }8 {2 p. i8 u+ F+ X! Q
                        pMatrix3->Array[j]=*(double *)&((xx+i)->x);- v  u. D9 ?) h8 s& Z3 X$ w1 w

} 
% O7 l9 L6 m; p1 g4 {( \; l
                FunReObj(hFor);        //告诉Lu，返回一个动态对象; u\\" p/ b7 `\\" r\\" Z, b

a.BType=Matrix; a.VType=Matrix; a.x=0; *(luVOID *)&(a.x)=(luVOID)pMatrix3; 
. B) ^4 w- f/ T2 ~9 @* C5 q, f* d$ T
                break; 
9 H& |$ i7 g: ~- U5 I. \2 M
        case 49:        //重载函数o 
/ b. e' {2 c! \+ J
                pMessage=(luMessage)SearchKey("\0\0\0\0",sizeof(luVOID),luPubKey_User);\\" G! q* t5 B! W( k

if(!pMessage) break; 
2 r/ Z\\" C# P2 E9 `4 P/ Y. r
                pMatrix1=(myMatrix *)SearchKey((char *)&(xx->x),sizeof(luVOID),Matrix);1 b4 Y& W$ X/ t  {

if(!pMatrix1) break;        //对象句柄无效，不是矩阵 
# T1 h\\" T! h( m2 ^
                pa=pMatrix1->Array;/ U2 i& }  Z/ n0 ]

m=pMatrix1->Dim[0]; n=pMatrix1->Dim[1]; k=0; 
& v* `4 h9 g' k6 l; }
                for(i=0; i<m; i++)        //输出矩阵 
* [' W& }& d6 K, z
                {0 I0 `0 j) g6 t4 X; @& v6 Q

pMessage(L"\r\n"); k+=2; 
) T2 m9 g  X\\" J
                        for(j=0; j<n; j++) 
( Z8 F2 T) Z4 t  P) L+ ]
                        { 
4 u) i* D\\" @3 v. B1 U
                                _gcvt_s(chNum,pa[i*n+j],16); 
2 x5 y6 H% m0 l# v9 w) x* D% @; D
                                for(u=0;chNum[u];u++) {wchNum[u]=chNum[u]; k++;} 
! T' ?2 h, W\\" l$ y6 g2 v
                                wchNum[u]='\0';  l. y& q$ g8 h5 a0 C8 e/ n

pMessage(wchNum); pMessage(L"  "); k+=2; 
/ K6 w3 E! D! O\\" Q
                        } 
& S( z5 S3 C& _# L) c4 E* l3 n
                } 
0 n9 T5 W. s' Y; o1 k# @- E8 ]$ J
                pMessage(L"\r\n"); k+=2; 
9 w1 C. T& t  V  r% R
                a.BType=luStaData_int64; a.VType=luStaData_int64; a.x=k;        //按函数o的要求，返回输出的字符总数 
/ a# O3 ^/ J' e$ |6 r1 L6 _. a
                break; 
* n* q$ i% R+ Y1 m. N5 J
        default: 
% s0 y7 t3 m: y- v0 X% d
                break; 
; X: T) r\\" o: Q) l& j
        }/ L; U8 i8 J4 a2 {+ F\\" I

return a;/ N$ F4 t! q1 P2 a! b

} 
# e, F# G) }$ W
void main(void) 
: M9 y\\" M$ C0 I  L
{ 
9 q8 K2 {( P) a
        void *hFor;                //表达式句柄 
' ^# Z% F; U8 ]\\" g8 e
        luINT nPara;                //存放表达式的自变量个数 
1 L# g; x; Z0 o( m  m3 b5 T# w# H
        LuData *pPara;                //存放输入自变量的数组指针 
# V7 `; ^& N* @. f5 [
        luINT ErrBegin,ErrEnd;        //表达式编译出错的初始位置和结束位置+ d6 t+ W2 V8 w# v+ U

int ErrCode;                //错误代码 
$ g1 u\\" h- i; W' ?; ]1 K: h\\" I' D
        void *v; 
0 p, f) y. b9 w7 ~% {
        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.]}";//字符串表达式，矩阵乘 
- P$ p& O0 Y! B8 o9 ^\\" y$ s
        //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.]}";//字符串表达式，矩阵点乘 
5 `  W4 d- d+ S$ v' y& ?
        LuData Val;0 U) p- n6 f* B7 F) F# b

if(!InitLu()) return;        //初始化Lu 
( k, V; b5 b: I# b9 O
        while(LockKey(Matrix,DelMatrix,OpMatrix)){Matrix--;}        //锁定一个键，用于存储矩阵扩展类型/ u0 X9 ]\\" K7 H- x, ]) u: }

( {; N' `9 c. O
        Val.BType=luStaData_int64; Val.VType=luStaData_int64; Val.x=Matrix;        //定义整数常量- q& ?4 G) d* ]+ _7 r

SetConst(L"matrix",&Val);        //设置整数常量 
! d\\" ^+ a, Q: s: y! L, C- I& j
        InsertKey("\0\0\0\0",4,luPubKey_User,LuMessage,NULL,NULL,1,v); //使Lu运行时可输出函数信息 
0 _' l, y* @- R$ w+ g/ Z
        wcout.imbue(locale("chs"));        //设置输出的locale为中文 
, z1 ]- j  U6 u. E
   
( b3 [3 |+ ^- T
        ErrCode=LuCom(ForStr,0,0,0,hFor,nPara,pPara,ErrBegin,ErrEnd); //编译表达式) z, s) e6 z( K

if(ErrCode) 
. C5 `6 a0 F! O6 |. F, Y, X& X
        {6 p' D: J\\" O  X8 s

wcout<<L"表达式有错误！错误代码："<<ErrCode<<endl; 
- R8 m8 Z3 t* M; q3 `! s
        } 
+ Y% `) K0 o6 W% t+ f7 r* B
        else 
2 o4 L/ L; K! n
        {8 ~\\" U- O# z! {4 a\\" s- j

LuCal(hFor,pPara);        //计算表达式的值 
$ U; r2 A: l. R5 i
        }$ H2 p0 m% v; X- ~, a. [

LockKey(Matrix,NULL,OpMatrix);//解锁键Matrix，本例中，该函数可以不用( @5 w! |, d/ {8 ]\\" V+ g

FreeLu();                        //释放Lu 
7 u% b) |+ x\\" G  m3 g! ?) f) J
}

习题：

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

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

main(:a,b,c,d,t,i)=- o: ?( G\" \& t Z/ h
a=new[matrix,2,2: 1.,2.,2.,1.],
0 P( y4 r3 Z: C- k7 Z, Z5 i+ X5 P G
b=new[matrix,2,2: 2.,1.,1.,2.],
7 J5 t* c5 h7 e) N
c=new[matrix,2,2: 2/3.,-1/3.,-1/3.,2/3.],
* Q; c9 _# x1 O8 y
t=clock(),
+ F7 M& B; P! W/ h
d=a*b, i=0, while{i<1000000, d=d*c*b, i++},
! U3 C: D: B1 N& T2 w; r0 d( z( W
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\"}";//字符串表达式

复制代码

结果：