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

查看: 8855|回复: 2

在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>
* g0 K8 W) u* C: E0 v6 n
#include <iostream>- ?3 o6 Y: ~- t4 l
#include <math.h>6 v! I1 A r. l- n. Y4 F$ }
#include "lu32.h"
5 a. ~* h* `! ?3 P7 c9 D
#pragma comment( lib, "lu32.lib" ). U) V/ v$ R& @9 T
using namespace std;
$ k0 F; Z/ ~1 _
//自定义矩阵- X\\" y! S3 m. {4 A: ?. e3 }! }+ }
class myMatrix
4 w- `! b- V( u2 N\\" b7 F
{
+ O S, o8 O- _7 h3 ?7 ^# s& `
public:
; I# b. I\\" P; @
double *Array; //数据缓冲区
) N0 ?* M\\" z6 P% O) f
luVOID ArrayLen; //数据缓冲区长度
* f$ F, E/ q* ]7 K' b7 V
luVOID Dim[2]; //矩阵维数
# p7 h- n* u( P8 p
myMatrix(){Array=NULL; ArrayLen=0; Dim[0]=0; Dim[1]=0;}8 N% a0 ^5 r M3 x
~myMatrix()
9 V! M! a- o* q: Z6 D& \
{
( M+ u2 F3 U. j) P
if(Array) delete[] Array;
0 |' ?; b$ ~8 N2 b' T: r2 H
}: }' r) r. g) q8 J5 |\\" I
};1 [0 |& W( i' f i9 r
luKEY Matrix=-1000; //标识矩阵类型，最终的Matrix由LockKey决定
3 `1 e. t. v$ i* K\\" ^
void _stdcall LuMessage(wchar_t *pch)//输出动态库信息，该函数注册到Lu，由Lu二级函数调用 * C4 m8 l$ {, t! F+ W
{5 d( B; w; k1 ]5 @1 }5 k\\" u5 z3 G
wcout<<pch;
* R\\" Y. h1 z0 P1 ]
}! D4 E5 M+ G e# [
void _stdcall DelMatrix(void *me) //用于LockKey函数及InsertKey函数，使Lu能自动销毁myMatrix对象* j8 j# y4 P, Q# M9 f
{$ y8 Q# h( N# D Y. R7 [/ q% A- M
delete (myMatrix *)me;* O0 e0 ]' A- B0 b4 d* O+ A
}
\\" D0 ?8 _7 s2 R* s% N+ n2 Q, Z: A
myMatrix * _stdcall NewMatrix(luVOID m,luVOID n) //生成一个myMatrix对象. S0 Y$ o5 {& M* J$ u. V
{, C6 A n4 f( i/ i6 S
myMatrix *pMatrix;& i2 X& Z* H: ?' h0 E0 H) I
luVOID k;
8 Z6 ~1 y, R: ~0 }2 m
double *pa;5 P- N q5 Y: Z! L% s1 o* [
char keyname[sizeof(luVOID)];4 s0 S9 U. A2 Q% \
void *NowKey;9 C/ B2 U0 j: l0 G% {# v) W\\" f2 R
k=m*n;6 }+ b: L( J6 [2 n4 O
pMatrix=(myMatrix *)GetBufObj(Matrix,keyname);//先尝试从缓冲区中获取一个矩阵对象
; ~' f% Y! Y3 G/ {% G\\" [5 z
if(pMatrix)# _ E6 U6 i) K, O- F5 {9 a
{
3 Y% M5 c* ~( X$ t' M& n: B
if(pMatrix->ArrayLen!=k) //重置矩阵的大小 B0 n$ ?; Z- D) ~; ^$ ^& W4 M2 E
{9 R4 F1 {/ G& A\\" |6 R
pa=new double[k];* J: a* i. r) I
if(!pa)
# Y |! C3 z! e) K- u4 |\\" t4 I
{
0 f& z; T6 |\\" d: c! v- _: U
DeleteKey(keyname,sizeof(luVOID),Matrix,DelMatrix,1); //将矩阵对象放回缓冲区
- F1 S\\" v* ~4 A! l3 P
return NULL;
- I5 [5 M4 J0 a: s( w2 z\\" `
}. `1 q+ i( q6 N! h+ B0 p
delete[] pMatrix->Array;. l8 B\\" I2 J! l4 |0 X1 i2 K
pMatrix->Array=pa;0 x8 K) U# {6 i( J2 }( U/ e
}
% n4 J7 `0 W9 d2 A x+ D: \+ j
}
+ L+ l\\" C; g7 ?5 \6 j& g
else% G* \! J: D2 P& V/ s7 o
{
6 W6 A+ h& X- U
pMatrix=new myMatrix; //创建矩阵对象
u3 q3 H- L4 T- U9 q$ l4 r
if(!pMatrix) return NULL;3 i4 m3 Y9 _4 u0 l8 p
pMatrix->Array=new double[k];
9 {7 z2 ~6 J2 E* n# K% _ ?\\" L
if(!pMatrix->Array)6 {\\" P3 m8 s/ |+ d' p2 T, j\\" i$ X
{ L/ b$ v) [4 Y7 o0 d( z' u2 _, n, ?
delete pMatrix;' q0 [6 g, j1 z' V- s
return NULL;4 T( w- j# p\\" H/ D3 u; {2 `4 g: t
}
& @0 }( c+ i0 M. N4 g
if(InsertKey((char *)&pMatrix,-1,Matrix,pMatrix,DelMatrix,NULL,0,NowKey)) //将矩阵对象注册到Lu
* P( ~7 [( v, g, ?
{7 o( t0 I( Q9 R. B& z3 Y# ?+ M) O0 Q
delete pMatrix;6 [! q( M3 e L) C. g
return NULL;( h: W- }3 [# |4 h8 B
}+ J5 m, c% \) r3 R% o \
}/ j1 D, T2 m7 @
pMatrix->ArrayLen=k; pMatrix->Dim[0]=m; pMatrix->Dim[1]=n; Z5 N2 v: ~# x
return pMatrix;' D: B' S1 j0 v5 W, |) j
}
: g' u- |5 B7 y8 A\\" C- U& J3 K\\" L
LuData _stdcall OpMatrix(luINT mm,LuData *xx,void *hFor,int theOperator) //运算符重载函数，用于LockKey函数
\\" p5 K# o' i1 T: Q
{
1 g7 \% g1 P' U4 S7 x; E* D6 ~
LuData a;# U1 n: {9 q# x) C- P h8 D/ k5 t' q, C
myMatrix *pMatrix1,*pMatrix2,*pMatrix3;
! \* t0 S/ d. [5 [1 E7 x
luVOID i,j,k,m,n,u,v;
' B& B/ A9 {1 l8 y. U7 _- C5 i
double *pa,*pb,*pc;
8 P L: z- C5 ]: i3 b% x
luMessage pMessage;8 u& T; V- a7 }
wchar_t wchNum[32];
5 ~ G4 X( f: d
char chNum[32];
`0 d5 o6 i! R% X( r
a.BType=luStaData_nil; a.VType=luStaData_nil; a.x=0;1 B7 H- K- O8 q; T
switch(theOperator)1 C% s7 t$ a2 M) x
{$ B& M\\" P9 z. H7 r
case 2: //重载运算符*
. b, }- ?) y' t: w
pMatrix1=(myMatrix *)SearchKey((char *)&(xx->x),sizeof(luVOID),Matrix);
! I/ w! T8 E* K\\" ]3 c\\" t
pMatrix2=(myMatrix *)SearchKey((char *)&((xx+1)->x),sizeof(luVOID),Matrix);
* Q+ j* L1 ^/ C3 U
if(!pMatrix1 || !pMatrix2) break; //对象句柄无效，不是矩阵
/ D- w1 E9 R' q9 e
if(pMatrix1->Dim[1]!=pMatrix2->Dim[0]) break; //维数不匹配
& |, |; @$ L9 D! i
pMatrix3=NewMatrix(pMatrix1->Dim[0],pMatrix2->Dim[1]); //生成新矩阵
1 j1 B- D; k& y/ o
if(!pMatrix3) break;
# j/ T6 e+ t4 Y Z9 \; k+ ~
pa=pMatrix1->Array; pb=pMatrix2->Array; pc=pMatrix3->Array;; I+ b, G* a0 q; o: G: |
m=pMatrix1->Dim[0]; n=pMatrix1->Dim[1]; k=pMatrix2->Dim[1];
& Q5 P3 t- W6 _& J& W7 O# E: t* z
for(i=0; i<m; i++) //矩阵乘: p) a( V5 ^& J4 D$ v' e; W
{( C* C0 S, r# i ?+ Q
for(j=0; j<k; j++)
6 Y2 L X8 X! f\\" ~+ U
{$ m3 }# o1 N! E5 Q' B0 E) T; g
u=i*k+j; pc[u]=0.0;
% k* X& x; u. j6 H' X: `! N
for (v=0; v<n; v++)
1 }4 @# d) p O& V& c' Q* m
{. |5 j* b- C( |& |% |1 D, z. f
pc[u]=pc[u]+pa[i*n+v]*pb[v*k+j];0 b7 u: n' A' Q\\" e0 P
}1 }- ?6 @+ G; u. ?
}
' D% `6 v) e8 ~
}' d) ^6 @6 r# I# V) @6 _. I( ?
FunReObj(hFor); //告诉Lu，返回一个动态对象0 |9 X7 U* T/ L$ H& @4 S
a.BType=Matrix; a.VType=Matrix; a.x=0; *(luVOID *)&(a.x)=(luVOID)pMatrix3;
/ E! I2 b6 e# V% p! C+ N6 t6 U8 s( f
break;; x' c4 k. ~3 y! |
case 25: //重载运算符.*: \ x4 |# r: Q! R7 c\\" _7 _
pMatrix1=(myMatrix *)SearchKey((char *)&(xx->x),sizeof(luVOID),Matrix);
: O$ t+ p6 l0 }& } l. l+ a
pMatrix2=(myMatrix *)SearchKey((char *)&((xx+1)->x),sizeof(luVOID),Matrix);+ O2 D6 P0 Y2 u
if(!pMatrix1 || !pMatrix2) break; //对象句柄无效，不是矩阵
5 P6 o( q/ }5 x6 L* z% V
if(pMatrix1->Dim[0]!=pMatrix2->Dim[0] || pMatrix1->Dim[1]!=pMatrix2->Dim[1]) break; //维数不相同+ |- `- e, ?1 W, ^& ^0 s |3 W$ Z
pMatrix3=NewMatrix(pMatrix1->Dim[0],pMatrix1->Dim[1]); //生成新矩阵
9 I R' p5 p- O( J: _
if(!pMatrix3) break;. `0 E, H) k. t5 d$ d9 j) T7 e
for(i=0;i<pMatrix1->ArrayLen;i++) pMatrix3->Array[i]=pMatrix1->Array[i]*pMatrix2->Array[i]; //矩阵点乘$ g: B- q. m4 j: X
FunReObj(hFor); //告诉Lu，返回一个动态对象
3 ?9 ?9 \7 q% C
a.BType=Matrix; a.VType=Matrix; a.x=0; *(luVOID *)&(a.x)=(luVOID)pMatrix3;
7 {& L9 @) X# Y
break;
- a' @) Z# \/ b: T, `/ p
case 46: //重载函数new' w6 K# |: e+ _# O# w
if(mm<2) break;0 Y+ b4 m$ O, f1 _' n
if((xx+1)->x<1 || (xx+2)->x<1 || (xx+1)->BType!=luStaData_int64 || (xx+2)->BType!=luStaData_int64) break;9 W6 o' C7 X( i. C1 |+ q/ K# M
pMatrix3=NewMatrix((luVOID)(xx+1)->x,(luVOID)(xx+2)->x);//生成新矩阵
& s' ?$ g- r& s6 T\\" {
if(!pMatrix3) break;, A8 ^) q; N& J+ ?
for(j=0,i=3;i<=mm;i++,j++) //赋初值7 @\\" s' r2 G% [6 i, q: n
{: m5 C6 V; `/ Y/ e
if(j>=pMatrix3->ArrayLen) break;\\" j1 `. o% q* G\\" t+ W9 j/ m
if((xx+i)->BType!=luStaData_double) break; //只接受实数参数
( J5 `. o, `) x, s% F0 x0 T5 K2 ]
pMatrix3->Array[j]=*(double *)&((xx+i)->x);
\\" L8 o5 L6 q# {( `. j) M6 V
}
# P3 _$ ~4 m% H
FunReObj(hFor); //告诉Lu，返回一个动态对象
4 S7 u: c' h. B, B! v
a.BType=Matrix; a.VType=Matrix; a.x=0; *(luVOID *)&(a.x)=(luVOID)pMatrix3;+ O1 M4 p X- o2 p. o
break;+ x; k2 u/ y2 b; ^; Y
case 49: //重载函数o
}) u. ]% U, @% ]& I% i
pMessage=(luMessage)SearchKey("\0\0\0\0",sizeof(luVOID),luPubKey_User);! I* ~* Q% [* \1 y* V6 H* A
if(!pMessage) break;
0 R6 U\\" P' G; P* b4 u8 v
pMatrix1=(myMatrix *)SearchKey((char *)&(xx->x),sizeof(luVOID),Matrix);2 m5 V/ {3 f( b' A5 ?' S% l# h- q
if(!pMatrix1) break; //对象句柄无效，不是矩阵9 o& q# w- h, t( n% W2 J0 @
pa=pMatrix1->Array;
# i8 u+ O4 B% S9 a2 t r
m=pMatrix1->Dim[0]; n=pMatrix1->Dim[1]; k=0;
* C# P; O7 i Z! X7 l, Y: l) g5 S
for(i=0; i<m; i++) //输出矩阵
9 R4 h9 \' d w! ]' J1 ^1 q
{
& b0 z) G# [) `8 {
pMessage(L"\r\n"); k+=2;
; E: g U& \/ y- U* p
for(j=0; j<n; j++)
) C+ q- X1 x4 i8 }\\" q
{, i2 F0 j- j\\" ~1 t A0 A
_gcvt_s(chNum,pa[i*n+j],16);
( [3 g$ G( q% c& R
for(u=0;chNum[u];u++) {wchNum[u]=chNum[u]; k++;}
' y$ \# O1 a7 ?3 i' L3 S# ]
wchNum[u]='\0';
6 X3 Y: a( j. I& o
pMessage(wchNum); pMessage(L" "); k+=2;
+ ^. o/ D. }' Y# n
}/ q$ P; F. u C/ U, M
}4 n9 n1 H0 I: z5 C0 a( |
pMessage(L"\r\n"); k+=2;4 G: x0 o( v! P/ W
a.BType=luStaData_int64; a.VType=luStaData_int64; a.x=k; //按函数o的要求，返回输出的字符总数- {0 x' p: z& q+ u9 d
break;) p8 _! x4 \- k, _& Z9 L
default:4 |% f9 T' S/ ]. S8 Y [) p( `. _
break;; I. N+ y6 U8 Y/ R5 _
}/ m4 i; Q' N) V' Y* l9 o
return a;- {! v# }2 {. U
}
- E/ C F6 t( y5 U. N, c, V q
void main(void): H/ w* f\\" b7 S) q5 W/ O
{ e0 o0 A) f* Z& T8 R& f
void *hFor; //表达式句柄% `# g5 K' d8 ~- o* g
luINT nPara; //存放表达式的自变量个数0 q: X- _7 `0 N/ ^( u b6 B
LuData *pPara; //存放输入自变量的数组指针. q2 @% E( n. u0 m3 N4 B
luINT ErrBegin,ErrEnd; //表达式编译出错的初始位置和结束位置
: A c, b0 O! y. \. a: g- L- J
int ErrCode; //错误代码% T+ K) Y0 ?( ^6 [; Q
void *v;
$ A/ ~0 M( C, @% {1 \
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.]}";//字符串表达式，矩阵乘0 ~6 ]% ]& o* 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.]}";//字符串表达式，矩阵点乘# N( Z' f4 o9 b4 o\\" e% D% j
LuData Val;
( `% b; K+ \# S! q, p; Z
if(!InitLu()) return; //初始化Lu. }$ i, f+ Q% i4 y+ _( @8 N
while(LockKey(Matrix,DelMatrix,OpMatrix)){Matrix--;} //锁定一个键，用于存储矩阵扩展类型
4 b8 I- J U& L2 N4 F
- B' Z3 d9 E: R \
Val.BType=luStaData_int64; Val.VType=luStaData_int64; Val.x=Matrix; //定义整数常量1 i6 M9 }* V5 k4 [
SetConst(L"matrix",&Val); //设置整数常量
* k5 a( v5 O+ }\\" I3 M0 K, D4 g6 p
InsertKey("\0\0\0\0",4,luPubKey_User,LuMessage,NULL,NULL,1,v); //使Lu运行时可输出函数信息. w( k$ r A2 U
wcout.imbue(locale("chs")); //设置输出的locale为中文
) W' W; |\\" p8 Q& [) m
}7 I* Y; D$ j2 k, \
ErrCode=LuCom(ForStr,0,0,0,hFor,nPara,pPara,ErrBegin,ErrEnd); //编译表达式- D: R& u& J7 K. d8 {0 N% ]
if(ErrCode)
) s% `) u! y- O
{
# S) z- h) y7 b$ W& p4 l; K
wcout<<L"表达式有错误！错误代码："<<ErrCode<<endl;: f: A) ~, h7 O2 n- D1 f3 |, I t; p
}
9 c( P: _. j, g$ o6 |
else
% B3 }, i) m& ?9 v) M
{: G0 l$ C% u- e6 d7 p' f* P- u, a
LuCal(hFor,pPara); //计算表达式的值; K% T& |* }8 T$ b
}: A) w7 A3 x* o\\" Y7 G- w# V
LockKey(Matrix,NULL,OpMatrix);//解锁键Matrix，本例中，该函数可以不用. a4 |\\" y& M9 v1 Q
FreeLu(); //释放Lu
- y) o5 O+ y2 Q* r# z
}

#include <windows.h> 
* g0 K8 W) u* C: E0 v6 n
#include <iostream>- ?3 o6 Y: ~- t4 l

#include <math.h>6 v! I1 A  r. l- n. Y4 F$ }

#include "lu32.h" 
5 a. ~* h* `! ?3 P7 c9 D
#pragma comment( lib, "lu32.lib" ). U) V/ v$ R& @9 T

using namespace std; 
$ k0 F; Z/ ~1 _
//自定义矩阵- X\\" y! S3 m. {4 A: ?. e3 }! }+ }

class myMatrix 
4 w- `! b- V( u2 N\\" b7 F
{ 
+ O  S, o8 O- _7 h3 ?7 ^# s& `
public: 
; I# b. I\\" P; @
        double *Array;        //数据缓冲区 
) N0 ?* M\\" z6 P% O) f
        luVOID ArrayLen;        //数据缓冲区长度 
* f$ F, E/ q* ]7 K' b7 V
        luVOID Dim[2];        //矩阵维数 
# p7 h- n* u( P8 p
        myMatrix(){Array=NULL; ArrayLen=0; Dim[0]=0; Dim[1]=0;}8 N% a0 ^5 r  M3 x

~myMatrix() 
9 V! M! a- o* q: Z6 D& \
        { 
( M+ u2 F3 U. j) P
                if(Array) delete[] Array; 
0 |' ?; b$ ~8 N2 b' T: r2 H
        }: }' r) r. g) q8 J5 |\\" I

};1 [0 |& W( i' f  i9 r

luKEY Matrix=-1000;        //标识矩阵类型，最终的Matrix由LockKey决定 
3 `1 e. t. v$ i* K\\" ^
void _stdcall LuMessage(wchar_t *pch)//输出动态库信息，该函数注册到Lu，由Lu二级函数调用 * C4 m8 l$ {, t! F+ W

{5 d( B; w; k1 ]5 @1 }5 k\\" u5 z3 G

wcout<<pch; 
* R\\" Y. h1 z0 P1 ]
}! D4 E5 M+ G  e# [

void _stdcall DelMatrix(void *me)        //用于LockKey函数及InsertKey函数，使Lu能自动销毁myMatrix对象* j8 j# y4 P, Q# M9 f

{$ y8 Q# h( N# D  Y. R7 [/ q% A- M

delete (myMatrix *)me;* O0 e0 ]' A- B0 b4 d* O+ A

} 
\\" D0 ?8 _7 s2 R* s% N+ n2 Q, Z: A
myMatrix * _stdcall NewMatrix(luVOID m,luVOID n)        //生成一个myMatrix对象. S0 Y$ o5 {& M* J$ u. V

{, C6 A  n4 f( i/ i6 S

myMatrix *pMatrix;& i2 X& Z* H: ?' h0 E0 H) I

luVOID k; 
8 Z6 ~1 y, R: ~0 }2 m
        double *pa;5 P- N  q5 Y: Z! L% s1 o* [

char keyname[sizeof(luVOID)];4 s0 S9 U. A2 Q% \

void *NowKey;9 C/ B2 U0 j: l0 G% {# v) W\\" f2 R

k=m*n;6 }+ b: L( J6 [2 n4 O

pMatrix=(myMatrix *)GetBufObj(Matrix,keyname);//先尝试从缓冲区中获取一个矩阵对象 
; ~' f% Y! Y3 G/ {% G\\" [5 z
        if(pMatrix)# _  E6 U6 i) K, O- F5 {9 a

{ 
3 Y% M5 c* ~( X$ t' M& n: B
                if(pMatrix->ArrayLen!=k)        //重置矩阵的大小  B0 n$ ?; Z- D) ~; ^$ ^& W4 M2 E

{9 R4 F1 {/ G& A\\" |6 R

pa=new double[k];* J: a* i. r) I

if(!pa) 
# Y  |! C3 z! e) K- u4 |\\" t4 I
                        { 
0 f& z; T6 |\\" d: c! v- _: U
                                DeleteKey(keyname,sizeof(luVOID),Matrix,DelMatrix,1);        //将矩阵对象放回缓冲区 
- F1 S\\" v* ~4 A! l3 P
                                return NULL; 
- I5 [5 M4 J0 a: s( w2 z\\" `
                        }. `1 q+ i( q6 N! h+ B0 p

delete[] pMatrix->Array;. l8 B\\" I2 J! l4 |0 X1 i2 K

pMatrix->Array=pa;0 x8 K) U# {6 i( J2 }( U/ e

} 
% n4 J7 `0 W9 d2 A  x+ D: \+ j
        } 
+ L+ l\\" C; g7 ?5 \6 j& g
        else% G* \! J: D2 P& V/ s7 o

{ 
6 W6 A+ h& X- U
                pMatrix=new myMatrix;        //创建矩阵对象 
  u3 q3 H- L4 T- U9 q$ l4 r
                if(!pMatrix) return NULL;3 i4 m3 Y9 _4 u0 l8 p

pMatrix->Array=new double[k]; 
9 {7 z2 ~6 J2 E* n# K% _  ?\\" L
                if(!pMatrix->Array)6 {\\" P3 m8 s/ |+ d' p2 T, j\\" i$ X

{  L/ b$ v) [4 Y7 o0 d( z' u2 _, n, ?

delete pMatrix;' q0 [6 g, j1 z' V- s

return NULL;4 T( w- j# p\\" H/ D3 u; {2 `4 g: t

} 
& @0 }( c+ i0 M. N4 g
                if(InsertKey((char *)&pMatrix,-1,Matrix,pMatrix,DelMatrix,NULL,0,NowKey))        //将矩阵对象注册到Lu 
* P( ~7 [( v, g, ?
                {7 o( t0 I( Q9 R. B& z3 Y# ?+ M) O0 Q

delete pMatrix;6 [! q( M3 e  L) C. g

return NULL;( h: W- }3 [# |4 h8 B

}+ J5 m, c% \) r3 R% o  \

}/ j1 D, T2 m7 @

pMatrix->ArrayLen=k; pMatrix->Dim[0]=m; pMatrix->Dim[1]=n;  Z5 N2 v: ~# x

return pMatrix;' D: B' S1 j0 v5 W, |) j

} 
: g' u- |5 B7 y8 A\\" C- U& J3 K\\" L
LuData _stdcall OpMatrix(luINT mm,LuData *xx,void *hFor,int theOperator)        //运算符重载函数，用于LockKey函数 
\\" p5 K# o' i1 T: Q
{ 
1 g7 \% g1 P' U4 S7 x; E* D6 ~
        LuData a;# U1 n: {9 q# x) C- P  h8 D/ k5 t' q, C

myMatrix *pMatrix1,*pMatrix2,*pMatrix3; 
! \* t0 S/ d. [5 [1 E7 x
        luVOID i,j,k,m,n,u,v; 
' B& B/ A9 {1 l8 y. U7 _- C5 i
        double *pa,*pb,*pc; 
8 P  L: z- C5 ]: i3 b% x
        luMessage pMessage;8 u& T; V- a7 }

wchar_t wchNum[32]; 
5 ~  G4 X( f: d
        char chNum[32]; 
  `0 d5 o6 i! R% X( r
        a.BType=luStaData_nil; a.VType=luStaData_nil; a.x=0;1 B7 H- K- O8 q; T

switch(theOperator)1 C% s7 t$ a2 M) x

{$ B& M\\" P9 z. H7 r

case 2:        //重载运算符* 
. b, }- ?) y' t: w
                pMatrix1=(myMatrix *)SearchKey((char *)&(xx->x),sizeof(luVOID),Matrix); 
! I/ w! T8 E* K\\" ]3 c\\" t
                pMatrix2=(myMatrix *)SearchKey((char *)&((xx+1)->x),sizeof(luVOID),Matrix); 
* Q+ j* L1 ^/ C3 U
                if(!pMatrix1 || !pMatrix2) break;        //对象句柄无效，不是矩阵 
/ D- w1 E9 R' q9 e
                if(pMatrix1->Dim[1]!=pMatrix2->Dim[0]) break;        //维数不匹配 
& |, |; @$ L9 D! i
                pMatrix3=NewMatrix(pMatrix1->Dim[0],pMatrix2->Dim[1]);        //生成新矩阵 
1 j1 B- D; k& y/ o
                if(!pMatrix3) break; 
# j/ T6 e+ t4 Y  Z9 \; k+ ~
                pa=pMatrix1->Array; pb=pMatrix2->Array; pc=pMatrix3->Array;; I+ b, G* a0 q; o: G: |

m=pMatrix1->Dim[0]; n=pMatrix1->Dim[1]; k=pMatrix2->Dim[1]; 
& Q5 P3 t- W6 _& J& W7 O# E: t* z
                for(i=0; i<m; i++)        //矩阵乘: p) a( V5 ^& J4 D$ v' e; W

{( C* C0 S, r# i  ?+ Q

for(j=0; j<k; j++) 
6 Y2 L  X8 X! f\\" ~+ U
                        {$ m3 }# o1 N! E5 Q' B0 E) T; g

u=i*k+j; pc[u]=0.0; 
% k* X& x; u. j6 H' X: `! N
                                for (v=0; v<n; v++) 
1 }4 @# d) p  O& V& c' Q* m
                                {. |5 j* b- C( |& |% |1 D, z. f

pc[u]=pc[u]+pa[i*n+v]*pb[v*k+j];0 b7 u: n' A' Q\\" e0 P

}1 }- ?6 @+ G; u. ?

} 
' D% `6 v) e8 ~
                }' d) ^6 @6 r# I# V) @6 _. I( ?

FunReObj(hFor);        //告诉Lu，返回一个动态对象0 |9 X7 U* T/ L$ H& @4 S

a.BType=Matrix; a.VType=Matrix; a.x=0; *(luVOID *)&(a.x)=(luVOID)pMatrix3; 
/ E! I2 b6 e# V% p! C+ N6 t6 U8 s( f
                break;; x' c4 k. ~3 y! |

case 25:        //重载运算符.*: \  x4 |# r: Q! R7 c\\" _7 _

pMatrix1=(myMatrix *)SearchKey((char *)&(xx->x),sizeof(luVOID),Matrix); 
: O$ t+ p6 l0 }& }  l. l+ a
                pMatrix2=(myMatrix *)SearchKey((char *)&((xx+1)->x),sizeof(luVOID),Matrix);+ O2 D6 P0 Y2 u

if(!pMatrix1 || !pMatrix2) break;        //对象句柄无效，不是矩阵 
5 P6 o( q/ }5 x6 L* z% V
                if(pMatrix1->Dim[0]!=pMatrix2->Dim[0] || pMatrix1->Dim[1]!=pMatrix2->Dim[1]) break;        //维数不相同+ |- `- e, ?1 W, ^& ^0 s  |3 W$ Z

pMatrix3=NewMatrix(pMatrix1->Dim[0],pMatrix1->Dim[1]);        //生成新矩阵 
9 I  R' p5 p- O( J: _
                if(!pMatrix3) break;. `0 E, H) k. t5 d$ d9 j) T7 e

for(i=0;i<pMatrix1->ArrayLen;i++) pMatrix3->Array[i]=pMatrix1->Array[i]*pMatrix2->Array[i];        //矩阵点乘$ g: B- q. m4 j: X

FunReObj(hFor);        //告诉Lu，返回一个动态对象 
3 ?9 ?9 \7 q% C
                a.BType=Matrix; a.VType=Matrix; a.x=0; *(luVOID *)&(a.x)=(luVOID)pMatrix3; 
7 {& L9 @) X# Y
                break; 
- a' @) Z# \/ b: T, `/ p
        case 46:        //重载函数new' w6 K# |: e+ _# O# w

if(mm<2) break;0 Y+ b4 m$ O, f1 _' n

if((xx+1)->x<1 || (xx+2)->x<1 || (xx+1)->BType!=luStaData_int64 || (xx+2)->BType!=luStaData_int64) break;9 W6 o' C7 X( i. C1 |+ q/ K# M

pMatrix3=NewMatrix((luVOID)(xx+1)->x,(luVOID)(xx+2)->x);//生成新矩阵 
& s' ?$ g- r& s6 T\\" {
                if(!pMatrix3) break;, A8 ^) q; N& J+ ?

for(j=0,i=3;i<=mm;i++,j++)        //赋初值7 @\\" s' r2 G% [6 i, q: n

{: m5 C6 V; `/ Y/ e

if(j>=pMatrix3->ArrayLen) break;\\" j1 `. o% q* G\\" t+ W9 j/ m

if((xx+i)->BType!=luStaData_double) break;        //只接受实数参数 
( J5 `. o, `) x, s% F0 x0 T5 K2 ]
                        pMatrix3->Array[j]=*(double *)&((xx+i)->x); 
\\" L8 o5 L6 q# {( `. j) M6 V
                } 
# P3 _$ ~4 m% H
                FunReObj(hFor);        //告诉Lu，返回一个动态对象 
4 S7 u: c' h. B, B! v
                a.BType=Matrix; a.VType=Matrix; a.x=0; *(luVOID *)&(a.x)=(luVOID)pMatrix3;+ O1 M4 p  X- o2 p. o

break;+ x; k2 u/ y2 b; ^; Y

case 49:        //重载函数o 
  }) u. ]% U, @% ]& I% i
                pMessage=(luMessage)SearchKey("\0\0\0\0",sizeof(luVOID),luPubKey_User);! I* ~* Q% [* \1 y* V6 H* A

if(!pMessage) break; 
0 R6 U\\" P' G; P* b4 u8 v
                pMatrix1=(myMatrix *)SearchKey((char *)&(xx->x),sizeof(luVOID),Matrix);2 m5 V/ {3 f( b' A5 ?' S% l# h- q

if(!pMatrix1) break;        //对象句柄无效，不是矩阵9 o& q# w- h, t( n% W2 J0 @

pa=pMatrix1->Array; 
# i8 u+ O4 B% S9 a2 t  r
                m=pMatrix1->Dim[0]; n=pMatrix1->Dim[1]; k=0; 
* C# P; O7 i  Z! X7 l, Y: l) g5 S
                for(i=0; i<m; i++)        //输出矩阵 
9 R4 h9 \' d  w! ]' J1 ^1 q
                { 
& b0 z) G# [) `8 {
                        pMessage(L"\r\n"); k+=2; 
; E: g  U& \/ y- U* p
                        for(j=0; j<n; j++) 
) C+ q- X1 x4 i8 }\\" q
                        {, i2 F0 j- j\\" ~1 t  A0 A

_gcvt_s(chNum,pa[i*n+j],16); 
( [3 g$ G( q% c& R
                                for(u=0;chNum[u];u++) {wchNum[u]=chNum[u]; k++;} 
' y$ \# O1 a7 ?3 i' L3 S# ]
                                wchNum[u]='\0'; 
6 X3 Y: a( j. I& o
                                pMessage(wchNum); pMessage(L"  "); k+=2; 
+ ^. o/ D. }' Y# n
                        }/ q$ P; F. u  C/ U, M

}4 n9 n1 H0 I: z5 C0 a( |

pMessage(L"\r\n"); k+=2;4 G: x0 o( v! P/ W

a.BType=luStaData_int64; a.VType=luStaData_int64; a.x=k;        //按函数o的要求，返回输出的字符总数- {0 x' p: z& q+ u9 d

break;) p8 _! x4 \- k, _& Z9 L

default:4 |% f9 T' S/ ]. S8 Y  [) p( `. _

break;; I. N+ y6 U8 Y/ R5 _

}/ m4 i; Q' N) V' Y* l9 o

return a;- {! v# }2 {. U

} 
- E/ C  F6 t( y5 U. N, c, V  q
void main(void): H/ w* f\\" b7 S) q5 W/ O

{  e0 o0 A) f* Z& T8 R& f

void *hFor;                //表达式句柄% `# g5 K' d8 ~- o* g

luINT nPara;                //存放表达式的自变量个数0 q: X- _7 `0 N/ ^( u  b6 B

LuData *pPara;                //存放输入自变量的数组指针. q2 @% E( n. u0 m3 N4 B

luINT ErrBegin,ErrEnd;        //表达式编译出错的初始位置和结束位置 
: A  c, b0 O! y. \. a: g- L- J
        int ErrCode;                //错误代码% T+ K) Y0 ?( ^6 [; Q

void *v; 
$ A/ ~0 M( C, @% {1 \
        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.]}";//字符串表达式，矩阵乘0 ~6 ]% ]& o* 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.]}";//字符串表达式，矩阵点乘# N( Z' f4 o9 b4 o\\" e% D% j

LuData Val; 
( `% b; K+ \# S! q, p; Z
        if(!InitLu()) return;        //初始化Lu. }$ i, f+ Q% i4 y+ _( @8 N

while(LockKey(Matrix,DelMatrix,OpMatrix)){Matrix--;}        //锁定一个键，用于存储矩阵扩展类型 
4 b8 I- J  U& L2 N4 F
- B' Z3 d9 E: R  \

Val.BType=luStaData_int64; Val.VType=luStaData_int64; Val.x=Matrix;        //定义整数常量1 i6 M9 }* V5 k4 [

SetConst(L"matrix",&Val);        //设置整数常量 
* k5 a( v5 O+ }\\" I3 M0 K, D4 g6 p
        InsertKey("\0\0\0\0",4,luPubKey_User,LuMessage,NULL,NULL,1,v); //使Lu运行时可输出函数信息. w( k$ r  A2 U

wcout.imbue(locale("chs"));        //设置输出的locale为中文 
) W' W; |\\" p8 Q& [) m
   
  }7 I* Y; D$ j2 k, \
        ErrCode=LuCom(ForStr,0,0,0,hFor,nPara,pPara,ErrBegin,ErrEnd); //编译表达式- D: R& u& J7 K. d8 {0 N% ]

if(ErrCode) 
) s% `) u! y- O
        { 
# S) z- h) y7 b$ W& p4 l; K
                wcout<<L"表达式有错误！错误代码："<<ErrCode<<endl;: f: A) ~, h7 O2 n- D1 f3 |, I  t; p

} 
9 c( P: _. j, g$ o6 |
        else 
% B3 }, i) m& ?9 v) M
        {: G0 l$ C% u- e6 d7 p' f* P- u, a

LuCal(hFor,pPara);        //计算表达式的值; K% T& |* }8 T$ b

}: A) w7 A3 x* o\\" Y7 G- w# V

LockKey(Matrix,NULL,OpMatrix);//解锁键Matrix，本例中，该函数可以不用. a4 |\\" y& M9 v1 Q

FreeLu();                        //释放Lu 
- y) o5 O+ y2 Q* r# z
}

习题：

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

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

main(:a,b,c,d,t,i)=. X5 a) }4 A7 ~* U7 n
a=new[matrix,2,2: 1.,2.,2.,1.],( Y3 ^, n% ^$ T7 c* Q- u
b=new[matrix,2,2: 2.,1.,1.,2.],
\" _7 R; Z$ ?, c! H( L( V
c=new[matrix,2,2: 2/3.,-1/3.,-1/3.,2/3.],
: o, t1 d\" G+ H3 D
t=clock(),
# u; s- [9 k9 Q, A
d=a*b, i=0, while{i<1000000, d=d*c*b, i++},
7 `8 y Z2 }% J0 m
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\"}";//字符串表达式

复制代码

结果：