QQ登录

只需要一步,快速开始

 注册地址  找回密码
查看: 8670|回复: 2
打印 上一主题 下一主题

Lu基于系统内置对象创建扩展数据类型,小矩阵乘效率测试

[复制链接]
字体大小: 正常 放大
forcal 实名认证       

45

主题

3

听众

282

积分

升级  91%

  • TA的每日心情
    难过
    2012-8-27 18:22
  • 签到天数: 1 天

    [LV.1]初来乍到

    跳转到指定楼层
    1#
    发表于 2011-10-23 09:37 |只看该作者 |倒序浏览
    |招呼Ta 关注Ta
        本例中,我们将基于系统内置实数数组创建矩阵(matrix)类型,即:基本类型为luDynData_realarray(标识实数数组),扩展类型为matrix(标识矩阵)。为了简单,我们仅处理二维实数数组即矩阵类型。) a8 R# v, P; x) n4 Z9 b
      _* o( i1 x2 L
        基本要点:% a. n3 c0 w: Q! @+ U8 Q

    4 \! A/ X, h" ?, g- A/ G+ ~& G, s0 t    (1)为扩展类型matrix编写运算符重载函数OpMatrix。
    2 k8 g( |1 \+ X2 I" d7 J) B' M2 _% K
    9 R5 j3 B. w' F! f# T9 I    (2)用函数LockKey将重载函数OpMatrix注册到Lu,锁定的键的类型即为matrix,要注册为常量,以便于使用。2 x& ?6 [6 N/ d2 Z) e/ a5 P5 D9 R
      v8 H9 U8 t# V/ H+ P, F2 v
        (3)为扩展类型matrix编写其他操作函数(本例未提供)。; a" U; o% i0 b3 C4 X3 B. C' H

    7 Z- R9 ?8 F0 m    (4)用函数LockKey解锁键matrix(本例中,程序退出时会自动解锁,故可以不用)。
    1. #include <windows.h>' t+ ]% h\\" P) \; x( t. H  h# M2 c4 Z
    2. #include <iostream>! X! O+ N, {0 M) Q- T
    3. #include <math.h># R9 G) q! s( h% f, o
    4. #include "lu32.h"9 @, A0 e' M) G/ W1 Q

    5. ' k3 F\\" ^4 R\\" P6 Y' y4 ]' e
    6. #pragma comment( lib, "lu32.lib" )
    7. & h1 f- x  _# i$ ^- h: s7 v
    8. - u, n# [; H9 p9 f; b+ _
    9. using namespace std;* @) {* [8 G/ [& D

    10. 8 z( g3 q. j; @4 O5 B. Q
    11. luKEY Matrix=-1000;        //标识矩阵类型,最终的Matrix由LockKey决定8 D: g* m\\" G) n: M7 P* U

    12. + t2 y6 v# x2 i& F& r6 y& I% X
    13. void _stdcall LuMessage(wchar_t *pch)//输出动态库信息,该函数注册到Lu,由Lu二级函数调用
    14. * r$ G& Q8 C/ N1 Z! l$ B
    15. {
    16. 7 T7 \& p5 @! J: ]/ r8 u
    17.         wcout<<pch;
    18. + K4 {, r8 z/ g. E; G\\" K) E- k5 }
    19. }* k$ d# O( K& R3 T
    20. void _stdcall DelMatrix(void *me)        //用于LockKey函数,因为是基于系统内置实数数组创建矩阵,故该函数什么也不做
    21. $ D5 v# e- S* l, u: r  Y
    22. {4 n- u- v: o9 _5 l1 R+ |. i3 Z
    23. }3 Q5 h' f( C, ^/ m
    24. LuData _stdcall OpMatrix(luINT mm,LuData *xx,void *hFor,int theOperator)        //运算符重载函数,用于LockKey函数
    25. $ A2 H, }9 n8 y) p
    26. {% ~. U) N, J+ t+ w% s
    27.         LuData a;/ l* m5 V2 l0 A: u* g
    28.         luRealArray *pRealArray1,*pRealArray2,*pRealArray3;
    29. ( ~5 r' U2 C7 G' I/ H
    30.         luVOID i,j,k,m,n,u,v;
    31. ! a8 z- m/ d, f. {! ~# O- Q: X. D
    32.         double *pa,*pb,*pc;\\" A+ E4 n! I$ W: S0 \0 A* f) v
    33.         luMessage pMessage;
    34. ' }) |, O7 L) D( Q
    35.         wchar_t wchNum[32];
    36. * L7 y\\" _! Y: P, o
    37.         char chNum[32];
    38. ' [% u% I2 [\\" i& {. g( ^  d. o& Q
    39.         a.BType=luStaData_nil; a.VType=luStaData_nil; a.x=0;/ h& i( Y5 m5 I
    40.         switch(theOperator)
    41. $ C/ i) @, G+ ?( V) a; y/ u
    42.         {, Q- T9 g\\" F8 V
    43.         case 2:        //重载运算符*8 T. l, r8 p) C! U5 B
    44.                 pRealArray1=(luRealArray *)SearchKey((char *)&(xx->x),sizeof(luVOID),luDynData_realarray);
    45. & `+ Z+ W\\" `7 s1 D
    46.                 pRealArray2=(luRealArray *)SearchKey((char *)&((xx+1)->x),sizeof(luVOID),luDynData_realarray);6 C. {( _# y3 _6 \: @- \( U9 T
    47.                 if(!pRealArray1 || !pRealArray2) break;        //对象句柄无效,不是实数数组1 B5 ?+ {; s& A( |$ B
    48.                 if(pRealArray1->DimLen!=2 || pRealArray2->DimLen!=2) break;        //不是二维实数数组(矩阵)) c0 ]1 [0 H* o/ z+ {/ b
    49.                 if(pRealArray1->Dim[1]!=pRealArray2->Dim[0]) break;        //维数不匹配. S9 _& d( G; z8 x: K9 c% H1 j
    50.                 pRealArray3=(luRealArray *)NewSysObj(luDynData_realarray,pRealArray1->Dim[0]*pRealArray2->Dim[1],2);        //创建矩阵对象4 _+ d3 R  i4 i
    51.                 if(!pRealArray3) break;
    52. ) ~! O' N( o, Z9 t, }  p5 [
    53.                 pRealArray3->Dim[0]=pRealArray1->Dim[0]; pRealArray3->Dim[1]=pRealArray2->Dim[1];        //设置矩阵维数大小
    54.   [/ k# S7 t9 W1 \) H' o+ [
    55.                 pa=pRealArray1->Array; pb=pRealArray2->Array; pc=pRealArray3->Array;
    56. & U: P7 Q* a' W' E( _
    57.                 m=pRealArray1->Dim[0]; n=pRealArray1->Dim[1]; k=pRealArray2->Dim[1];
    58. + v0 _9 ~( [- G4 }& L5 g
    59.                 for(i=0; i<m; i++)        //矩阵乘
    60. 4 k: z; e1 G; Y( ~( V, x
    61.                 {; D4 H# {8 G6 D
    62.                         for(j=0; j<k; j++)+ M5 q* S+ t( ]6 }
    63.                         {( [9 D& K! f) g! Z2 m3 `
    64.                                 u=i*k+j; pc[u]=0.0;
    65. ( i3 o) R( k5 V1 J9 H) y# A( a5 x
    66.                                 for (v=0; v<n; v++)2 ?\\" [0 e/ Y' ^& F
    67.                                 {
    68. , q! C  W* {( F0 `
    69.                                         pc[u]=pc[u]+pa[i*n+v]*pb[v*k+j];
    70. % }2 q: U- M; `
    71.                                 }5 n9 l% k/ l2 G. L
    72.                         }
    73. % m, j$ b6 [: x8 U6 ?
    74.                 }4 J3 t6 a. q5 y% Z, c* ?8 i; |& h
    75.                 FunReObj(hFor);        //告诉Lu,返回一个动态对象1 N9 S  \7 f7 j; D, J4 r
    76.                 a.BType=luDynData_realarray; a.VType=Matrix; a.x=0; *(luVOID *)&(a.x)=(luVOID)pRealArray3;
    77. % ^7 B; I6 ]& Y6 K2 G% F% I, Y1 D\\" c
    78.                 break;. `' ^% ^* r\\" B+ g
    79.         case 25:        //重载运算符.*
    80. & q' c8 i3 v2 v9 B
    81.                 pRealArray1=(luRealArray *)SearchKey((char *)&(xx->x),sizeof(luVOID),luDynData_realarray);+ R& d- r! w\\" T+ o
    82.                 pRealArray2=(luRealArray *)SearchKey((char *)&((xx+1)->x),sizeof(luVOID),luDynData_realarray);
    83. 8 A4 Q5 d* w& y7 V* a: o# L) K
    84.                 if(!pRealArray1 || !pRealArray2) break;        //对象句柄无效,不是实数数组7 ?* Y9 I/ W6 u# }& v5 @
    85.                 if(pRealArray1->DimLen!=2 || pRealArray2->DimLen!=2) break;        //不是二维实数数组(矩阵)8 F, O$ _8 Y9 d4 ~
    86.                 if(pRealArray1->Dim[0]!=pRealArray2->Dim[0] || pRealArray1->Dim[1]!=pRealArray2->Dim[1]) break;        //维数不相同9 m# F7 d4 }  s7 X; z% B- F0 G: X: [
    87.                 pRealArray3=(luRealArray *)NewSysObj(luDynData_realarray,pRealArray1->ArrayLen,2);        //创建矩阵对象# k; w! C% Y) U6 P+ l' ^7 v/ N
    88.                 if(!pRealArray3) break;$ C* Z! B: J+ ~- J) r% Y: T
    89.                 pRealArray3->Dim[0]=pRealArray1->Dim[0]; pRealArray3->Dim[1]=pRealArray1->Dim[1];        //设置矩阵维数大小# ?# U3 \8 a  T
    90.                 for(i=0;i<pRealArray1->ArrayLen;i++) pRealArray3->Array[i]=pRealArray1->Array[i]*pRealArray2->Array[i];//矩阵点乘
    91.   e0 V+ e! k/ K; r
    92.                 FunReObj(hFor);        //告诉Lu,返回一个动态对象
    93. # o0 Y5 D0 O0 F
    94.                 a.BType=luDynData_realarray; a.VType=Matrix; a.x=0; *(luVOID *)&(a.x)=(luVOID)pRealArray3;
    95. % ]2 f/ Y: Z! l
    96.                 break;0 h5 U6 J% j( d2 j0 H* N
    97.         case 46:        //重载函数new; W, B/ O- L( v. t# }
    98.                 a=ExeOperator(mm,xx,hFor,theOperator,luDynData_realarray);        //直接调用基本类型luDynData_realarray的new函数% p% x( K' t% o0 Z5 N' ]  C
    99.                 if(a.VType==luDynData_realarray) a.VType=Matrix;        //设置扩展类型为自定义的Matrix类型
    100. + `# P* z! s1 Q6 z
    101.                 break;
    102. ; ?; E/ V- A+ \1 J% e5 v
    103.         case 49:        //重载函数o' _4 J/ r/ N& J- s$ z, s
    104.                 pMessage=(luMessage)SearchKey("\0\0\0\0",sizeof(luVOID),luPubKey_User);7 G3 n2 X9 ]7 D\\" ]
    105.                 if(!pMessage) break;. w: V  G& Y1 F5 k8 U: ]) P: \
    106.                 pRealArray1=(luRealArray *)SearchKey((char *)&(xx->x),sizeof(luVOID),luDynData_realarray);
    107. ) R$ h7 t  s& u6 A. P. {! G: `
    108.                 if(!pRealArray1) break;        //对象句柄无效,不是实数数组% G/ o0 n2 A, s' ]
    109.                 if(pRealArray1->DimLen!=2) break;        //不是二维实数数组(矩阵)
    110. ! f* n9 l; I+ Q
    111.                 pa=pRealArray1->Array;1 z! W: z' n2 J3 E
    112.                 m=pRealArray1->Dim[0]; n=pRealArray1->Dim[1]; k=0;
    113. 0 Q3 M& o\\" ^; K0 s) c: N
    114.                 for(i=0; i<m; i++)        //输出矩阵
    115. ) m, B& [' o\\" X) ?
    116.                 {
    117. & y! F3 M6 C2 a. g% B. Y
    118.                         pMessage(L"\r\n"); k+=2;3 J5 l( f$ _( I' _. b' d
    119.                         for(j=0; j<n; j++)7 u5 C4 _5 p7 `, H# g: z* e2 Z
    120.                         {/ R: W! T! k2 w- C: K! H8 A
    121.                                 _gcvt_s(chNum,pa[i*n+j],16);7 X- x+ S* ^# G- i$ M& f& d/ A% D
    122.                                 for(u=0;chNum[u];u++) {wchNum[u]=chNum[u]; k++;}4 l5 Y# {/ k# m. w' G
    123.                                 wchNum[u]='\0';9 J8 }! s6 n; T/ B
    124.                                 pMessage(wchNum); pMessage(L"  "); k+=2;7 O/ J4 j3 A: {* Z2 R
    125.                         }0 F( R) o7 `/ j; _) U9 r; v
    126.                 }
    127. 8 S3 H4 h0 X; r+ I0 V* i/ _5 z
    128.                 pMessage(L"\r\n"); k+=2;
    129. * Z- M! K% H\\" p; ]8 N, X6 q
    130.                 a.BType=luStaData_int64; a.VType=luStaData_int64; a.x=k;        //按函数o的要求,返回输出的字符总数. I1 \\\" O3 B) z5 M! V! l6 E9 H, W
    131.                 break;: @5 e. l, d7 G* @0 Y& z- m
    132.         default:
    133. ! T0 ]# {- V: g. T( w( @
    134.                 break;
    135. 6 t5 k! C- ^; z5 U7 k
    136.         }4 z7 j9 k+ P\\" g9 C/ v0 Z( a
    137.         return a;
    138. ) ?, B/ e) L& F' t0 J\\" L) A
    139. }$ B' ?0 P7 l2 M8 Q
    140. void main(void)$ _0 a1 h0 H& D  {7 w
    141. {
    142. : V1 u\\" e* {; }! s3 N! W\\" t3 n
    143.         void *hFor;                //表达式句柄: R, j2 s$ _# \2 H& A
    144.         luINT nPara;                //存放表达式的自变量个数
    145. 1 p2 w) Z+ K7 m( p; I
    146.         LuData *pPara;                //存放输入自变量的数组指针8 |+ S9 ]. ?; b8 L  @! w
    147.         luINT ErrBegin,ErrEnd;        //表达式编译出错的初始位置和结束位置
    148. 0 D( m0 f9 ?\\" r. d3 a8 p\\" p: v
    149.         int ErrCode;                //错误代码3 d' z, }0 M8 R7 k7 q1 Q$ s  G% Y
    150.         void *v;# y% }2 _0 x9 q+ ]/ O3 ]
    151.         wchar_t ForStr[]=L"o{new[matrix,2,3,data: 0.,1.,2.;3.,4.,5.]*new[matrix,3,2,data: 1.,2.;3.,4.;5.,6.]}";//字符串表达式,矩阵乘$ q/ N) o6 d( @1 `, Q
    152.         //wchar_t ForStr[]=L"o{new[matrix,2,3,data: 0.,1.,2.;3.,4.,5.].*new[matrix,2,3,data: 1.,2.,3.;4.,5.,6.]}";//字符串表达式,矩阵点乘
    153. 3 I$ j' }$ q- P/ U/ `\\" P
    154.         LuData Val;! S, @  l$ b) m$ a' H
    155.         if(!InitLu()) return;        //初始化Lu7 \6 a3 T, I. l* C! B
    156.         while(LockKey(Matrix,DelMatrix,OpMatrix)){Matrix++;}        //锁定一个键,用于存储矩阵扩展类型6 X\\" g\\" H. ]0 Z9 S
    157. / j* n2 X6 a0 D) D\\" Q
    158.         Val.BType=luStaData_int64; Val.VType=luStaData_int64; Val.x=Matrix;        //定义整数常量
    159. + a- B+ h3 E' \2 v' H6 \! [
    160.         SetConst(L"matrix",&Val);        //设置整数常量' }* g6 `! Q# {7 Q% n
    161.         InsertKey("\0\0\0\0",4,luPubKey_User,LuMessage,NULL,NULL,1,v); //使Lu运行时可输出函数信息+ ^. ?$ c9 Q4 _, z3 v( a# h
    162.         wcout.imbue(locale("chs"));        //设置输出的locale为中文
    163. 9 s8 f- E: v5 y4 W; e/ _
    164.   
    165. / J  {- ~( }9 Y( D% X3 f
    166.         ErrCode=LuCom(ForStr,0,0,0,hFor,nPara,pPara,ErrBegin,ErrEnd); //编译表达式
    167. 5 [3 C- c) `# Q: B. ^+ D
    168.         if(ErrCode)9 e5 O% [6 h+ ]
    169.         {6 y4 L) C7 a% D. F8 |\\" X
    170.                 wcout<<L"表达式有错误!错误代码:"<<ErrCode<<endl;
    171. \\" x& s+ g# x. A* N) M# P0 B
    172.         }0 |8 u, d# S/ U0 G2 ~0 {8 ^
    173.         else% G$ i$ Q$ f+ g3 B% O: g
    174.         {  _, K# v: x9 B# Z; c
    175.                 LuCal(hFor,pPara);        //计算表达式的值1 d8 L* v7 r+ d\\" i
    176.         }# H7 @' B( Z1 K( j, u. [3 ^9 |
    177.         LockKey(Matrix,NULL,OpMatrix);//解锁键Matrix,本例中,该函数可以不用
    178. 1 }. K6 t' _0 d8 B
    179.         FreeLu();                        //释放Lu
    180. 8 l6 I+ ^, i\\" e) l9 j) _  Q
    181. }
    习题:: l; k( y7 b' y4 B' Z7 W& J2 V

      `: m. L+ z9 n! R    (1)自定义矩阵的加、减、左除、右除、点左除等运算,自编测试字符串代码,重新编译运行程序,观察计算结果。
    / E8 l0 G' t% @7 U! L0 H2 m$ R7 x( V7 m) v) D' T2 M
        (2)小矩阵乘效率测试。编译运行以下Lu字符串代码:
    1. main(:a,b,c,d,t,i)=
      # _( K) l8 Y! P* c
    2.     a=new[matrix,2,2,data:1.,2.,2.,1.],
      0 U/ g8 N/ \+ u/ A
    3.     b=new[matrix,2,2,data:2.,1.,1.,2.],: O* w% u7 u2 J( P2 h6 [$ M
    4.     c=new[matrix,2,2,data:2/3.,-1/3.,-1/3.,2/3.],$ u6 Y7 |2 a. Z% X
    5.     t=clock(),' c/ ~) E6 W& \, m4 Z# {4 U
    6.     d=a*b, i=0, while{i<1000000, d=d*c*b, i++},
      ! @% q* u' r\" g( P
    7.     o{d, "time=",[clock()-t]/1000.," seconds.\r\n"}
    复制代码
    C/C++中的字符串定义为:
    1. wchar_t ForStr[]=L"main(:a,b,c,d,t,i)= a=new[matrix,2,2,data:1.1,2.,2.,1.], b=new[matrix,2,2,data:2.,1.,1.,2.], c=new[matrix,2,2,data: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\"}";//字符串表达式
    复制代码
    结果:
    1. 4. 5.
      , a6 `4 e3 |7 [; T% ~
    2. 5. 4.
      9 t2 ^( f) r6 R( p% s\" @$ j
    3. time=0.875 seconds.
      / I: r. I. A* `. i' o/ b4 ?
    4. 请按任意键继续. . .
    复制代码
    Matlab 2009a 代码:
    1. a=[1.,2.;2.,1.];
      $ C5 q) c\" A+ l\" A+ @+ s% g\" P
    2. b=[2.,1.;1.,2.];7 |' T/ R7 r2 m, {7 ?/ [% N
    3. c=[2/3.,-1/3.;-1/3.,2/3.];( s8 U: d3 _9 M( A% S
    4. tic,' p0 q. R2 V% K$ j: @8 j0 A\" h
    5. d=a*b;9 A  M) E1 p5 L+ b; I
    6. for i=1:1000000
      4 B, x  P* K! y& Q& `
    7.     d=d*c*b;
      : r- O2 K  g/ Q) r& I# i
    8. end
      5 p, ^+ C\" ?+ N$ a/ L4 a8 s$ x
    9. d,
      / W\" ]. Z# F6 s+ d. ]& e
    10. toc
    复制代码
    结果:
    1. d =! E4 Z( }6 v1 a0 s
    2.      4     5
      4 S3 L% }, h6 {- a) R
    3.      5     4- k! R. q4 D8 i) X
    4. Elapsed time is 2.903034 seconds.
    复制代码
    本例矩阵乘效率测试,Lu的速度超过了Matlab,主要在于Lu有更高的动态对象管理效率。
    1 X7 c1 l& }7 C+ I7 v8 u3 A: c( P
    zan
    转播转播0 分享淘帖0 分享分享0 收藏收藏0 支持支持0 反对反对0 微信微信
    2#
    无效楼层,该帖已经被删除
    3#
    无效楼层,该帖已经被删除
    您需要登录后才可以回帖 登录 | 注册地址

    qq
    收缩
    • 电话咨询

    • 04714969085
    fastpost

    关于我们| 联系我们| 诚征英才| 对外合作| 产品服务| QQ

    手机版|Archiver| |繁體中文 手机客户端  

    蒙公网安备 15010502000194号

    Powered by Discuz! X2.5   © 2001-2013 数学建模网-数学中国 ( 蒙ICP备14002410号-3 蒙BBS备-0002号 )     论坛法律顾问:王兆丰

    GMT+8, 2026-4-10 03:00 , Processed in 0.355390 second(s), 63 queries .

    回顶部