找回密码
 欢迎注册
查看: 9234|回复: 1

[讨论] 在Lu中创建自定义数据类型,小矩阵乘效率测试,有胜出

[复制链接]
发表于 2011-10-25 08:07:37 | 显示全部楼层 |阅读模式

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

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

×
本例中,我们将自定义矩阵(matrix)类型,基本类型和扩展类型均为matrix(标识矩阵)。

    基本要点:

    (1)编写生成矩阵(matrix)的函数NewMatrix和销毁矩阵的函数DelMatrix。

    (2)为自定义类型matrix编写运算符重载函数OpMatrix。

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

    (4)为自定义类型matrix编写其他操作函数(本例未提供)。

    (5)用函数LockKey解锁键matrix(本例中,程序退出时会自动解锁,故可以不用)。
  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. //自定义矩阵
  8. class myMatrix
  9. {
  10. public:
  11.         double *Array;        //数据缓冲区
  12.         luVOID ArrayLen;        //数据缓冲区长度
  13.         luVOID Dim[2];        //矩阵维数
  14.         myMatrix(){Array=NULL; ArrayLen=0; Dim[0]=0; Dim[1]=0;}
  15.         ~myMatrix()
  16.         {
  17.                 if(Array) delete[] Array;
  18.         }
  19. };
  20. luKEY Matrix=-1000;        //标识矩阵类型,最终的Matrix由LockKey决定
  21. void _stdcall LuMessage(wchar_t *pch)//输出动态库信息,该函数注册到Lu,由Lu二级函数调用
  22. {
  23.         wcout<<pch;
  24. }
  25. void _stdcall DelMatrix(void *me)        //用于LockKey函数及InsertKey函数,使Lu能自动销毁myMatrix对象
  26. {
  27.         delete (myMatrix *)me;
  28. }
  29. myMatrix * _stdcall NewMatrix(luVOID m,luVOID n)        //生成一个myMatrix对象
  30. {
  31.         myMatrix *pMatrix;
  32.         luVOID k;
  33.         double *pa;
  34.         char keyname[sizeof(luVOID)];
  35.         void *NowKey;
  36.         k=m*n;
  37.         pMatrix=(myMatrix *)GetBufObj(Matrix,keyname);//先尝试从缓冲区中获取一个矩阵对象
  38.         if(pMatrix)
  39.         {
  40.                 if(pMatrix->ArrayLen!=k)        //重置矩阵的大小
  41.                 {
  42.                         pa=new double[k];
  43.                         if(!pa)
  44.                         {
  45.                                 DeleteKey(keyname,sizeof(luVOID),Matrix,DelMatrix,1);        //将矩阵对象放回缓冲区
  46.                                 return NULL;
  47.                         }
  48.                         delete[] pMatrix->Array;
  49.                         pMatrix->Array=pa;
  50.                 }
  51.         }
  52.         else
  53.         {
  54.                 pMatrix=new myMatrix;        //创建矩阵对象
  55.                 if(!pMatrix) return NULL;
  56.                 pMatrix->Array=new double[k];
  57.                 if(!pMatrix->Array)
  58.                 {
  59.                         delete pMatrix;
  60.                         return NULL;
  61.                 }
  62.                 if(InsertKey((char *)&pMatrix,-1,Matrix,pMatrix,DelMatrix,NULL,0,NowKey))        //将矩阵对象注册到Lu
  63.                 {
  64.                         delete pMatrix;
  65.                         return NULL;
  66.                 }
  67.         }
  68.         pMatrix->ArrayLen=k; pMatrix->Dim[0]=m; pMatrix->Dim[1]=n;
  69.         return pMatrix;
  70. }
  71. LuData _stdcall OpMatrix(luINT mm,LuData *xx,void *hFor,int theOperator)        //运算符重载函数,用于LockKey函数
  72. {
  73.         LuData a;
  74.         myMatrix *pMatrix1,*pMatrix2,*pMatrix3;
  75.         luVOID i,j,k,m,n,u,v;
  76.         double *pa,*pb,*pc;
  77.         luMessage pMessage;
  78.         wchar_t wchNum[32];
  79.         char chNum[32];
  80.         a.BType=luStaData_nil; a.VType=luStaData_nil; a.x=0;
  81.         switch(theOperator)
  82.         {
  83.         case 2:        //重载运算符*
  84.                 pMatrix1=(myMatrix *)SearchKey((char *)&(xx->x),sizeof(luVOID),Matrix);
  85.                 pMatrix2=(myMatrix *)SearchKey((char *)&((xx+1)->x),sizeof(luVOID),Matrix);
  86.                 if(!pMatrix1 || !pMatrix2) break;        //对象句柄无效,不是矩阵
  87.                 if(pMatrix1->Dim[1]!=pMatrix2->Dim[0]) break;        //维数不匹配
  88.                 pMatrix3=NewMatrix(pMatrix1->Dim[0],pMatrix2->Dim[1]);        //生成新矩阵
  89.                 if(!pMatrix3) break;
  90.                 pa=pMatrix1->Array; pb=pMatrix2->Array; pc=pMatrix3->Array;
  91.                 m=pMatrix1->Dim[0]; n=pMatrix1->Dim[1]; k=pMatrix2->Dim[1];
  92.                 for(i=0; i<m; i++)        //矩阵乘
  93.                 {
  94.                         for(j=0; j<k; j++)
  95.                         {
  96.                                 u=i*k+j; pc[u]=0.0;
  97.                                 for (v=0; v<n; v++)
  98.                                 {
  99.                                         pc[u]=pc[u]+pa[i*n+v]*pb[v*k+j];
  100.                                 }
  101.                         }
  102.                 }
  103.                 FunReObj(hFor);        //告诉Lu,返回一个动态对象
  104.                 a.BType=Matrix; a.VType=Matrix; a.x=0; *(luVOID *)&(a.x)=(luVOID)pMatrix3;
  105.                 break;
  106.         case 25:        //重载运算符.*
  107.                 pMatrix1=(myMatrix *)SearchKey((char *)&(xx->x),sizeof(luVOID),Matrix);
  108.                 pMatrix2=(myMatrix *)SearchKey((char *)&((xx+1)->x),sizeof(luVOID),Matrix);
  109.                 if(!pMatrix1 || !pMatrix2) break;        //对象句柄无效,不是矩阵
  110.                 if(pMatrix1->Dim[0]!=pMatrix2->Dim[0] || pMatrix1->Dim[1]!=pMatrix2->Dim[1]) break;        //维数不相同
  111.                 pMatrix3=NewMatrix(pMatrix1->Dim[0],pMatrix1->Dim[1]);        //生成新矩阵
  112.                 if(!pMatrix3) break;
  113.                 for(i=0;i<pMatrix1->ArrayLen;i++) pMatrix3->Array[i]=pMatrix1->Array[i]*pMatrix2->Array[i];        //矩阵点乘
  114.                 FunReObj(hFor);        //告诉Lu,返回一个动态对象
  115.                 a.BType=Matrix; a.VType=Matrix; a.x=0; *(luVOID *)&(a.x)=(luVOID)pMatrix3;
  116.                 break;
  117.         case 46:        //重载函数new
  118.                 if(mm<2) break;
  119.                 if((xx+1)->x<1 || (xx+2)->x<1 || (xx+1)->BType!=luStaData_int64 || (xx+2)->BType!=luStaData_int64) break;
  120.                 pMatrix3=NewMatrix((luVOID)(xx+1)->x,(luVOID)(xx+2)->x);//生成新矩阵
  121.                 if(!pMatrix3) break;
  122.                 for(j=0,i=3;i<=mm;i++,j++)        //赋初值
  123.                 {
  124.                         if(j>=pMatrix3->ArrayLen) break;
  125.                         if((xx+i)->BType!=luStaData_double) break;        //只接受实数参数
  126.                         pMatrix3->Array[j]=*(double *)&((xx+i)->x);
  127.                 }
  128.                 FunReObj(hFor);        //告诉Lu,返回一个动态对象
  129.                 a.BType=Matrix; a.VType=Matrix; a.x=0; *(luVOID *)&(a.x)=(luVOID)pMatrix3;
  130.                 break;
  131.         case 49:        //重载函数o
  132.                 pMessage=(luMessage)SearchKey("\0\0\0\0",sizeof(luVOID),luPubKey_User);
  133.                 if(!pMessage) break;
  134.                 pMatrix1=(myMatrix *)SearchKey((char *)&(xx->x),sizeof(luVOID),Matrix);
  135.                 if(!pMatrix1) break;        //对象句柄无效,不是矩阵
  136.                 pa=pMatrix1->Array;
  137.                 m=pMatrix1->Dim[0]; n=pMatrix1->Dim[1]; k=0;
  138.                 for(i=0; i<m; i++)        //输出矩阵
  139.                 {
  140.                         pMessage(L"\r\n"); k+=2;
  141.                         for(j=0; j<n; j++)
  142.                         {
  143.                                 _gcvt_s(chNum,pa[i*n+j],16);
  144.                                 for(u=0;chNum[u];u++) {wchNum[u]=chNum[u]; k++;}
  145.                                 wchNum[u]='\0';
  146.                                 pMessage(wchNum); pMessage(L"  "); k+=2;
  147.                         }
  148.                 }
  149.                 pMessage(L"\r\n"); k+=2;
  150.                 a.BType=luStaData_int64; a.VType=luStaData_int64; a.x=k;        //按函数o的要求,返回输出的字符总数
  151.                 break;
  152.         default:
  153.                 break;
  154.         }
  155.         return a;
  156. }
  157. void main(void)
  158. {
  159.         void *hFor;                //表达式句柄
  160.         luINT nPara;                //存放表达式的自变量个数
  161.         LuData *pPara;                //存放输入自变量的数组指针
  162.         luINT ErrBegin,ErrEnd;        //表达式编译出错的初始位置和结束位置
  163.         int ErrCode;                //错误代码
  164.         void *v;
  165.         wchar_t ForStr[]=L"o{new[matrix,2,3: 0.,1.,2.;3.,4.,5.]*new[matrix,3,2: 1.,2.;3.,4.;5.,6.]}";//字符串表达式,矩阵乘
  166.         //wchar_t ForStr[]=L"o{new[matrix,2,3: 0.,1.,2.;3.,4.,5.].*new[matrix,2,3: 1.,2.,3.;4.,5.,6.]}";//字符串表达式,矩阵点乘
  167.         LuData Val;
  168.         if(!InitLu()) return;        //初始化Lu
  169.         while(LockKey(Matrix,DelMatrix,OpMatrix)){Matrix--;}        //锁定一个键,用于存储矩阵扩展类型

  170.         Val.BType=luStaData_int64; Val.VType=luStaData_int64; Val.x=Matrix;        //定义整数常量
  171.         SetConst(L"matrix",&Val);        //设置整数常量
  172.         InsertKey("\0\0\0\0",4,luPubKey_User,LuMessage,NULL,NULL,1,v); //使Lu运行时可输出函数信息
  173.         wcout.imbue(locale("chs"));        //设置输出的locale为中文
  174.   
  175.         ErrCode=LuCom(ForStr,0,0,0,hFor,nPara,pPara,ErrBegin,ErrEnd); //编译表达式
  176.         if(ErrCode)
  177.         {
  178.                 wcout<<L"表达式有错误!错误代码:"<<ErrCode<<endl;
  179.         }
  180.         else
  181.         {
  182.                 LuCal(hFor,pPara);        //计算表达式的值
  183.         }
  184.         LockKey(Matrix,NULL,OpMatrix);//解锁键Matrix,本例中,该函数可以不用
  185.         FreeLu();                        //释放Lu
  186. }
复制代码
习题:

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

    (2)小矩阵乘效率测试。编译运行以下Lu字符串代码:
  1. main(:a,b,c,d,t,i)=
  2.     a=new[matrix,2,2: 1.,2.,2.,1.],
  3.     b=new[matrix,2,2: 2.,1.,1.,2.],
  4.     c=new[matrix,2,2: 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: 1.,2.,2.,1.], b=new[matrix,2,2: 2.,1.,1.,2.], c=new[matrix,2,2: 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.797 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-5-19 21:49 , Processed in 0.042559 second(s), 16 queries .

Powered by Discuz! X3.5

© 2001-2024 Discuz! Team.

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