找回密码
 欢迎注册
查看: 10230|回复: 0

[讨论] Lu基于系统内置对象创建扩展数据类型,小矩阵乘效率测试,有胜出

[复制链接]
发表于 2011-10-23 10:03:41 | 显示全部楼层 |阅读模式

马上注册,结交更多好友,享用更多功能,让你轻松玩转社区。

您需要 登录 才可以下载或查看,没有账号?欢迎注册

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

    本例中,我们将基于系统内置实数数组创建矩阵(matrix)类型,即:基本类型为luDynData_realarray(标识实数数组),扩展类型为matrix(标识矩阵)。为了简单,我们仅处理二维实数数组即矩阵类型。

    基本要点:

    (1)为扩展类型matrix编写运算符重载函数OpMatrix。

    (2)用函数LockKey将重载函数OpMatrix注册到Lu,锁定的键的类型即为matrix,要注册为常量,以便于使用。

    (3)为扩展类型matrix编写其他操作函数(本例未提供)。

    (4)用函数LockKey解锁键matrix(本例中,程序退出时会自动解锁,故可以不用)。

    仅需要以下支持文件:

    1)头文件lu32.h。
    2)导入库lu32.lib。
    3)核心库lu32.dll。
  1. #include <windows.h>
  2. #include <iostream>
  3. #include <math.h>
  4. #include "lu32.h"
  5. #pragma comment( lib, "lu32.lib" )
  6. using namespace std;
  7. luKEY Matrix=-1000;        //标识矩阵类型,最终的Matrix由LockKey决定
  8. void _stdcall LuMessage(wchar_t *pch)//输出动态库信息,该函数注册到Lu,由Lu二级函数调用
  9. {
  10.         wcout<<pch;
  11. }
  12. void _stdcall DelMatrix(void *me)        //用于LockKey函数,因为是基于系统内置实数数组创建矩阵,故该函数什么也不做
  13. {
  14. }
  15. LuData _stdcall OpMatrix(luINT mm,LuData *xx,void *hFor,int theOperator)        //运算符重载函数,用于LockKey函数
  16. {
  17.         LuData a;
  18.         luRealArray *pRealArray1,*pRealArray2,*pRealArray3;
  19.         luVOID i,j,k,m,n,u,v;
  20.         double *pa,*pb,*pc;
  21.         luMessage pMessage;
  22.         wchar_t wchNum[32];
  23.         char chNum[32];
  24.         a.BType=luStaData_nil; a.VType=luStaData_nil; a.x=0;
  25.         switch(theOperator)
  26.         {
  27.         case 2:        //重载运算符*
  28.                 pRealArray1=(luRealArray *)SearchKey((char *)&(xx->x),sizeof(luVOID),luDynData_realarray);
  29.                 pRealArray2=(luRealArray *)SearchKey((char *)&((xx+1)->x),sizeof(luVOID),luDynData_realarray);
  30.                 if(!pRealArray1 || !pRealArray2) break;        //对象句柄无效,不是实数数组
  31.                 if(pRealArray1->DimLen!=2 || pRealArray2->DimLen!=2) break;        //不是二维实数数组(矩阵)
  32.                 if(pRealArray1->Dim[1]!=pRealArray2->Dim[0]) break;        //维数不匹配
  33.                 pRealArray3=(luRealArray *)NewSysObj(luDynData_realarray,pRealArray1->Dim[0]*pRealArray2->Dim[1],2);        //创建矩阵对象
  34.                 if(!pRealArray3) break;
  35.                 pRealArray3->Dim[0]=pRealArray1->Dim[0]; pRealArray3->Dim[1]=pRealArray2->Dim[1];        //设置矩阵维数大小
  36.                 pa=pRealArray1->Array; pb=pRealArray2->Array; pc=pRealArray3->Array;
  37.                 m=pRealArray1->Dim[0]; n=pRealArray1->Dim[1]; k=pRealArray2->Dim[1];
  38.                 for(i=0; i<m; i++)        //矩阵乘
  39.                 {
  40.                         for(j=0; j<k; j++)
  41.                         {
  42.                                 u=i*k+j; pc[u]=0.0;
  43.                                 for (v=0; v<n; v++)
  44.                                 {
  45.                                         pc[u]=pc[u]+pa[i*n+v]*pb[v*k+j];
  46.                                 }
  47.                         }
  48.                 }
  49.                 FunReObj(hFor);        //告诉Lu,返回一个动态对象
  50.                 a.BType=luDynData_realarray; a.VType=Matrix; a.x=0; *(luVOID *)&(a.x)=(luVOID)pRealArray3;
  51.                 break;
  52.         case 25:        //重载运算符.*
  53.                 pRealArray1=(luRealArray *)SearchKey((char *)&(xx->x),sizeof(luVOID),luDynData_realarray);
  54.                 pRealArray2=(luRealArray *)SearchKey((char *)&((xx+1)->x),sizeof(luVOID),luDynData_realarray);
  55.                 if(!pRealArray1 || !pRealArray2) break;        //对象句柄无效,不是实数数组
  56.                 if(pRealArray1->DimLen!=2 || pRealArray2->DimLen!=2) break;        //不是二维实数数组(矩阵)
  57.                 if(pRealArray1->Dim[0]!=pRealArray2->Dim[0] || pRealArray1->Dim[1]!=pRealArray2->Dim[1]) break;        //维数不相同
  58.                 pRealArray3=(luRealArray *)NewSysObj(luDynData_realarray,pRealArray1->ArrayLen,2);        //创建矩阵对象
  59.                 if(!pRealArray3) break;
  60.                 pRealArray3->Dim[0]=pRealArray1->Dim[0]; pRealArray3->Dim[1]=pRealArray1->Dim[1];        //设置矩阵维数大小
  61.                 for(i=0;i<pRealArray1->ArrayLen;i++) pRealArray3->Array[i]=pRealArray1->Array[i]*pRealArray2->Array[i];//矩阵点乘
  62.                 FunReObj(hFor);        //告诉Lu,返回一个动态对象
  63.                 a.BType=luDynData_realarray; a.VType=Matrix; a.x=0; *(luVOID *)&(a.x)=(luVOID)pRealArray3;
  64.                 break;
  65.         case 46:        //重载函数new
  66.                 a=ExeOperator(mm,xx,hFor,theOperator,luDynData_realarray);        //直接调用基本类型luDynData_realarray的new函数
  67.                 if(a.VType==luDynData_realarray) a.VType=Matrix;        //设置扩展类型为自定义的Matrix类型
  68.                 break;
  69.         case 49:        //重载函数o
  70.                 pMessage=(luMessage)SearchKey("\0\0\0\0",sizeof(luVOID),luPubKey_User);
  71.                 if(!pMessage) break;
  72.                 pRealArray1=(luRealArray *)SearchKey((char *)&(xx->x),sizeof(luVOID),luDynData_realarray);
  73.                 if(!pRealArray1) break;        //对象句柄无效,不是实数数组
  74.                 if(pRealArray1->DimLen!=2) break;        //不是二维实数数组(矩阵)
  75.                 pa=pRealArray1->Array;
  76.                 m=pRealArray1->Dim[0]; n=pRealArray1->Dim[1]; k=0;
  77.                 for(i=0; i<m; i++)        //输出矩阵
  78.                 {
  79.                         pMessage(L"\r\n"); k+=2;
  80.                         for(j=0; j<n; j++)
  81.                         {
  82.                                 _gcvt_s(chNum,pa[i*n+j],16);
  83.                                 for(u=0;chNum[u];u++) {wchNum[u]=chNum[u]; k++;}
  84.                                 wchNum[u]='\0';
  85.                                 pMessage(wchNum); pMessage(L"  "); k+=2;
  86.                         }
  87.                 }
  88.                 pMessage(L"\r\n"); k+=2;
  89.                 a.BType=luStaData_int64; a.VType=luStaData_int64; a.x=k;        //按函数o的要求,返回输出的字符总数
  90.                 break;
  91.         default:
  92.                 break;
  93.         }
  94.         return a;
  95. }
  96. void main(void)
  97. {
  98.         void *hFor;                //表达式句柄
  99.         luINT nPara;                //存放表达式的自变量个数
  100.         LuData *pPara;                //存放输入自变量的数组指针
  101.         luINT ErrBegin,ErrEnd;        //表达式编译出错的初始位置和结束位置
  102.         int ErrCode;                //错误代码
  103.         void *v;
  104.         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.]}";//字符串表达式,矩阵乘
  105.         //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.]}";//字符串表达式,矩阵点乘
  106.         LuData Val;
  107.         if(!InitLu()) return;        //初始化Lu
  108.         while(LockKey(Matrix,DelMatrix,OpMatrix)){Matrix++;}        //锁定一个键,用于存储矩阵扩展类型

  109.         Val.BType=luStaData_int64; Val.VType=luStaData_int64; Val.x=Matrix;        //定义整数常量
  110.         SetConst(L"matrix",&Val);        //设置整数常量
  111.         InsertKey("\0\0\0\0",4,luPubKey_User,LuMessage,NULL,NULL,1,v); //使Lu运行时可输出函数信息
  112.         wcout.imbue(locale("chs"));        //设置输出的locale为中文
  113.   
  114.         ErrCode=LuCom(ForStr,0,0,0,hFor,nPara,pPara,ErrBegin,ErrEnd); //编译表达式
  115.         if(ErrCode)
  116.         {
  117.                 wcout<<L"表达式有错误!错误代码:"<<ErrCode<<endl;
  118.         }
  119.         else
  120.         {
  121.                 LuCal(hFor,pPara);        //计算表达式的值
  122.         }
  123.         LockKey(Matrix,NULL,OpMatrix);//解锁键Matrix,本例中,该函数可以不用
  124.         FreeLu();                        //释放Lu
  125. }
复制代码
习题:

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

    (2)小矩阵乘效率测试。编译运行以下Lu字符串代码:
  1. main(:a,b,c,d,t,i)=
  2.     a=new[matrix,2,2,data:1.,2.,2.,1.],
  3.     b=new[matrix,2,2,data:2.,1.,1.,2.],
  4.     c=new[matrix,2,2,data:2/3.,-1/3.,-1/3.,2/3.],
  5.     t=clock(),
  6.     d=a*b, i=0, while{i<1000000, d=d*c*b, 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.
  2. 5. 4.
  3. time=0.875 seconds.
  4. 请按任意键继续. . .
复制代码
Matlab 2009a 代码:
  1. a=[1.,2.;2.,1.];
  2. b=[2.,1.;1.,2.];
  3. c=[2/3.,-1/3.;-1/3.,2/3.];
  4. tic,
  5. d=a*b;
  6. for i=1:1000000
  7.     d=d*c*b;
  8. end
  9. d,
  10. toc
复制代码
结果:
  1. d =
  2.      4     5
  3.      5     4
  4. Elapsed time is 2.903034 seconds.
复制代码
本例矩阵乘效率测试,Lu的速度超过了Matlab,主要在于Lu有更高的动态对象管理效率。
毋因群疑而阻独见  毋任己意而废人言
毋私小惠而伤大体  毋借公论以快私情
您需要登录后才可以回帖 登录 | 欢迎注册

本版积分规则

小黑屋|手机版|数学研发网 ( 苏ICP备07505100号 )

GMT+8, 2024-3-29 17:17 , Processed in 0.043886 second(s), 16 queries .

Powered by Discuz! X3.5

© 2001-2024 Discuz! Team.

快速回复 返回顶部 返回列表