QQ登录

只需要一步,快速开始

 注册地址  找回密码
查看: 9164|回复: 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(标识矩阵)。为了简单,我们仅处理二维实数数组即矩阵类型。' |* |! Z4 B  }2 I3 Q3 P# u
    " p8 \1 e: f/ x9 h: Z1 L* `! l+ V
        基本要点:
    2 [. `3 U; X' U1 h( Y! @6 v3 T# m
        (1)为扩展类型matrix编写运算符重载函数OpMatrix。
    " @* ]; z9 s0 R9 f3 g& x7 j: t7 `. z4 {, l; m) F, v, Z" A
        (2)用函数LockKey将重载函数OpMatrix注册到Lu,锁定的键的类型即为matrix,要注册为常量,以便于使用。
    7 K. U  C( u6 a: Y3 Z& I0 R* h7 f; u
        (3)为扩展类型matrix编写其他操作函数(本例未提供)。
    3 t6 u& w( I) `3 R
    $ z; a2 l. U- P4 O    (4)用函数LockKey解锁键matrix(本例中,程序退出时会自动解锁,故可以不用)。
    1. #include <windows.h>6 k* _2 i( U) y
    2. #include <iostream>: T' j9 A0 W% U1 B# b, ?. b
    3. #include <math.h>
    4. 7 l. W: Q, C  i
    5. #include "lu32.h"$ k# \) u) i1 z* y6 u

    6. 0 g1 V( {/ i2 u
    7. #pragma comment( lib, "lu32.lib" )
    8. - O3 `4 N* e0 r+ r' U  c

    9. : G6 g# ]+ c) n: L6 c/ Q5 X/ c
    10. using namespace std;
    11. ) c, D, Q$ U3 N8 Y/ ?2 z

    12. 4 ?4 G1 `6 w. S
    13. luKEY Matrix=-1000;        //标识矩阵类型,最终的Matrix由LockKey决定
    14. . k7 ?5 J& w7 C$ g
    15. + ^: Q+ q7 S/ p7 s/ K2 ^% ~1 X
    16. void _stdcall LuMessage(wchar_t *pch)//输出动态库信息,该函数注册到Lu,由Lu二级函数调用
    17. ( w; P. ~3 A1 Z( S3 I0 w2 ~
    18. {! C4 X2 f3 a) w7 k) D
    19.         wcout<<pch;
    20. ! t4 z* C7 ^* x6 u; p$ b
    21. }
    22. $ `3 r' ]- P+ p. W( T
    23. void _stdcall DelMatrix(void *me)        //用于LockKey函数,因为是基于系统内置实数数组创建矩阵,故该函数什么也不做$ A) X! ?$ r! B% S3 }
    24. {
    25. \\" k; Y, T6 j- `' `
    26. }* K; {# P# s6 U
    27. LuData _stdcall OpMatrix(luINT mm,LuData *xx,void *hFor,int theOperator)        //运算符重载函数,用于LockKey函数
    28. 7 L6 j- M\\" D8 t( y1 e8 ~6 |' |6 P: U
    29. {
    30. $ Z3 V' c  g7 X) d0 e$ q
    31.         LuData a;* s4 k1 Z, p( I5 u) ~3 \( u
    32.         luRealArray *pRealArray1,*pRealArray2,*pRealArray3;
    33. 4 a# C. m\\" g# ], ?8 O! J\\" f5 H
    34.         luVOID i,j,k,m,n,u,v;, h2 W9 j\\" ]8 V/ j- R2 V  C
    35.         double *pa,*pb,*pc;
    36. ! G, f1 M7 N' N5 D
    37.         luMessage pMessage;
    38. ! d2 e' j4 y. a  r+ X
    39.         wchar_t wchNum[32];
    40. 7 S& v; ?3 T3 c% E4 f, O: s, K
    41.         char chNum[32];  D9 `- f6 d1 `9 B  b
    42.         a.BType=luStaData_nil; a.VType=luStaData_nil; a.x=0;
    43. & r\\" }4 f! L4 N7 X, M
    44.         switch(theOperator)$ u: T. p$ b\\" q\\" b- m% r
    45.         {
    46. % b$ N- h6 Z9 I- o  K: K
    47.         case 2:        //重载运算符*
    48. 2 \2 n4 R/ n7 ?  z9 a\\" j\\" ?
    49.                 pRealArray1=(luRealArray *)SearchKey((char *)&(xx->x),sizeof(luVOID),luDynData_realarray);& r1 s  W' [2 s4 G\\" ~
    50.                 pRealArray2=(luRealArray *)SearchKey((char *)&((xx+1)->x),sizeof(luVOID),luDynData_realarray);& y5 ^- d  s3 m4 H( I; d
    51.                 if(!pRealArray1 || !pRealArray2) break;        //对象句柄无效,不是实数数组4 ~: A' M9 B$ ~/ Y& K3 w\\" e, z( @
    52.                 if(pRealArray1->DimLen!=2 || pRealArray2->DimLen!=2) break;        //不是二维实数数组(矩阵)- Q- N$ P) k# j5 _. B5 n& H
    53.                 if(pRealArray1->Dim[1]!=pRealArray2->Dim[0]) break;        //维数不匹配
    54. , s$ ~! P) |: \0 ?4 C, Z+ N# k7 \
    55.                 pRealArray3=(luRealArray *)NewSysObj(luDynData_realarray,pRealArray1->Dim[0]*pRealArray2->Dim[1],2);        //创建矩阵对象
    56. 0 }: n+ X- N& g0 B1 {1 [6 _9 w& p
    57.                 if(!pRealArray3) break;2 o/ W/ P# v. @; p$ Z
    58.                 pRealArray3->Dim[0]=pRealArray1->Dim[0]; pRealArray3->Dim[1]=pRealArray2->Dim[1];        //设置矩阵维数大小( C1 b. i7 K4 _# l; s% Y\\" \9 c
    59.                 pa=pRealArray1->Array; pb=pRealArray2->Array; pc=pRealArray3->Array;
    60. % z' P* L3 v/ G: m- P3 F
    61.                 m=pRealArray1->Dim[0]; n=pRealArray1->Dim[1]; k=pRealArray2->Dim[1];/ n# k  ?6 j8 b5 Y\\" k0 P) g  ^& o
    62.                 for(i=0; i<m; i++)        //矩阵乘
    63. : ?% V5 m- y% H! O% V4 D
    64.                 {% m\\" C, H# @6 Y' ]
    65.                         for(j=0; j<k; j++)\\" k+ v: |, X5 u: X- }$ v5 b3 d
    66.                         {7 X$ N5 h0 \8 j+ M
    67.                                 u=i*k+j; pc[u]=0.0;% C0 G  x: [\\" ]  @( K
    68.                                 for (v=0; v<n; v++)( }# `3 ~/ T* H- Q: N, a
    69.                                 {2 Q) b# U  U; Z; k) t
    70.                                         pc[u]=pc[u]+pa[i*n+v]*pb[v*k+j];
    71. / d: A; M) {# ~4 S' t& h
    72.                                 }4 P. d% a. Y6 j. G9 c: Q
    73.                         }
    74. . w0 ^5 w/ V& _7 m/ ]  g9 v
    75.                 }  Z. R\\" S7 ?7 O
    76.                 FunReObj(hFor);        //告诉Lu,返回一个动态对象* m. i6 J& y# ]2 F% N+ q6 x
    77.                 a.BType=luDynData_realarray; a.VType=Matrix; a.x=0; *(luVOID *)&(a.x)=(luVOID)pRealArray3;
    78. $ b, H9 n8 B+ q1 ?% k
    79.                 break;
    80. 2 T+ y+ A3 j$ B- q
    81.         case 25:        //重载运算符.*4 c- |. K& M4 h9 M( j
    82.                 pRealArray1=(luRealArray *)SearchKey((char *)&(xx->x),sizeof(luVOID),luDynData_realarray);
    83. * q8 Z; K8 \; D; `
    84.                 pRealArray2=(luRealArray *)SearchKey((char *)&((xx+1)->x),sizeof(luVOID),luDynData_realarray);# z! o8 ^( v% O+ t\\" o* e
    85.                 if(!pRealArray1 || !pRealArray2) break;        //对象句柄无效,不是实数数组6 X1 a; E* g9 T* b2 n3 n! r8 c$ ^
    86.                 if(pRealArray1->DimLen!=2 || pRealArray2->DimLen!=2) break;        //不是二维实数数组(矩阵)1 F' x' R! ?0 }: y6 |2 N
    87.                 if(pRealArray1->Dim[0]!=pRealArray2->Dim[0] || pRealArray1->Dim[1]!=pRealArray2->Dim[1]) break;        //维数不相同
    88. 8 m: J0 n9 }3 ~& J6 B/ n, o9 S6 O
    89.                 pRealArray3=(luRealArray *)NewSysObj(luDynData_realarray,pRealArray1->ArrayLen,2);        //创建矩阵对象
    90. 4 g* P* u$ I1 b+ [  U2 h
    91.                 if(!pRealArray3) break;! ~& A7 G, ]9 R3 K4 ]0 r, @6 C\\" p8 p
    92.                 pRealArray3->Dim[0]=pRealArray1->Dim[0]; pRealArray3->Dim[1]=pRealArray1->Dim[1];        //设置矩阵维数大小. _: k1 q0 O9 f1 R0 B
    93.                 for(i=0;i<pRealArray1->ArrayLen;i++) pRealArray3->Array[i]=pRealArray1->Array[i]*pRealArray2->Array[i];//矩阵点乘& d& j+ X. o% T
    94.                 FunReObj(hFor);        //告诉Lu,返回一个动态对象, i( f6 ^% t* K; [; a8 }
    95.                 a.BType=luDynData_realarray; a.VType=Matrix; a.x=0; *(luVOID *)&(a.x)=(luVOID)pRealArray3;7 y1 ]0 R5 }2 \( _% U
    96.                 break;4 v. Z% m- y7 u6 H\\" F2 T& x
    97.         case 46:        //重载函数new2 N) ~# ~/ ~7 M/ k* {6 p4 k
    98.                 a=ExeOperator(mm,xx,hFor,theOperator,luDynData_realarray);        //直接调用基本类型luDynData_realarray的new函数
    99. ) h  e$ c2 f# g/ I  K
    100.                 if(a.VType==luDynData_realarray) a.VType=Matrix;        //设置扩展类型为自定义的Matrix类型! B3 Y\\" C- U0 ~# n3 g' }\\" ~' u
    101.                 break;
    102. % H( c\\" S; {/ Y# W
    103.         case 49:        //重载函数o
    104.   y& ]2 K1 R9 z  v1 _$ z  n. r5 S
    105.                 pMessage=(luMessage)SearchKey("\0\0\0\0",sizeof(luVOID),luPubKey_User);( @# Q$ A9 e# C& _\\" T
    106.                 if(!pMessage) break;
    107. & S& d+ m% h0 m/ P  @: Y$ J' s
    108.                 pRealArray1=(luRealArray *)SearchKey((char *)&(xx->x),sizeof(luVOID),luDynData_realarray);3 m5 l( |- x$ b& u
    109.                 if(!pRealArray1) break;        //对象句柄无效,不是实数数组
    110. 2 q1 B$ I) L! g4 D; ]4 y# Q, c
    111.                 if(pRealArray1->DimLen!=2) break;        //不是二维实数数组(矩阵)0 [7 G8 q0 q7 U9 }8 E
    112.                 pa=pRealArray1->Array;
    113. 4 b' [$ `8 `+ e2 a# ^9 [- K
    114.                 m=pRealArray1->Dim[0]; n=pRealArray1->Dim[1]; k=0;9 r; i9 h' n' U! m5 z) o: z
    115.                 for(i=0; i<m; i++)        //输出矩阵\\" \) e. V2 g+ A% x
    116.                 {
    117.   o+ k' a: V% \7 u% ^
    118.                         pMessage(L"\r\n"); k+=2;
    119. ) l4 i, S6 m4 |/ U
    120.                         for(j=0; j<n; j++)' i$ Z; x* o9 T! `
    121.                         {
    122. # k) g; l% G7 d\\" G2 @6 U: ]
    123.                                 _gcvt_s(chNum,pa[i*n+j],16);
    124. 8 x# W  q1 I, P8 d4 z
    125.                                 for(u=0;chNum[u];u++) {wchNum[u]=chNum[u]; k++;}
    126. + U: t0 v8 ~9 Q  v\\" F+ M& f\\" H4 X
    127.                                 wchNum[u]='\0';! A) E9 h; d/ B\\" {9 h2 B
    128.                                 pMessage(wchNum); pMessage(L"  "); k+=2;
    129. ! o' Q8 P5 o9 R4 h
    130.                         }
    131. . U3 R: P9 N- `' Z- g
    132.                 }
    133. % q$ F1 ?# j( z, n* u' P' o
    134.                 pMessage(L"\r\n"); k+=2;
    135. 7 p- M: R  H% _* e! X) D6 U3 y
    136.                 a.BType=luStaData_int64; a.VType=luStaData_int64; a.x=k;        //按函数o的要求,返回输出的字符总数# a0 _% h; B. A8 v+ j7 A& H4 N
    137.                 break;
    138. + v+ J1 [\\" U' g# H\\" p1 |; F
    139.         default:0 ?% [( P! y9 q$ |% B3 Z8 b
    140.                 break;
    141. : T* b7 L( p6 j: S\\" j
    142.         }
    143. / P$ R8 C: [2 l8 V+ `
    144.         return a;8 T5 F' T7 }) @6 |5 _- P
    145. }
    146.   e( _9 _\\" J% V
    147. void main(void)1 d7 t$ H' [' b3 d% S4 h' D
    148. {! P% n' r* v7 A# ~
    149.         void *hFor;                //表达式句柄0 o/ p3 T  {. A+ H) S7 _, s% l5 C
    150.         luINT nPara;                //存放表达式的自变量个数+ O/ ~/ @$ K6 V6 q5 `
    151.         LuData *pPara;                //存放输入自变量的数组指针8 f: G4 k! a2 W5 p
    152.         luINT ErrBegin,ErrEnd;        //表达式编译出错的初始位置和结束位置
    153. . P( A0 _' L+ r. c( D
    154.         int ErrCode;                //错误代码
    155. * W) g& N6 F) @0 F# N0 k9 g+ t# E
    156.         void *v;
    157. # ?+ I/ K4 F( T$ K$ L( U7 b9 h\\" s
    158.         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.]}";//字符串表达式,矩阵乘
    159. $ t- V8 H$ A% O  |; |9 I
    160.         //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.]}";//字符串表达式,矩阵点乘
    161. ; O- k- g1 Q, t: n. q
    162.         LuData Val;
    163. 8 m' S/ G6 ]- w3 R! w! `
    164.         if(!InitLu()) return;        //初始化Lu$ E0 B7 r9 C( K% {+ ]5 f8 A  z& H
    165.         while(LockKey(Matrix,DelMatrix,OpMatrix)){Matrix++;}        //锁定一个键,用于存储矩阵扩展类型5 Q3 s- Q$ Y1 _
    166. 6 n8 _! u) I; X( ^$ ?' }% t9 T
    167.         Val.BType=luStaData_int64; Val.VType=luStaData_int64; Val.x=Matrix;        //定义整数常量  }/ n4 t+ v! I4 o
    168.         SetConst(L"matrix",&Val);        //设置整数常量, n6 D) _) c; d  O3 I$ `! m
    169.         InsertKey("\0\0\0\0",4,luPubKey_User,LuMessage,NULL,NULL,1,v); //使Lu运行时可输出函数信息
    170. / X. t/ r$ @* M% i# m. n
    171.         wcout.imbue(locale("chs"));        //设置输出的locale为中文
    172. ' y& z$ j0 T\\" U2 ^4 \, e
    173.   7 }! X$ D8 v4 ?' ~2 S% a% D\\" K
    174.         ErrCode=LuCom(ForStr,0,0,0,hFor,nPara,pPara,ErrBegin,ErrEnd); //编译表达式/ P9 }: X, n, X7 ^5 P8 U' @' b
    175.         if(ErrCode)
    176.   Z) r- I0 f( ^$ ^7 c/ j8 s) L$ J
    177.         {
    178. + F2 G$ E- |; f) w; q6 \* V- u\\" M
    179.                 wcout<<L"表达式有错误!错误代码:"<<ErrCode<<endl;- [6 t! \/ {, M1 c3 G
    180.         }- |2 ~! {3 p$ f$ d; L
    181.         else! n$ y\\" N' a- [# i5 ]8 {- p
    182.         {
    183. 8 c1 l% e! ], Y; A1 v! u1 f# h; r
    184.                 LuCal(hFor,pPara);        //计算表达式的值
    185. ) M0 Z. S1 Q5 {
    186.         }' U' P3 G0 M9 w7 t/ O( |
    187.         LockKey(Matrix,NULL,OpMatrix);//解锁键Matrix,本例中,该函数可以不用4 h0 X7 B% W\\" Y& X$ g! k+ M& Q/ a
    188.         FreeLu();                        //释放Lu
    189. # W' N! O\\" w( ]: Y$ S
    190. }
    习题:
      D" U6 Q9 M! k4 t
      r; D& t! h- w0 i$ @: A- F    (1)自定义矩阵的加、减、左除、右除、点左除等运算,自编测试字符串代码,重新编译运行程序,观察计算结果。 ( n9 c0 X) ~' H- {! q! D# k. a
    6 k0 M% I0 p7 v! @
        (2)小矩阵乘效率测试。编译运行以下Lu字符串代码:
    1. main(:a,b,c,d,t,i)=
      / Y) f3 e; Y8 p% O* Q+ Q
    2.     a=new[matrix,2,2,data:1.,2.,2.,1.],
      6 A9 A$ @; Z6 ^4 W' U7 R
    3.     b=new[matrix,2,2,data:2.,1.,1.,2.],% b9 E5 ^\" @3 P8 `- T
    4.     c=new[matrix,2,2,data:2/3.,-1/3.,-1/3.,2/3.],1 }' q5 I4 x/ R1 h% A
    5.     t=clock(),
      ; ^/ u; ?& E1 h0 F
    6.     d=a*b, i=0, while{i<1000000, d=d*c*b, i++},5 {\" [: e1 A3 A
    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.0 u  {& B3 }4 v
    2. 5. 4., s( u$ `* Y8 `4 {
    3. time=0.875 seconds.
      ' C2 ^1 E% W% E+ c! z\" q6 a
    4. 请按任意键继续. . .
    复制代码
    Matlab 2009a 代码:
    1. a=[1.,2.;2.,1.];
      * y; i& r1 q0 C0 m\" r
    2. b=[2.,1.;1.,2.];2 N) K$ f7 r- _7 x/ K- E
    3. c=[2/3.,-1/3.;-1/3.,2/3.];
      + T8 ^4 p5 z' z6 i5 o\" H9 P
    4. tic,
      ) b& e- F5 T5 b1 O
    5. d=a*b;
      $ ?' }* M; F6 E$ _
    6. for i=1:1000000
      ' a, y! T& ~, Z) y2 r$ S
    7.     d=d*c*b;
      & @2 I8 L6 b  n7 _
    8. end
      * H  y7 s% E\" x, Z
    9. d,3 k& s* ^5 C  [! i# D
    10. toc
    复制代码
    结果:
    1. d =* J7 R  F: _# v9 G' g! r
    2.      4     5
      / q2 y# |/ e9 F% P, O
    3.      5     4( ~  l0 U0 N2 t\" o. G
    4. Elapsed time is 2.903034 seconds.
    复制代码
    本例矩阵乘效率测试,Lu的速度超过了Matlab,主要在于Lu有更高的动态对象管理效率。! e6 e' {7 k. Z
    zan
    转播转播0 分享淘帖0 分享分享0 收藏收藏0 支持支持0 反对反对0 微信微信
    2#
    无效楼层,该帖已经被删除
    3#
    无效楼层,该帖已经被删除
    您需要登录后才可以回帖 登录 | 注册地址

    fastpost qq
    收缩
    • 电话咨询

    • 04714969085

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

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

    蒙公网安备 15010502000194号

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

    GMT+8, 2026-11-23 05:39 , Processed in 0.267679 second(s), 63 queries .

    回顶部