QQ登录

只需要一步,快速开始

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

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(标识矩阵)。为了简单,我们仅处理二维实数数组即矩阵类型。
    ) y9 E; B5 W" o7 z+ s% q: k" b9 L& g" H" ^/ Z) ?
        基本要点:; Y6 x6 ?; r- k. w% |2 ?3 n: D

    + P2 p* @, C* B) d+ Q5 _+ u    (1)为扩展类型matrix编写运算符重载函数OpMatrix。
    9 ?0 u6 H* V- o  Z9 F
    ; q; h5 a& y- b1 r* m    (2)用函数LockKey将重载函数OpMatrix注册到Lu,锁定的键的类型即为matrix,要注册为常量,以便于使用。
    1 w! b8 ~& K! a0 t( v& m" }) n( M6 @; p# s. m7 r- b
        (3)为扩展类型matrix编写其他操作函数(本例未提供)。' b7 j; F& W; i

    + @+ K: ?; `1 g# R4 p( x    (4)用函数LockKey解锁键matrix(本例中,程序退出时会自动解锁,故可以不用)。
    1. #include <windows.h>
    2. ; n5 G+ M3 Z; C% c$ r# z
    3. #include <iostream>( p  a2 R+ y2 c6 f7 W
    4. #include <math.h>\\" ?# B9 r6 [) ^7 ^' [\\" q5 H
    5. #include "lu32.h"5 h3 H$ `2 D4 q+ I  O

    6. ( ^% c\\" m/ h4 q) i
    7. #pragma comment( lib, "lu32.lib" )& h9 p* R* f6 j: {4 l2 I4 U+ K+ _
    8. 9 w$ d! n% m1 v( J' ]- w
    9. using namespace std;
    10. 8 n! l. L, t8 g

    11. 6 Z\\" K0 B# J  g/ C4 D5 z' I
    12. luKEY Matrix=-1000;        //标识矩阵类型,最终的Matrix由LockKey决定
    13. # ]% c0 p2 I# r1 }  N( n2 z
    14. $ r7 |. I2 |$ p, A\\" d
    15. void _stdcall LuMessage(wchar_t *pch)//输出动态库信息,该函数注册到Lu,由Lu二级函数调用 # y% z' \2 u. ?- I4 y# \
    16. {
    17. 1 x; W# H1 L2 T& \3 i
    18.         wcout<<pch;: ^, ]+ j6 N. m% v# |2 @
    19. }
    20. / o7 @  q. A* ]$ A1 i3 t& K+ k
    21. void _stdcall DelMatrix(void *me)        //用于LockKey函数,因为是基于系统内置实数数组创建矩阵,故该函数什么也不做
    22. \\" [  a- R1 z0 ]1 r
    23. {
    24. 7 e# b6 [% r' H' Z( f% Y\\" j\\" S& _
    25. }6 S0 B, o( Y& [
    26. LuData _stdcall OpMatrix(luINT mm,LuData *xx,void *hFor,int theOperator)        //运算符重载函数,用于LockKey函数
    27. % s7 o- h) ~; y% p; u4 {
    28. {/ {0 {- s4 b; i7 F
    29.         LuData a;* O! P  T4 x& f\\" t7 c* [/ |
    30.         luRealArray *pRealArray1,*pRealArray2,*pRealArray3;
    31. ; n+ E; h/ ]6 F0 Q$ ~. V\\" d
    32.         luVOID i,j,k,m,n,u,v;9 W+ D9 ]1 e7 g2 d& m
    33.         double *pa,*pb,*pc;
    34. + L/ N) c# j' N# |$ |% s- R
    35.         luMessage pMessage;
    36. 8 W  a- E: I8 C2 F, i* V8 U) L% A
    37.         wchar_t wchNum[32];
    38. 5 f# o7 @3 R\\" a' R( }5 G: L
    39.         char chNum[32];& g\\" f' y4 G$ f7 `
    40.         a.BType=luStaData_nil; a.VType=luStaData_nil; a.x=0;
    41. 7 k3 u7 ^6 }& G* z5 `- V4 X+ h; g% u
    42.         switch(theOperator)1 m+ E& Q/ F/ K- c) m, ~1 H
    43.         {3 i# m' W# n: i2 y8 T- ~, `; y! I
    44.         case 2:        //重载运算符*1 e0 }* M% y- _- \5 L
    45.                 pRealArray1=(luRealArray *)SearchKey((char *)&(xx->x),sizeof(luVOID),luDynData_realarray);8 q3 I$ v+ ^' S7 h  `/ D) B
    46.                 pRealArray2=(luRealArray *)SearchKey((char *)&((xx+1)->x),sizeof(luVOID),luDynData_realarray);
    47. , f' }\\" O/ j8 \5 v* m
    48.                 if(!pRealArray1 || !pRealArray2) break;        //对象句柄无效,不是实数数组& G8 I7 ]. [- t+ W
    49.                 if(pRealArray1->DimLen!=2 || pRealArray2->DimLen!=2) break;        //不是二维实数数组(矩阵)
    50. - m' d& P8 d+ g* B) {; J3 {
    51.                 if(pRealArray1->Dim[1]!=pRealArray2->Dim[0]) break;        //维数不匹配
    52. 3 C  f4 L1 T3 }/ Y
    53.                 pRealArray3=(luRealArray *)NewSysObj(luDynData_realarray,pRealArray1->Dim[0]*pRealArray2->Dim[1],2);        //创建矩阵对象: x3 d! W5 \6 n& a  J) `; `% `0 m
    54.                 if(!pRealArray3) break;5 O- G- q; I' q% n
    55.                 pRealArray3->Dim[0]=pRealArray1->Dim[0]; pRealArray3->Dim[1]=pRealArray2->Dim[1];        //设置矩阵维数大小( q* T0 Z' \2 I$ ?
    56.                 pa=pRealArray1->Array; pb=pRealArray2->Array; pc=pRealArray3->Array;* U$ z\\" h# I8 ~; z; p
    57.                 m=pRealArray1->Dim[0]; n=pRealArray1->Dim[1]; k=pRealArray2->Dim[1];3 m! C( A, f' ~: P( t: a2 m+ W
    58.                 for(i=0; i<m; i++)        //矩阵乘- i+ Y9 q/ S0 }+ u
    59.                 {
    60. * E' c  `& c+ Z* o
    61.                         for(j=0; j<k; j++)& b: o% q3 `6 T) c\\" b6 d
    62.                         {5 l/ A2 f% `9 o) W% D, Z+ v: H$ y
    63.                                 u=i*k+j; pc[u]=0.0;, [2 m. G+ L7 N
    64.                                 for (v=0; v<n; v++)
    65. # c, O( t9 I\\" M
    66.                                 {
    67. & t+ s' o8 r* V% o% \
    68.                                         pc[u]=pc[u]+pa[i*n+v]*pb[v*k+j];- ^7 ^0 v' J% B3 {3 u4 {0 X
    69.                                 }
    70. 7 @4 s# m% s\\" R) F5 L4 \7 l( S
    71.                         }. z  d$ K8 N; J) |$ ~
    72.                 }\\" V6 `' P. F' I8 \  |% g) F
    73.                 FunReObj(hFor);        //告诉Lu,返回一个动态对象
    74. * ?3 Z( q: l2 q9 U, T
    75.                 a.BType=luDynData_realarray; a.VType=Matrix; a.x=0; *(luVOID *)&(a.x)=(luVOID)pRealArray3;
    76. 2 Q2 b: c: b8 @1 Y1 s
    77.                 break;. N9 z0 ?; D) P- \9 `. ~' @
    78.         case 25:        //重载运算符.*' {4 o* V5 \0 @& O9 j5 v
    79.                 pRealArray1=(luRealArray *)SearchKey((char *)&(xx->x),sizeof(luVOID),luDynData_realarray);
    80. - j* c/ x3 O' `2 W4 }
    81.                 pRealArray2=(luRealArray *)SearchKey((char *)&((xx+1)->x),sizeof(luVOID),luDynData_realarray);
    82. ! R6 d6 b  s& d/ m
    83.                 if(!pRealArray1 || !pRealArray2) break;        //对象句柄无效,不是实数数组
    84. / e% i) c( R\\" U6 a4 N/ N6 f2 r
    85.                 if(pRealArray1->DimLen!=2 || pRealArray2->DimLen!=2) break;        //不是二维实数数组(矩阵)4 v% M7 |/ f1 R* Y4 n0 @- C! r
    86.                 if(pRealArray1->Dim[0]!=pRealArray2->Dim[0] || pRealArray1->Dim[1]!=pRealArray2->Dim[1]) break;        //维数不相同
    87. 6 b2 F4 \. C/ X4 N
    88.                 pRealArray3=(luRealArray *)NewSysObj(luDynData_realarray,pRealArray1->ArrayLen,2);        //创建矩阵对象
    89. & y. Q) X+ T1 Z7 Z% J
    90.                 if(!pRealArray3) break;; l\\" t, u$ s. N9 _6 D\\" X; m
    91.                 pRealArray3->Dim[0]=pRealArray1->Dim[0]; pRealArray3->Dim[1]=pRealArray1->Dim[1];        //设置矩阵维数大小
    92. 7 ?4 k9 _5 }' v) C\\" J- Y
    93.                 for(i=0;i<pRealArray1->ArrayLen;i++) pRealArray3->Array[i]=pRealArray1->Array[i]*pRealArray2->Array[i];//矩阵点乘
    94. , ~' m+ ?2 }+ E& m0 S+ O, [/ Q, t
    95.                 FunReObj(hFor);        //告诉Lu,返回一个动态对象
    96. : \8 f$ y2 ?% T* S+ O% T
    97.                 a.BType=luDynData_realarray; a.VType=Matrix; a.x=0; *(luVOID *)&(a.x)=(luVOID)pRealArray3;( W  z% x! [! x
    98.                 break;
    99. 2 `3 W( e) u# V. K* r
    100.         case 46:        //重载函数new
    101. * ]! U2 x; ^' I7 y6 m9 c
    102.                 a=ExeOperator(mm,xx,hFor,theOperator,luDynData_realarray);        //直接调用基本类型luDynData_realarray的new函数  R7 U8 K4 p  s/ e( S3 |
    103.                 if(a.VType==luDynData_realarray) a.VType=Matrix;        //设置扩展类型为自定义的Matrix类型: _8 q$ e4 A' V2 C+ n! }% B* B
    104.                 break;* |: `7 C+ j! l/ q
    105.         case 49:        //重载函数o0 M7 C( N0 P. z
    106.                 pMessage=(luMessage)SearchKey("\0\0\0\0",sizeof(luVOID),luPubKey_User);
    107. 9 r\\" u) \. U7 ^% j4 p8 d$ m. u5 W' l
    108.                 if(!pMessage) break;
    109. 9 J: F3 I4 B. v' ^
    110.                 pRealArray1=(luRealArray *)SearchKey((char *)&(xx->x),sizeof(luVOID),luDynData_realarray);3 D8 ^& U7 ]* n) \
    111.                 if(!pRealArray1) break;        //对象句柄无效,不是实数数组# _\\" G4 `$ C0 b8 L. G6 A
    112.                 if(pRealArray1->DimLen!=2) break;        //不是二维实数数组(矩阵)2 R7 i\\" B) a7 R+ m: r9 `
    113.                 pa=pRealArray1->Array;
    114. , c' m! p9 W+ @- D1 F, @% E
    115.                 m=pRealArray1->Dim[0]; n=pRealArray1->Dim[1]; k=0;1 E: B9 p' Z( I0 e5 \
    116.                 for(i=0; i<m; i++)        //输出矩阵: }7 F0 d- i5 C6 v8 `2 ~\\" p
    117.                 {0 u) R7 s: C3 U, y) ^
    118.                         pMessage(L"\r\n"); k+=2;
    119. 2 a( \0 i! @& T2 t9 n/ e+ {& D
    120.                         for(j=0; j<n; j++)
    121. ' w6 P$ A' @8 f4 b- b& \9 g  x
    122.                         {
    123. 6 r, I( T\\" N4 f1 w4 u) ?/ k, Y$ ~
    124.                                 _gcvt_s(chNum,pa[i*n+j],16);
    125. * p7 F- A! H* i5 E( F
    126.                                 for(u=0;chNum[u];u++) {wchNum[u]=chNum[u]; k++;}
    127. & ]) I0 d4 k/ ~4 a
    128.                                 wchNum[u]='\0';0 D- b. l1 r8 W8 z8 O. H; p. f
    129.                                 pMessage(wchNum); pMessage(L"  "); k+=2;+ \- r1 T9 J4 `
    130.                         }
    131. ) L0 ^) K0 N+ l! {0 q\\" \9 h
    132.                 }
    133. 5 v; u3 X  T7 e2 P- g$ K
    134.                 pMessage(L"\r\n"); k+=2;
    135. 0 s. n) A( ^7 l; Q  ]1 j' t
    136.                 a.BType=luStaData_int64; a.VType=luStaData_int64; a.x=k;        //按函数o的要求,返回输出的字符总数
    137. ) V$ e  A/ e: m; e5 j( {1 J& }
    138.                 break;
    139. 4 a3 ^( z+ S( G' ?4 [  H\\" h- K: f
    140.         default:8 P% e& _\\" j* C, i# R9 l; l, b
    141.                 break;
    142. 3 |7 q& e. s5 T5 g0 d) u
    143.         }8 l, V9 W- ^+ q$ ~1 _
    144.         return a;
    145. , F$ ~: B3 F; t, X* j4 i
    146. }2 w4 B; h0 @! I3 h0 m
    147. void main(void); [3 U- n/ B  F% x5 o
    148. {, J\\" R, T; J7 W) n+ ^1 ]# s3 z  u
    149.         void *hFor;                //表达式句柄
    150. : Z& D\\" E) E3 N3 p\\" b, m) J  W- M
    151.         luINT nPara;                //存放表达式的自变量个数. W- ]/ C' P' b1 J( ], Q4 U  H
    152.         LuData *pPara;                //存放输入自变量的数组指针$ X) ^& ~7 m) y& g
    153.         luINT ErrBegin,ErrEnd;        //表达式编译出错的初始位置和结束位置0 H1 L& L+ |2 G1 H5 O- N. r
    154.         int ErrCode;                //错误代码, e/ k$ y. ^# X5 K, V2 k  Y
    155.         void *v;
    156. \\" e  x4 z1 b! r$ w3 x
    157.         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.]}";//字符串表达式,矩阵乘
    158. \\" k( s, V; O4 ]' ]! n$ g
    159.         //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.]}";//字符串表达式,矩阵点乘5 W8 g: @/ w# w) s
    160.         LuData Val;0 T8 i/ R: g/ V8 G2 S- ^6 Z! z& {
    161.         if(!InitLu()) return;        //初始化Lu
    162. 5 t) L. m  X4 ]( z0 x( w! ^
    163.         while(LockKey(Matrix,DelMatrix,OpMatrix)){Matrix++;}        //锁定一个键,用于存储矩阵扩展类型
    164. 5 E& T, X2 Y% q5 s

    165. : D9 X% w% R3 _4 x
    166.         Val.BType=luStaData_int64; Val.VType=luStaData_int64; Val.x=Matrix;        //定义整数常量2 o& x* ~% E% K3 F1 I( V; U8 z
    167.         SetConst(L"matrix",&Val);        //设置整数常量
    168. 7 s* j, \6 V' `9 w
    169.         InsertKey("\0\0\0\0",4,luPubKey_User,LuMessage,NULL,NULL,1,v); //使Lu运行时可输出函数信息5 a% X; V& o) Y( p9 k7 W
    170.         wcout.imbue(locale("chs"));        //设置输出的locale为中文
    171. , b9 J/ a/ @, h8 x* F% ^
    172.   % n, [3 o, G- \3 T
    173.         ErrCode=LuCom(ForStr,0,0,0,hFor,nPara,pPara,ErrBegin,ErrEnd); //编译表达式  w: A. I6 X& M\\" f9 H
    174.         if(ErrCode)
    175. \\" k. P$ C) R; S0 ?/ I
    176.         {! o7 s1 V( @; m+ B
    177.                 wcout<<L"表达式有错误!错误代码:"<<ErrCode<<endl;
    178. ' ?6 e0 c5 b6 N0 G) _$ ^$ ]4 P
    179.         }
    180. 6 D. Z8 s( x; v- v2 J2 N0 Z: k4 Z
    181.         else2 H# n5 x9 |9 q. o$ p! K
    182.         {& J\\" G& h) ], v0 o; D
    183.                 LuCal(hFor,pPara);        //计算表达式的值
    184. - q8 @* u4 q/ y. Z
    185.         }3 u+ o, x; H. V1 z) n
    186.         LockKey(Matrix,NULL,OpMatrix);//解锁键Matrix,本例中,该函数可以不用0 o& S# o\\" z# [
    187.         FreeLu();                        //释放Lu# n: ?, ^9 E\\" q5 j; d, \- d
    188. }
    习题:
    % t+ ~7 L% V7 D/ @* ^4 W# L% t6 ~  a6 d- {# q* r, [
        (1)自定义矩阵的加、减、左除、右除、点左除等运算,自编测试字符串代码,重新编译运行程序,观察计算结果。 * D0 j* n& K0 u6 a) @5 [+ s
    ! w; d+ u, T) \/ A9 T3 v& U
        (2)小矩阵乘效率测试。编译运行以下Lu字符串代码:
    1. main(:a,b,c,d,t,i)=
      # w5 \8 Z1 I# H2 x+ z! h
    2.     a=new[matrix,2,2,data:1.,2.,2.,1.],
      , h' @+ j# j: }$ B& }
    3.     b=new[matrix,2,2,data:2.,1.,1.,2.],
      $ |9 j6 d( m; V/ i# m
    4.     c=new[matrix,2,2,data:2/3.,-1/3.,-1/3.,2/3.],
      ) D/ K; Q8 |\" v9 M
    5.     t=clock(),
      / @* ^+ v7 q( Y! Z! X# e, O
    6.     d=a*b, i=0, while{i<1000000, d=d*c*b, i++},# p1 `) o3 ]8 l\" i
    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.% _# h: S0 ~( d3 ]+ a& d. {
    2. 5. 4.
      - R8 u' F) \$ z\" g# H' Z5 ]( F5 I/ b- W
    3. time=0.875 seconds.5 |/ X$ p. H' I! E9 M
    4. 请按任意键继续. . .
    复制代码
    Matlab 2009a 代码:
    1. a=[1.,2.;2.,1.];
      / O8 M1 R( w: k
    2. b=[2.,1.;1.,2.];
      : C7 F5 \4 W. S7 p
    3. c=[2/3.,-1/3.;-1/3.,2/3.];
      * M/ |7 R/ V' p9 x
    4. tic,
      & K; Y5 K( ~  l/ Y, ~; u* F
    5. d=a*b;3 Y. Y6 a; i2 X/ j\" j
    6. for i=1:1000000* _7 F8 O* n: z* e
    7.     d=d*c*b;# k* D- Y* u0 n
    8. end
      ; w8 p/ q+ |) Y2 }% `
    9. d,
      & o8 x$ h$ C& g\" O; ?! R
    10. toc
    复制代码
    结果:
    1. d =
      # V, |6 a' T' i' V: h; |
    2.      4     5  z) d+ l: {3 h6 i
    3.      5     4\" m0 l5 z- a  [3 i
    4. Elapsed time is 2.903034 seconds.
    复制代码
    本例矩阵乘效率测试,Lu的速度超过了Matlab,主要在于Lu有更高的动态对象管理效率。, j3 g& |, ]9 Z, g% |) |
    zan
    转播转播0 分享淘帖0 分享分享0 收藏收藏0 支持支持0 反对反对0 微信微信
    您需要登录后才可以回帖 登录 | 注册地址

    qq
    收缩
    • 电话咨询

    • 04714969085
    fastpost

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

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

    蒙公网安备 15010502000194号

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

    GMT+8, 2026-8-31 21:19 , Processed in 1.493720 second(s), 51 queries .

    回顶部