快捷通道

QQ登录

只需要一步，快速开始

  注册地址  找回密码

数学建模社区-数学中国

留学>>
返回列表 发新帖
查看: 8475|回复: 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（标识矩阵）。为了简单，我们仅处理二维实数数组即矩阵类型。* N( G! q& d- Q8 X

    1 A6 O9 i) l! f) W* v, V    基本要点：
    2 k4 x% ]+ A1 \  _6 D8 S) o5 D+ C+ `$ Z, e2 ^' I9 S" X
        （1）为扩展类型matrix编写运算符重载函数OpMatrix。
    5 R5 D) l# i) t$ G3 Y# w" R% I+ Y* m* ^1 q+ B7 P. H# j
        （2）用函数LockKey将重载函数OpMatrix注册到Lu，锁定的键的类型即为matrix，要注册为常量，以便于使用。
    1 ~; ?4 V5 S" J  x7 O  r8 ]. }
    " }/ ~( G4 b- Q) A, \; R/ I" w    （3）为扩展类型matrix编写其他操作函数（本例未提供）。, V  P( s# p& D' C. @. O

    9 a" F: @' J( t    （4）用函数LockKey解锁键matrix（本例中，程序退出时会自动解锁，故可以不用）。
    2. #include <windows.h># l4 F/ c/ ?+ b1 g4 P# g
    4. #include <iostream>& z, O7 j7 D+ Z2 l0 Y6 m: e& B! C
    6. #include <math.h>: z- V8 A& \8 r/ h0 A, _
    8. #include "lu32.h"
    9. * b0 X( z# D; h% Z

    11. ( ^+ t$ i) O$ F% e
    12. #pragma comment( lib, "lu32.lib" )
    13. ( h  c! Q4 E! V

    15. , S% u! d7 n\\" U
    16. using namespace std;
    17. / L7 p% X  D' f* K- |
    18. 5 t9 ^- Y6 \\\" _2 v; y
    20. luKEY Matrix=-1000;        //标识矩阵类型，最终的Matrix由LockKey决定* [0 k4 i5 r6 d2 l) P

    23. 0 g6 O9 K% b! n8 g4 ?3 O$ X
    24. void _stdcall LuMessage(wchar_t *pch)//输出动态库信息，该函数注册到Lu，由Lu二级函数调用 8 ?- l! T5 }& b# Q; j6 F' b
    26. {! J% ^! b; r3 j; M; h* Y
    28.         wcout<<pch;
    29. . K( H9 [  T' M; P7 M, p% F4 F
    30. }
    31. + r+ E' F$ i4 _, U8 u& P3 w
    32. void _stdcall DelMatrix(void *me)        //用于LockKey函数，因为是基于系统内置实数数组创建矩阵，故该函数什么也不做\\" P1 F% A2 Q( j% g
    34. {
    35. 8 j7 L2 V2 ^5 X& ^\\" ?# t4 \
    36. }
    37. ) r& b5 T/ X; n% g# A3 }
    38. LuData _stdcall OpMatrix(luINT mm,LuData *xx,void *hFor,int theOperator)        //运算符重载函数，用于LockKey函数1 Y- a6 `! _: d+ C/ H
    40. {0 I6 b% R* L5 V/ d. i4 j/ Q
    42.         LuData a;
    43. 9 s; Z8 Y* Y( }# P6 v% p- l
    44.         luRealArray *pRealArray1,*pRealArray2,*pRealArray3;. Z7 x% Y( I, A! O. ?/ ^5 v
    46.         luVOID i,j,k,m,n,u,v;
    47. $ }6 h; \9 I) s* X
    48.         double *pa,*pb,*pc;6 U  P1 v, O, ~/ y
    50.         luMessage pMessage;
    51. + |6 B; O% Y8 t5 \
    52.         wchar_t wchNum[32];: x: E( w: b! _6 [0 M\\" c/ W; |
    54.         char chNum[32];; T- U3 |$ r) h2 t+ H
    56.         a.BType=luStaData_nil; a.VType=luStaData_nil; a.x=0;
    57. \\" t/ }$ W! a5 s9 J! [7 g% J
    58.         switch(theOperator)( |; |. n  s' q# b2 k5 W1 J
    60.         {
    61. 5 q/ H4 u* z: v6 C
    62.         case 2:        //重载运算符*
    63. \\" e5 k- v$ B: @' U; f
    64.                 pRealArray1=(luRealArray *)SearchKey((char *)&(xx->x),sizeof(luVOID),luDynData_realarray);
    65.   G6 r# ~\\" Y\\" H9 K
    66.                 pRealArray2=(luRealArray *)SearchKey((char *)&((xx+1)->x),sizeof(luVOID),luDynData_realarray);$ l! ?0 t+ d5 h* ?+ U
    68.                 if(!pRealArray1 || !pRealArray2) break;        //对象句柄无效，不是实数数组
    69. ) f; s% G  Y. j: Y4 W+ R0 A
    70.                 if(pRealArray1->DimLen!=2 || pRealArray2->DimLen!=2) break;        //不是二维实数数组（矩阵）4 E$ ^% U4 ?7 h
    72.                 if(pRealArray1->Dim[1]!=pRealArray2->Dim[0]) break;        //维数不匹配7 v8 o) a% S, W
    74.                 pRealArray3=(luRealArray *)NewSysObj(luDynData_realarray,pRealArray1->Dim[0]*pRealArray2->Dim[1],2);        //创建矩阵对象. G; N/ B! H- F4 t% `
    76.                 if(!pRealArray3) break;0 h9 C0 ?; b/ n4 W/ d: [: I6 U8 {
    78.                 pRealArray3->Dim[0]=pRealArray1->Dim[0]; pRealArray3->Dim[1]=pRealArray2->Dim[1];        //设置矩阵维数大小
    79. ' g2 R/ m* g, a3 J3 f
    80.                 pa=pRealArray1->Array; pb=pRealArray2->Array; pc=pRealArray3->Array;
    81. + v: k$ G7 q# i% Y/ b4 e( \
    82.                 m=pRealArray1->Dim[0]; n=pRealArray1->Dim[1]; k=pRealArray2->Dim[1];
    83. 7 d8 q# Q& e\\" Z% V; U
    84.                 for(i=0; i<m; i++)        //矩阵乘6 ?# n7 i6 P3 p
    86.                 {# W! @6 X3 Y% z
    88.                         for(j=0; j<k; j++)
    89. # n0 o2 |0 {! L) {  I
    90.                         {; t: C# V1 I- O1 j2 I\\" j9 }
    92.                                 u=i*k+j; pc[u]=0.0;
    93. ( A6 y3 P2 |5 s  Y
    94.                                 for (v=0; v<n; v++)
    95. ! q* k: ^2 [; H+ p' `( o
    96.                                 {
    97. 5 C. N/ z. f) s. R/ l# L
    98.                                         pc[u]=pc[u]+pa[i*n+v]*pb[v*k+j];4 Q' V4 `: X\\" h; b\\" A$ e* |
    100.                                 }
    101. 1 k3 c% w# V0 t* }7 ?/ ^
    102.                         }4 S. F$ L( W4 U8 u$ B) S- n% b
    104.                 }
    105. , Y+ b% e6 `. h! R% V
    106.                 FunReObj(hFor);        //告诉Lu，返回一个动态对象- t\\" D  x- M' M5 I0 j. M* M
    108.                 a.BType=luDynData_realarray; a.VType=Matrix; a.x=0; *(luVOID *)&(a.x)=(luVOID)pRealArray3;
    109. + k  a4 P: U) ]
    110.                 break;% B; ~: ^- U5 Z4 [1 g: }. E+ B
    112.         case 25:        //重载运算符.*5 M3 Q) |0 Q/ W  G5 q
    114.                 pRealArray1=(luRealArray *)SearchKey((char *)&(xx->x),sizeof(luVOID),luDynData_realarray);: z/ `% F\\" e. G  l  L7 n\\" V
    116.                 pRealArray2=(luRealArray *)SearchKey((char *)&((xx+1)->x),sizeof(luVOID),luDynData_realarray);- \! P- d% K1 n) @% s0 u/ h
    118.                 if(!pRealArray1 || !pRealArray2) break;        //对象句柄无效，不是实数数组
    119. ' X5 U\\" {- \- M! `0 E  @- @& [2 |
    120.                 if(pRealArray1->DimLen!=2 || pRealArray2->DimLen!=2) break;        //不是二维实数数组（矩阵）
    121. * r$ `( K: g' v( w
    122.                 if(pRealArray1->Dim[0]!=pRealArray2->Dim[0] || pRealArray1->Dim[1]!=pRealArray2->Dim[1]) break;        //维数不相同
    123. # c/ e2 w' i3 k\\" a( b
    124.                 pRealArray3=(luRealArray *)NewSysObj(luDynData_realarray,pRealArray1->ArrayLen,2);        //创建矩阵对象
    125. % J+ H8 E+ }4 x2 B
    126.                 if(!pRealArray3) break;' Q) m0 ^$ ^' a7 ~\\" N, C3 h9 Q) z: k
    128.                 pRealArray3->Dim[0]=pRealArray1->Dim[0]; pRealArray3->Dim[1]=pRealArray1->Dim[1];        //设置矩阵维数大小$ s* l\\" b+ ^6 {4 \; f  i
    130.                 for(i=0;i<pRealArray1->ArrayLen;i++) pRealArray3->Array[i]=pRealArray1->Array[i]*pRealArray2->Array[i];//矩阵点乘
    131. 6 Q0 f1 r7 v! j0 A+ |# x\\" |% _
    132.                 FunReObj(hFor);        //告诉Lu，返回一个动态对象
    133. - i  w5 G$ M4 E$ a+ a
    134.                 a.BType=luDynData_realarray; a.VType=Matrix; a.x=0; *(luVOID *)&(a.x)=(luVOID)pRealArray3;; W: |+ f0 `: Q( u5 }9 [: t
    136.                 break;+ P0 @* s7 ^6 F8 J( S9 V* s
    138.         case 46:        //重载函数new
    139. ) ?& Y. [0 |1 |
    140.                 a=ExeOperator(mm,xx,hFor,theOperator,luDynData_realarray);        //直接调用基本类型luDynData_realarray的new函数( Z; a- ?  p' [7 R  f, C
    142.                 if(a.VType==luDynData_realarray) a.VType=Matrix;        //设置扩展类型为自定义的Matrix类型
    143. 0 f* b$ z( E# d2 P) J
    144.                 break;
    145. \\" S\\" N) u\\" h+ u, f0 ]+ G4 q+ D
    146.         case 49:        //重载函数o
    147. 3 U0 R! U* x% Q
    148.                 pMessage=(luMessage)SearchKey("\0\0\0\0",sizeof(luVOID),luPubKey_User);) A7 @& S' @+ a# l( G
    150.                 if(!pMessage) break;
    151. 4 d5 h1 ~3 ?# q\\" ?$ l
    152.                 pRealArray1=(luRealArray *)SearchKey((char *)&(xx->x),sizeof(luVOID),luDynData_realarray);
    153. ; G1 J\\" _- F6 z) C
    154.                 if(!pRealArray1) break;        //对象句柄无效，不是实数数组3 W3 G0 I' h\\" o. V# E1 u; f\\" g
    156.                 if(pRealArray1->DimLen!=2) break;        //不是二维实数数组（矩阵）
    157. 3 t0 K) V2 ^7 y: q
    158.                 pa=pRealArray1->Array;! P3 w6 ?/ K) _\\" F7 g. P9 d8 \: m# v
    160.                 m=pRealArray1->Dim[0]; n=pRealArray1->Dim[1]; k=0;
    161. 8 ^- k8 \8 i3 N6 Y/ ^
    162.                 for(i=0; i<m; i++)        //输出矩阵
    163. , ?. o  X6 \6 ^# P: K- e8 h8 w
    164.                 {
    165. . p0 t+ v3 O) B# u+ f\\" [
    166.                         pMessage(L"\r\n"); k+=2;1 r8 T* _2 P. @' p0 N  }' d7 Y
    168.                         for(j=0; j<n; j++)! N5 O& x$ V; H  l  s7 ?/ m
    170.                         {/ ^+ Y4 q% y7 x( q; S9 u
    172.                                 _gcvt_s(chNum,pa[i*n+j],16);8 ^+ I4 {6 p. {1 M
    174.                                 for(u=0;chNum[u];u++) {wchNum[u]=chNum[u]; k++;}
    175. / y% U+ p  B0 i1 [: |! b
    176.                                 wchNum[u]='\0';7 R0 N! e1 a. z7 U2 _' k
    178.                                 pMessage(wchNum); pMessage(L"  "); k+=2;
    179. 8 _- A# O. b) J2 _, C\\" L
    180.                         }8 j, ^! F) w9 }
    182.                 }
    183. 8 S6 l  x9 w, j4 J2 n6 H
    184.                 pMessage(L"\r\n"); k+=2;: c1 g& s0 R, S8 t5 M7 ^6 z
    186.                 a.BType=luStaData_int64; a.VType=luStaData_int64; a.x=k;        //按函数o的要求，返回输出的字符总数' \% l- ?& {- I9 ~8 a+ F
    188.                 break;( y: _) N' |5 h% ?3 Q
    190.         default:  @. M# D\\" H  Q  N4 l
    192.                 break;5 R  u9 Q' e. W/ h% l2 b5 ?% v$ r
    194.         }
    195. + n  n8 {' d' [0 F- H
    196.         return a;
    197. , Q1 ?  H3 I! s4 \7 S, _/ G& X1 A
    198. }
    199. 9 v  U- {6 A2 {2 i1 F
    200. void main(void)$ K, `9 M7 L9 l0 {# b
    202. {
    203. 8 I\\" b2 U- r\\" B3 x! t3 i) o
    204.         void *hFor;                //表达式句柄
    205. , G7 a- }+ I& U$ l9 n0 w6 K
    206.         luINT nPara;                //存放表达式的自变量个数+ N  F( }5 n) O( w% |# B\\" L/ v
    208.         LuData *pPara;                //存放输入自变量的数组指针
    209. - n4 P9 c' m\\" ~* k
    210.         luINT ErrBegin,ErrEnd;        //表达式编译出错的初始位置和结束位置' m5 v2 P3 B, ?
    212.         int ErrCode;                //错误代码
    213. $ G; Q7 M- O! w( V) G\\" R
    214.         void *v;
    215.   Z. {; b; |0 w3 |! ?$ L$ I
    216.         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.]}";//字符串表达式，矩阵乘, ]1 T# }0 g6 @3 }+ w  K
    218.         //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.]}";//字符串表达式，矩阵点乘
    219. 1 l' ?# z' C1 r# x5 Y3 H* P+ u
    220.         LuData Val;2 V2 H& s. t$ v: D  y/ d% `( |; H; k
    222.         if(!InitLu()) return;        //初始化Lu' E& n8 M# L9 I0 ~( R! m
    224.         while(LockKey(Matrix,DelMatrix,OpMatrix)){Matrix++;}        //锁定一个键，用于存储矩阵扩展类型
    225. ) ]2 O+ q$ t0 A/ D% r% v( z$ r
    226. ) V2 g% z' ?6 e7 X! s, y
    228.         Val.BType=luStaData_int64; Val.VType=luStaData_int64; Val.x=Matrix;        //定义整数常量
    229. 7 L0 W7 s$ x% q- z\\" t3 _- g4 \8 J
    230.         SetConst(L"matrix",&Val);        //设置整数常量
    231. * r3 H* \- t  H. ?. ]5 `
    232.         InsertKey("\0\0\0\0",4,luPubKey_User,LuMessage,NULL,NULL,1,v); //使Lu运行时可输出函数信息2 S* Z\\" P) l7 ^3 X3 [\\" T& y' b
    234.         wcout.imbue(locale("chs"));        //设置输出的locale为中文
    235. 2 T# B4 g6 a7 b
    236.   ; f6 h. \# h1 J6 |5 j
    238.         ErrCode=LuCom(ForStr,0,0,0,hFor,nPara,pPara,ErrBegin,ErrEnd); //编译表达式
    239. ' x8 B$ t/ m; v- P
    240.         if(ErrCode)  g\\" B4 J, `( C( }9 l! O
    242.         {4 B! ?$ E' h! C+ ^2 g( T
    244.                 wcout<<L"表达式有错误！错误代码："<<ErrCode<<endl;& ^0 h0 D# D4 A8 B1 k/ C; }
    246.         }' s  S# W5 z5 G: e
    248.         else, L0 A; n. r, L, |6 P
    250.         {) V4 f- k' [* m) v6 j+ Y
    252.                 LuCal(hFor,pPara);        //计算表达式的值
    253.   J. u& j9 @. k4 \
    254.         }
    255. 3 ^  H6 B( F; r6 t0 L8 k: ^
    256.         LockKey(Matrix,NULL,OpMatrix);//解锁键Matrix，本例中，该函数可以不用
    257. - a2 u% K& s; o# e  s, \; G
    258.         FreeLu();                        //释放Lu* I+ c1 c1 k* P+ \\\" R
    260. }
    习题：
    * Y- Y5 ]1 A  K2 N, i3 Q
    " S9 r0 T' {" g  I    （1）自定义矩阵的加、减、左除、右除、点左除等运算，自编测试字符串代码，重新编译运行程序，观察计算结果。
    * ]2 W' s8 I; Z* }( k) w! Z4 m9 c5 C
        （2）小矩阵乘效率测试。编译运行以下Lu字符串代码：
    1. main(:a,b,c,d,t,i)=
      # L( R9 d# b# K/ Y: v& a0 r
    2.     a=new[matrix,2,2,data:1.,2.,2.,1.],( R$ Q% b1 e5 k' X: b8 Q$ c7 M9 X
    3.     b=new[matrix,2,2,data:2.,1.,1.,2.],; y* v; z$ j7 x8 d$ Z1 U* e
    4.     c=new[matrix,2,2,data:2/3.,-1/3.,-1/3.,2/3.],
      3 x0 r) ^\" N% }
    5.     t=clock(),
      * w, Z+ c; d\" O( C; o
    6.     d=a*b, i=0, while{i<1000000, d=d*c*b, i++},\" L1 r, ]  a7 L8 W2 \. p\" k* R* w
    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./ N2 ]* e9 Y$ `/ a1 m$ M
    2. 5. 4.
      0 `. n& k# H6 z8 d9 n
    3. time=0.875 seconds.+ u0 t0 u4 Y3 W1 N' y\" Y
    4. 请按任意键继续. . .
    复制代码
    Matlab 2009a 代码：
    1. a=[1.,2.;2.,1.];, s; v' w\" _) k, Y: H$ j  K  [; n! W
    2. b=[2.,1.;1.,2.];* }7 Q4 N3 n7 f. p4 F6 n
    3. c=[2/3.,-1/3.;-1/3.,2/3.];
      + Y: J  I7 W  J\" e% ]$ b; t' k
    4. tic,/ l& J1 F3 b, R( D! T3 o\" ^
    5. d=a*b;6 N8 L5 e$ \0 `0 L, u1 g7 b( e
    6. for i=1:1000000\" _, X5 S/ i4 P4 `: F\" O3 e0 y4 `- Z
    7.     d=d*c*b;! T' c, X  _3 Y. b+ T3 V
    8. end& N9 C9 k, w/ {( P\" `& w
    9. d,8 U0 r' v# |$ y& ]\" f( D8 |
    10. toc
    复制代码
    结果：
    1. d =- R% ]( K5 n: g/ K
    2.      4     5
      \" m6 P. {+ w# c) G1 c
    3.      5     4
      / S6 b* v4 N6 \5 @& y
    4. Elapsed time is 2.903034 seconds.
    复制代码
    本例矩阵乘效率测试，Lu的速度超过了Matlab，主要在于Lu有更高的动态对象管理效率。- p% L5 W& C3 h0 |8 A: @
    zan
    标识, 注册, comment, include, Matrix
    转播转播0 分享淘帖0 分享分享0 收藏收藏0 支持支持0 反对反对0 微信微信

    相关帖子
    回复

    使用道具 举报

    2#
    无效楼层，该帖已经被删除
    3#
    无效楼层，该帖已经被删除
    返回列表 发新帖
    高级模式
    B Color Image Link Quote Code Smilies
    您需要登录后才可以回帖 登录 | 注册地址

    qq
    收缩

    • 电话咨询

    • 04714969085

    fastpost

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

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

    蒙公网安备 15010502000194号

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

    GMT+8, 2025-10-7 17:48 , Processed in 0.548040 second(s), 62 queries .

    回顶部