循序渐进Lu例程
来源:互联网 发布:扇贝单词mac版 编辑:程序博客网 时间:2024/03/28 16:31
欢迎访问Lu程序设计
循序渐进Lu例程
目 录
1 概述2 预备知识
3 最简单的例子
4 检测运行错误
5 检测返回值的类型
6 使Lu能输出信息7 注册常量和二级函数
8 编写使用表达式的二级函数
9 基于系统内置对象创建扩展数据类型
10 创建自定义数据类型
11 结语
1 概述 [返回页首]
如果你喜欢Lu,想用Lu编程而又无从下手,那么本文的例子将会对你有所帮助。
本文所有的例子均在VS C++ 2008环境下编译通过,编译时请将活动解决方案配置为“Release”。这都是些完整的例子,复制下来直接编译运行即可。为了减少代码,这些例子都是控制台应用程序,简单地加以改写,将它应用到实用的Windows程序中去是不难的。
本文没有穷尽Lu的所有用法和功能,而且还很不够。如果你还有什么不明白的,可以直接与我联系:forcal@sina.com 。
2 预备知识 [返回页首]
使用Lu的预备知识并不多,只要你会加载和卸载动态库(dll),而且懂一点多线程编程的知识就可以了。
2.1 加载和卸载Lu
(1)隐式调用
使用Lu核心库的导入库文件lu32.lib。这种方法比较方便,本文的例子大多是隐式调用例子。
(2)显示调用
应用程序可调用LoadLibrary直接加载Lu32.dll。
HANDLE hLu; //动态库模块句柄; hLu=LoadLibrary(L"Lu32.dll"); //加载动态库Lu32.dll;
加载Lu32.dll成功后,需调用函数GetProcAddress获取Lu输出函数的地址。例如:
luInitLu pInitLu; //luInitLu 在头文件Lu32.h中定义,为初始化Lu的函数指针; pInitLu=(luInitLu) GetProcAddress(hLu,"InitLu");
该函数获得了初始化Lu的函数地址,保存在指针pInitLu中。
当程序不再需要访问Lu32.dll时,应调用函数FreeLibrary将其卸载。
FreeLibrary(hLu); //释放动态库Lu32.dll;
2.2 在多线程中使用Lu
Lu可以用在单线程程序中,但不能及时退出漫长的计算过程或无限循环。没人愿意使用一个经常失去响应的程序。
为了安全地使用Lu,应用程序至少有两个线程,一个用于Lu计算,另一个用于监视Lu运行。
为了简单,本文的例子都是单线程的。多线程是一个更高级的概念,本文作为使用Lu的引玉之砖,没有提供这方面的例子。
3 最简单的例子[返回页首]
只用到了Lu的四个输出函数:初始化Lu的函数InitLu,释放Lu的函数FreeLu,编译表达式的函数LuCom和计算表达式的函数LuCal。
(1)隐式调用
仅需要以下支持文件(以后不再说明):
1)头文件lu32.h。
2)导入库lu32.lib。
3)核心库lu32.dll。
#include <windows.h>#include <iostream>#include <math.h>#include "lu32.h"//Lu头文件#pragma comment( lib, "lu32.lib" )using namespace std;void main(void){void *hFor;//表达式句柄luINT nPara;//存放表达式的自变量个数LuData *pPara;//存放输入自变量的数组指针LuData Val;//存放表达式的值luINT ErrBegin,ErrEnd;//表达式编译出错的初始位置和结束位置int ErrCode;//错误代码wchar_t ForStr[]=L"f(x,y)=x+y";//字符串表达式int i;if(!InitLu()) return;//初始化LuErrCode=LuCom(ForStr,0,0,0,hFor,nPara,pPara,ErrBegin,ErrEnd);//编译表达式if(ErrCode){cout<<"表达式有错误!错误代码:"<<ErrCode<<endl;}else{for(i=0;i<=nPara;i++)//表达式自变量赋值,均赋值为1{pPara[i].BType=luStaData_int64; pPara[i].VType=luStaData_int64; pPara[i].x=1;}Val=LuCal(hFor,pPara);//计算表达式的值cout<<Val.x<<endl;}FreeLu();//释放Lu}
运行结果:
2
请按任意键继续. . .
(2)显示调用
这个例子有三个函数:加载并初始化Lu的函数theInitLu,释放Lu的函数theFreeLu和主函数main,主函数编译并计算了一个表达式的值。前两个函数的内容完全可以并入主函数,但分开写显得更清晰一些。
#include <windows.h>#include <cmath>#include <iostream>#include <iomanip>#include "Lu32.h"using namespace std;HINSTANCE hLu=NULL;//动态库Lu32.dll的句柄//动态库输出函数;luInitLu pInitLu;luFreeLu pFreeLu;luLuCom pLuCom;luLuCal pLuCal;bool theInitLu(void)//初始化Lu{hLu=LoadLibrary(L"Lu32.dll");//加载动态库Lu32.dllif(!hLu){cout<<"找不到Lu32.dll!请将该库放到WINDOWS的搜索路径内!";return false;}//以下几个语句获取Lu32.dll中所调用函数的地址pInitLu=(luInitLu) GetProcAddress(hLu,"InitLu");pFreeLu=(luFreeLu) GetProcAddress(hLu,"FreeLu");pLuCom=(luLuCom) GetProcAddress(hLu,"LuCom");pLuCal=(luLuCal) GetProcAddress(hLu,"LuCal");if(!pInitLu||!pFreeLu||!pLuCom||!pLuCal){cout<<"无效的动态库函数!"<<endl;FreeLibrary(hLu);//释放动态库Lu32.dllhLu=NULL;return false;}pInitLu();//初始化Lu32.dllreturn true;}void theFreeLu(void)//释放Lu{pFreeLu();//释放Lu申请的空间FreeLibrary(hLu);//释放动态库}void main(void){void *hFor; //表达式句柄luINT nPara; //存放表达式的自变量个数LuData *pPara; //存放输入自变量的数组指针LuData Val; //存放表达式的值luINT ErrBegin,ErrEnd; //表达式编译出错的初始位置和结束位置int ErrCode; //错误代码wchar_t ForStr[]=L"f(x,y)=x+y"; //字符串表达式int i;if(!theInitLu()) return; //初始化LuErrCode=LuCom(ForStr,0,0,0,hFor,nPara,pPara,ErrBegin,ErrEnd); //编译表达式if(ErrCode){cout<<"表达式有错误!错误代码:"<<ErrCode<<endl;}else{for(i=0;i<=nPara;i++) //表达式自变量赋值,均赋值为1{pPara[i].BType=luStaData_int64; pPara[i].VType=luStaData_int64; pPara[i].x=1;}Val=LuCal(hFor,pPara); //计算表达式的值cout<<Val.x<<endl;}theFreeLu(); //释放Lu}
运行结果:
2
请按任意键继续. . .
习题:
(1)更换不同的字符串表达式ForStr,重新编译运行程序,观察计算结果。
4 检测运行错误 [返回页首]
Lu在遇到运行错误时,就会停止计算而退出。在这个例子中,我们将添加运行错误检测功能。为此,只需要增加Lu的一个输出函数GetRunErr就可以了。
本例子是上一个例子的继续,新添加的部分用红色标记。
#include <windows.h>#include <iostream>#include <math.h>#include "lu32.h"//Lu头文件#pragma comment( lib, "lu32.lib" )using namespace std;void main(void){void *hFor;//表达式句柄luINT nPara;//存放表达式的自变量个数LuData *pPara;//存放输入自变量的数组指针LuData Val;//存放表达式的值luINT ErrBegin,ErrEnd;//表达式编译出错的初始位置和结束位置int ErrCode;//错误代码wchar_t ForStr[]=L"f()=f()";//字符串表达式,无穷递归调用引起堆栈溢出int i;int ErrType;//运行错误类型wchar_t *FunName;//出错函数名void *ForHandle;//运行出错的表达式句柄if(!InitLu()) return;//初始化Luwcout.imbue(locale("chs"));//设置输出的locale为中文GetRunErr(ErrType,FunName,ErrCode,ForHandle);//设置运行错误为无错状态ErrCode=LuCom(ForStr,0,0,0,hFor,nPara,pPara,ErrBegin,ErrEnd);//编译表达式if(ErrCode){cout<<"表达式有错误!错误代码:"<<ErrCode<<endl;}else{for(i=0;i<=nPara;i++)//表达式自变量赋值,均赋值为1{pPara[i].BType=luStaData_int64; pPara[i].VType=luStaData_int64; pPara[i].x=1;}Val=LuCal(hFor,pPara);//计算表达式的值GetRunErr(ErrType,FunName,ErrCode,ForHandle);//检查运行错误if(ErrType){wcout<<L"出现运行错误!错误类型:"<<ErrType<<L" 出错函数名:"<<FunName<<L" 错误代码:"<<ErrCode<<endl;}else{wcout<<L"返回值:"<<Val.x<<L" 基本类型:"<<Val.BType<<L" 扩展类型:"<<Val.VType<<endl;}}FreeLu();//释放Lu}
运行结果:
出现运行错误!错误类型:1 出错函数名:Lu::StackOverFlow 错误代码:1
请按任意键继续. . .
习题:
(1)更换不同的字符串表达式ForStr,重新编译运行程序,观察计算结果。
5检测返回值的类型[返回页首]
在这个例子中,我们将检测返回值的类型并输出不同结果。
本例子是上一个例子的继续,新添加的部分用红色标记。
#include <windows.h>#include <iostream>#include <math.h>#include "lu32.h"//Lu头文件#pragma comment( lib, "lu32.lib" )using namespace std;void main(void){void *hFor;//表达式句柄luINT nPara;//存放表达式的自变量个数LuData *pPara;//存放输入自变量的数组指针LuData Val;//存放表达式的值luINT ErrBegin,ErrEnd;//表达式编译出错的初始位置和结束位置int ErrCode;//错误代码wchar_t ForStr[]=L"2-3i";//字符串表达式int i;int ErrType;//运行错误类型wchar_t *FunName;//出错函数名void *ForHandle;//运行出错的表达式句柄wchar_t *pStr;if(!InitLu()) return;//初始化Luwcout.imbue(locale("chs"));//设置输出的locale为中文GetRunErr(ErrType,FunName,ErrCode,ForHandle);//设置运行错误为无错状态ErrCode=LuCom(ForStr,0,0,0,hFor,nPara,pPara,ErrBegin,ErrEnd);//编译表达式if(ErrCode){cout<<"表达式有错误!错误代码:"<<ErrCode<<endl;}else{for(i=0;i<=nPara;i++)//表达式自变量赋值,均赋值为1{pPara[i].BType=luStaData_int64; pPara[i].VType=luStaData_int64; pPara[i].x=1;}Val=LuCal(hFor,pPara);//计算表达式的值GetRunErr(ErrType,FunName,ErrCode,ForHandle);//检查运行错误if(ErrType){wcout<<L"出现运行错误!错误类型:"<<ErrType<<L" 出错函数名:"<<FunName<<L" 错误代码:"<<ErrCode<<endl;}else{wcout<<L"返回值基本类型:"<<Val.BType<<L" 扩展类型:"<<Val.VType<<endl;switch(Val.BType){case luStaData_nil:wcout<<L"nil"<<endl;break;case luStaData_int64:wcout<<Val.x<<endl;break;case luStaData_double:wcout<<*(double *)&(Val.x)<<endl;break;case luStaData_complex:wcout<<L"复数 实部:"<<*(double *)&(Val.x)<<L" 虚部:"<<*(double *)&(Val.y)<<endl;break;case luStaData_logical:if(Val.x)wcout<<L"true"<<endl;elsewcout<<L"false"<<endl;break;case luStaData_string:case luDynData_string:pStr=GetStr(&Val,NULL,i);if(pStr) wcout<<pStr<<endl;break;default:wcout<<L"不可识别的类型!"<<endl;}}}FreeLu();//释放Lu}
结果:
返回值基本类型:4 扩展类型:4
复数 实部:2 虚部:-3
请按任意键继续. . .
习题:
(1)更换字符串表达式ForStr的内容为"\"abc\"+\"123\"",重新编译运行程序,观察计算结果。[Lu不允许两个静态字符串相加]
(2)更换字符串表达式ForStr的内容为"new[string,\"abc\"]+\"123\"",重新编译运行程序,观察计算结果。
(3)更换字符串表达式ForStr的内容为"1>2",重新编译运行程序,观察计算结果。
6 使Lu能输出信息 [返回页首]
Lu核心库的函数o以及许多注册到Lu的二级函数都将返回一些信息,为此,需要注册一个luMessage类型的函数到Lu(用luPubKey_User类型的4字节串"\0\0\0\0"键标识)。
#include <windows.h>#include <iostream>#include <math.h>#include "lu32.h"#pragma comment( lib, "lu32.lib" )using namespace std;void _stdcall LuMessage(wchar_t *pch) //输出动态库信息,该函数注册到Lu,由Lu二级函数调用 {wcout<<pch;}void main(void){void *hFor;//表达式句柄luINT nPara;//存放表达式的自变量个数LuData *pPara;//存放输入自变量的数组指针luINT ErrBegin,ErrEnd;//表达式编译出错的初始位置和结束位置int ErrCode;//错误代码void *v;wchar_t ForStr[]=L"o{\"o函数返回的信息:\",22,\" \",22.,\" \",2-3i,\" \",1$2$3,\" \",2>3}";//字符串表达式if(!InitLu()) return;//初始化LuInsertKey("\0\0\0\0",4,luPubKey_User,LuMessage,NULL,NULL,1,v); //使Lu运行时可输出函数信息wcout.imbue(locale("chs"));//设置输出的locale为中文 ErrCode=LuCom(ForStr,0,0,0,hFor,nPara,pPara,ErrBegin,ErrEnd); //编译表达式if(ErrCode){wcout<<L"表达式有错误!错误代码:"<<ErrCode<<endl;}else{LuCal(hFor,pPara);//计算表达式的值}FreeLu();//释放Lu}
结果:
o函数返回的信息:22 22. {(2.)$(-3.)} {(1.)$(2.)$(3.)} false请按任意键继续. . .
7 注册常量和二级函数 [返回页首]
在这个例子中,我们将往Lu中注册常量和二级函数。
使用Lu的输出函数SetConst可以往Lu中添加常量,本例中只添加了一个实型常量PI。
使用Lu的输出函数SetFunction可以往Lu中添加二级函数,本例中只添加了一个二级函数add。
本例子是上一个例子的继续,新添加的部分用红色标记。
#include <windows.h>#include <iostream>#include <math.h>#include "lu32.h"#pragma comment( lib, "lu32.lib" )using namespace std;void _stdcall LuMessage(wchar_t *pch) //输出动态库信息,该函数注册到Lu,由Lu二级函数调用 {wcout<<pch;}//二级函数定义LuData _stdcall Fun2_add(luINT mm,LuData *xx,void *vFor)//计算两个数的和,仅支持整数和实数加{LuData a;if(xx->VType==luStaData_int64 && (xx+1)->VType==luStaData_int64){a.BType=luStaData_int64; a.VType=luStaData_int64;a.x=xx->x+(xx+1)->x;}else if(xx->VType==luStaData_double && (xx+1)->VType==luStaData_double){a.BType=luStaData_double; a.VType=luStaData_double;*(double *)&(a.x)=*(double *)&(xx->x)+(*(double *)&((xx+1)->x));}else{a.BType=luStaData_nil; a.VType=luStaData_nil; a.x=0;}return a;}void main(void){void *hFor;//表达式句柄luINT nPara;//存放表达式的自变量个数LuData *pPara;//存放输入自变量的数组指针luINT ErrBegin,ErrEnd;//表达式编译出错的初始位置和结束位置int ErrCode;//错误代码void *v;wchar_t ForStr[]=L"o{\"2+3=\",add[2,3],\" 2.0+3.0=\",add[2.0,3.0],\" 2.0+3=\",add[2.0,3],\" PI=\",PI}";//字符串表达式LuData Val;if(!InitLu()) return;//初始化LuInsertKey("\0\0\0\0",4,luPubKey_User,LuMessage,NULL,NULL,1,v); //使Lu运行时可输出函数信息Val.BType=luStaData_double; Val.VType=luStaData_double; *(double *)&(Val.x)=3.1416;//定义实数常量SetConst(L"PI",&Val);//设置实型常量SetFunction(L"add",Fun2_add,1);//设置二级函数wcout.imbue(locale("chs"));//设置输出的locale为中文 ErrCode=LuCom(ForStr,0,0,0,hFor,nPara,pPara,ErrBegin,ErrEnd); //编译表达式if(ErrCode){wcout<<L"表达式有错误!错误代码:"<<ErrCode<<endl;}else{LuCal(hFor,pPara);//计算表达式的值}FreeLu();//释放Lu}
结果:
2+3=5 2.0+3.0=5. 2.0+3=nil PI=3.1415999999999999请按任意键继续. . .
习题:
(1)在本例的基础上再添加一个实型常量_E=2.718,更换字符串表达式ForStr的内容为"_E",重新编译运行程序,观察计算结果。
(2)在本例的基础上再添加一个二级函数PrintStr,该函数已在下面给出,该函数使用了Lu的输出函数GetStr以获得字符串,并使用函数SearchKey以获得输出信息函数(就是我们注册的函数LuMessage)的句柄。记着更换字符串表达式ForStr的内容为"PrintStr(\"hello Lu!\")",观察运行效果。
LuData _stdcall PrintStr(luINT mm,LuData *xx,void *vFor)//输出字符串{luMessage pMessage;wchar_t *pStr;luVOID i=0;pMessage=(luMessage)SearchKey((char *)&i,sizeof(luVOID),luPubKey_User);if(pMessage){pStr=GetStr(xx,vFor,i);if(pStr) pMessage(pStr);}return *xx;}
(3)在本例的基础上再添加一个自定义的二级函数并检查运行效果。
8 编写使用表达式的二级函数[返回页首]
本例注册了两个二级函数,函数ExeStrFor接受字符串形式的函数名并调用该函数,函数ExeHFor接受表达式句柄并调用该函数。
本例还将演示如何使用函数SetRunErr返回运行错误,以提供给用户更多的出错诊断信息。
#include <windows.h>#include <iostream>#include <math.h>#include "lu32.h"#pragma comment( lib, "lu32.lib" )using namespace std;void _stdcall LuMessage(wchar_t *pch) //输出动态库信息,该函数注册到Lu,由Lu二级函数调用 {wcout<<pch;}//二级函数定义LuData _stdcall ExeStrFor(luINT mm,LuData *xx,void *vFor)//通过字符串形式的函数名调用一个函数{LuData a;static wchar_t ErrName[]=L"ExeStrFor";wchar_t *pStr;luINT nPara;luVOID nModule;void *hFor,*vPara;a.BType=luStaData_nil; a.VType=luStaData_nil; a.x=0;if(mm<0)//至少需要1个参数{SetRunErr(1,ErrName,1,0,vFor);return a;}pStr=GetStr(xx,vFor,nModule);if(!pStr)//非法字符串参数{SetRunErr(1,ErrName,2,0,vFor);return a;}if(GetFor(pStr,1,vFor,nModule,hFor,vPara,nPara)){if(nPara!=mm-1)//调用表达式时参数不匹配{SetRunErr(1,ErrName,3,0,vFor);return a;}return LuCal(hFor,xx+1);}else//找不到表达式{SetRunErr(1,ErrName,4,0,vFor);return a;}}LuData _stdcall ExeHFor(luINT mm,LuData *xx,void *vFor)//通过表达式句柄调用一个函数{LuData a;static wchar_t ErrName[]=L"ExeHFor";luINT nPara;luVOID nModule;void *hFor,*vPara;a.BType=luStaData_nil; a.VType=luStaData_nil; a.x=0;if(mm<0)//至少需要1个参数{SetRunErr(1,ErrName,1,0,vFor);return a;}if(xx->BType!=luStaData_forhandle)//不是一个表达式句柄参数{SetRunErr(1,ErrName,2,0,vFor);return a;}if(GetFor(NULL,1,(void *)*(luVOID *)&(xx->x),nModule,hFor,vPara,nPara)){if(nPara!=mm-1)//调用表达式时参数不匹配{SetRunErr(1,ErrName,3,0,vFor);return a;}return LuCal(hFor,xx+1);}else//找不到表达式{SetRunErr(1,ErrName,4,0,vFor);return a;}}void main(void){void *hFor;//表达式句柄luINT nPara;//存放表达式的自变量个数LuData *pPara;//存放输入自变量的数组指针luINT ErrBegin,ErrEnd;//表达式编译出错的初始位置和结束位置int ErrCode1,ErrCode2;//错误代码void *v;int ErrType;//运行错误类型wchar_t *FunName;//出错函数名void *ForHandle;//运行出错的表达式句柄wchar_t ForStr[]=L"f(x,y)=x+y";//字符串表达式wchar_t MainStr[]=L"o{ExeHFor[@f,2,3],\"\r\n\"}";//字符串表达式if(!InitLu()) return;//初始化LuInsertKey("\0\0\0\0",4,luPubKey_User,LuMessage,NULL,NULL,1,v); //使Lu运行时可输出函数信息SetFunction(L"ExeStrFor",ExeStrFor,-2);//设置二级函数SetFunction(L"ExeHFor",ExeHFor,-2);//设置二级函数wcout.imbue(locale("chs"));//设置输出的locale为中文 ErrCode1=LuCom(ForStr,0,0,0,hFor,nPara,pPara,ErrBegin,ErrEnd);//编译表达式ErrCode2=LuCom(MainStr,0,0,0,hFor,nPara,pPara,ErrBegin,ErrEnd);//编译表达式if(ErrCode1 || ErrCode2){wcout<<L"表达式有错误!错误代码:"<<ErrCode1<<L" "<<ErrCode2<<endl;}else{LuCal(hFor,pPara);//计算表达式的值GetRunErr(ErrType,FunName,ErrCode1,ForHandle);//检查运行错误if(ErrType){wcout<<L"出现运行错误!错误类型:"<<ErrType<<L" 出错函数名:"<<FunName<<L" 错误代码:"<<ErrCode1<<endl;}}FreeLu();//释放Lu}
结果:
5请按任意键继续. . .
习题:
(1)将MainStr修改如下,重新编译运行程序,观察计算结果。
wchar_t MainStr[]=L"o{ExeStrFor[\"f\",2,3],\"\r\n\"}";//字符串表达式
(2)将MainStr修改如下,重新编译运行程序,观察计算结果。
wchar_t MainStr[]=L"o{ExeStrFor[\"f\",2],\"\r\n\"}";//字符串表达式
9 基于系统内置对象创建扩展数据类型[返回页首]
本例中,我们将基于系统内置实数数组创建矩阵(matrix)类型,即:基本类型为luDynData_realarray(标识实数数组),扩展类型为matrix(标识矩阵)。为了简单,我们仅处理二维实数数组即矩阵类型。
基本要点:
(1)为扩展类型matrix编写运算符重载函数OpMatrix。
(2)用函数LockKey将重载函数OpMatrix注册到Lu,锁定的键的类型即为matrix,要注册为常量,以便于使用。
(3)为扩展类型matrix编写其他操作函数(本例未提供)。
(4)用函数LockKey解锁键matrix(本例中,程序退出时会自动解锁,故可以不用)。
#include <windows.h>#include <iostream>#include <math.h>#include "lu32.h"#pragma comment( lib, "lu32.lib" )using namespace std;luKEY Matrix=-1000;//标识矩阵类型,最终的Matrix由LockKey决定void _stdcall LuMessage(wchar_t *pch)//输出动态库信息,该函数注册到Lu,由Lu二级函数调用 {wcout<<pch;}void _stdcall DelMatrix(void *me)//用于LockKey函数,因为是基于系统内置实数数组创建矩阵,故该函数什么也不做{}LuData _stdcall OpMatrix(luINT mm,LuData *xx,void *hFor,int theOperator)//运算符重载函数,用于LockKey函数{LuData a;luRealArray *pRealArray1,*pRealArray2,*pRealArray3;luVOID i,j,k,m,n,u,v;double *pa,*pb,*pc;luMessage pMessage;wchar_t wchNum[32];char chNum[32];a.BType=luStaData_nil; a.VType=luStaData_nil; a.x=0;switch(theOperator){case 2://重载运算符*pRealArray1=(luRealArray *)SearchKey((char *)&(xx->x),sizeof(luVOID),luDynData_realarray);pRealArray2=(luRealArray *)SearchKey((char *)&((xx+1)->x),sizeof(luVOID),luDynData_realarray);if(!pRealArray1 || !pRealArray2) break;//对象句柄无效,不是实数数组if(pRealArray1->DimLen!=2 || pRealArray2->DimLen!=2) break;//不是二维实数数组(矩阵)if(pRealArray1->Dim[1]!=pRealArray2->Dim[0]) break;//维数不匹配pRealArray3=(luRealArray *)NewSysObj(luDynData_realarray,pRealArray1->Dim[0]*pRealArray2->Dim[1],2);//创建矩阵对象if(!pRealArray3) break;pRealArray3->Dim[0]=pRealArray1->Dim[0]; pRealArray3->Dim[1]=pRealArray2->Dim[1];//设置矩阵维数大小pa=pRealArray1->Array; pb=pRealArray2->Array; pc=pRealArray3->Array;m=pRealArray1->Dim[0]; n=pRealArray1->Dim[1]; k=pRealArray2->Dim[1];for(i=0; i<m; i++)//矩阵乘{for(j=0; j<k; j++){u=i*k+j; pc[u]=0.0;for (v=0; v<n; v++){pc[u]=pc[u]+pa[i*n+v]*pb[v*k+j];}}}FunReObj(hFor);//告诉Lu,返回一个动态对象a.BType=luDynData_realarray; a.VType=Matrix; a.x=0; *(luVOID *)&(a.x)=(luVOID)pRealArray3;break;case 25://重载运算符.*pRealArray1=(luRealArray *)SearchKey((char *)&(xx->x),sizeof(luVOID),luDynData_realarray);pRealArray2=(luRealArray *)SearchKey((char *)&((xx+1)->x),sizeof(luVOID),luDynData_realarray);if(!pRealArray1 || !pRealArray2) break;//对象句柄无效,不是实数数组if(pRealArray1->DimLen!=2 || pRealArray2->DimLen!=2) break;//不是二维实数数组(矩阵)if(pRealArray1->Dim[0]!=pRealArray2->Dim[0] || pRealArray1->Dim[1]!=pRealArray2->Dim[1]) break;//维数不相同pRealArray3=(luRealArray *)NewSysObj(luDynData_realarray,pRealArray1->ArrayLen,2);//创建矩阵对象if(!pRealArray3) break;pRealArray3->Dim[0]=pRealArray1->Dim[0]; pRealArray3->Dim[1]=pRealArray1->Dim[1];//设置矩阵维数大小for(i=0;i<pRealArray1->ArrayLen;i++) pRealArray3->Array[i]=pRealArray1->Array[i]*pRealArray2->Array[i];//矩阵点乘FunReObj(hFor);//告诉Lu,返回一个动态对象a.BType=luDynData_realarray; a.VType=Matrix; a.x=0; *(luVOID *)&(a.x)=(luVOID)pRealArray3;break;case 46://重载函数newa=ExeOperator(mm,xx,hFor,theOperator,luDynData_realarray);//直接调用基本类型luDynData_realarray的new函数if(a.VType==luDynData_realarray) a.VType=Matrix;//设置扩展类型为自定义的Matrix类型break;case 49://重载函数opMessage=(luMessage)SearchKey("\0\0\0\0",sizeof(luVOID),luPubKey_User);if(!pMessage) break;pRealArray1=(luRealArray *)SearchKey((char *)&(xx->x),sizeof(luVOID),luDynData_realarray);if(!pRealArray1) break;//对象句柄无效,不是实数数组if(pRealArray1->DimLen!=2) break;//不是二维实数数组(矩阵)pa=pRealArray1->Array;m=pRealArray1->Dim[0]; n=pRealArray1->Dim[1]; k=0;for(i=0; i<m; i++)//输出矩阵{pMessage(L"\r\n"); k+=2;for(j=0; j<n; j++){_gcvt_s(chNum,pa[i*n+j],16);for(u=0;chNum[u];u++) {wchNum[u]=chNum[u]; k++;}wchNum[u]='\0';pMessage(wchNum); pMessage(L" "); k+=2;}}pMessage(L"\r\n"); k+=2;a.BType=luStaData_int64; a.VType=luStaData_int64; a.x=k;//按函数o的要求,返回输出的字符总数break;default:break;}return a;}void main(void){void *hFor;//表达式句柄luINT nPara;//存放表达式的自变量个数LuData *pPara;//存放输入自变量的数组指针luINT ErrBegin,ErrEnd;//表达式编译出错的初始位置和结束位置int ErrCode;//错误代码void *v;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.]}";//字符串表达式,矩阵乘//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.]}";//字符串表达式,矩阵点乘LuData Val;if(!InitLu()) return;//初始化Luwhile(LockKey(Matrix,DelMatrix,OpMatrix)){Matrix--;}//锁定一个键,用于存储矩阵扩展类型Val.BType=luStaData_int64; Val.VType=luStaData_int64; Val.x=Matrix;//定义整数常量SetConst(L"matrix",&Val);//设置整数常量InsertKey("\0\0\0\0",4,luPubKey_User,LuMessage,NULL,NULL,1,v); //使Lu运行时可输出函数信息wcout.imbue(locale("chs"));//设置输出的locale为中文 ErrCode=LuCom(ForStr,0,0,0,hFor,nPara,pPara,ErrBegin,ErrEnd); //编译表达式if(ErrCode){wcout<<L"表达式有错误!错误代码:"<<ErrCode<<endl;}else{LuCal(hFor,pPara);//计算表达式的值}LockKey(Matrix,NULL,OpMatrix);//解锁键Matrix,本例中,该函数可以不用FreeLu();//释放Lu}
习题:
(1)自定义矩阵的加、减、左除、右除、点左除等运算,自编测试字符串代码,重新编译运行程序,观察计算结果。
(2)小矩阵乘效率测试。编译运行以下Lu字符串代码:
main(:a,b,c,d,t,i)=
a=new[matrix,2,2,data: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"}
C/C++中的字符串定义为:
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\"}";//字符串表达式
结果:
4. 5.
5. 4.
time=0.875 seconds.
请按任意键继续. . .
Matlab 2009a 代码:
a=[1.,2.;2.,1.];
b=[2.,1.;1.,2.];
c=[2/3.,-1/3.;-1/3.,2/3.];
tic,
d=a*b;
for i=1:1000000
d=d*c*b;
end
d,
toc
结果:
d =
4 5 5 4
Elapsed time is 2.903034 seconds.
本例矩阵乘效率测试,Lu的速度超过了Matlab,主要在于Lu有更高的动态对象管理效率。
10 创建自定义数据类型[返回页首]
本例中,我们将自定义矩阵(matrix)类型,基本类型和扩展类型均为matrix(标识矩阵)。
基本要点:
(1)编写生成矩阵(matrix)的函数NewMatrix和销毁矩阵的函数DelMatrix。
(2)为自定义类型matrix编写运算符重载函数OpMatrix。
(3)用函数LockKey将重载函数OpMatrix注册到Lu,锁定的键的类型即为matrix,要注册为常量,以便于使用。
(4)为自定义类型matrix编写其他操作函数(本例未提供)。
(5)用函数LockKey解锁键matrix(本例中,程序退出时会自动解锁,故可以不用)。
#include <windows.h>#include <iostream>#include <math.h>#include "lu32.h"#pragma comment( lib, "lu32.lib" )using namespace std;//自定义矩阵class myMatrix{public:double *Array;//数据缓冲区luVOID ArrayLen;//数据缓冲区长度luVOID Dim[2];//矩阵维数myMatrix(){Array=NULL; ArrayLen=0; Dim[0]=0; Dim[1]=0;}~myMatrix(){if(Array) delete[] Array;}};luKEY Matrix=-1000;//标识矩阵类型,最终的Matrix由LockKey决定void _stdcall LuMessage(wchar_t *pch)//输出动态库信息,该函数注册到Lu,由Lu二级函数调用 {wcout<<pch;}void _stdcall DelMatrix(void *me)//用于LockKey函数及InsertKey函数,使Lu能自动销毁myMatrix对象{delete (myMatrix *)me;}myMatrix * _stdcall NewMatrix(luVOID m,luVOID n)//生成一个myMatrix对象{myMatrix *pMatrix;luVOID k;double *pa;char keyname[sizeof(luVOID)];void *NowKey;k=m*n;pMatrix=(myMatrix *)GetBufObj(Matrix,keyname);//先尝试从缓冲区中获取一个矩阵对象if(pMatrix){if(pMatrix->ArrayLen!=k)//重置矩阵的大小{pa=new double[k];if(!pa){DeleteKey(keyname,sizeof(luVOID),Matrix,DelMatrix,1);//将矩阵对象放回缓冲区return NULL;}delete[] pMatrix->Array;pMatrix->Array=pa;}}else{pMatrix=new myMatrix;//创建矩阵对象if(!pMatrix) return NULL;pMatrix->Array=new double[k];if(!pMatrix->Array){delete pMatrix;return NULL;}if(InsertKey((char *)&pMatrix,-1,Matrix,pMatrix,DelMatrix,NULL,0,NowKey))//将矩阵对象注册到Lu{delete pMatrix;return NULL;}}pMatrix->ArrayLen=k; pMatrix->Dim[0]=m; pMatrix->Dim[1]=n;return pMatrix;}LuData _stdcall OpMatrix(luINT mm,LuData *xx,void *hFor,int theOperator)//运算符重载函数,用于LockKey函数{LuData a;myMatrix *pMatrix1,*pMatrix2,*pMatrix3;luVOID i,j,k,m,n,u,v;double *pa,*pb,*pc;luMessage pMessage;wchar_t wchNum[32];char chNum[32];a.BType=luStaData_nil; a.VType=luStaData_nil; a.x=0;switch(theOperator){case 2://重载运算符*pMatrix1=(myMatrix *)SearchKey((char *)&(xx->x),sizeof(luVOID),Matrix);pMatrix2=(myMatrix *)SearchKey((char *)&((xx+1)->x),sizeof(luVOID),Matrix);if(!pMatrix1 || !pMatrix2) break;//对象句柄无效,不是矩阵if(pMatrix1->Dim[1]!=pMatrix2->Dim[0]) break;//维数不匹配pMatrix3=NewMatrix(pMatrix1->Dim[0],pMatrix2->Dim[1]);//生成新矩阵if(!pMatrix3) break;pa=pMatrix1->Array; pb=pMatrix2->Array; pc=pMatrix3->Array;m=pMatrix1->Dim[0]; n=pMatrix1->Dim[1]; k=pMatrix2->Dim[1];for(i=0; i<m; i++)//矩阵乘{for(j=0; j<k; j++){u=i*k+j; pc[u]=0.0;for (v=0; v<n; v++){pc[u]=pc[u]+pa[i*n+v]*pb[v*k+j];}}}FunReObj(hFor);//告诉Lu,返回一个动态对象a.BType=Matrix; a.VType=Matrix; a.x=0; *(luVOID *)&(a.x)=(luVOID)pMatrix3;break;case 25://重载运算符.*pMatrix1=(myMatrix *)SearchKey((char *)&(xx->x),sizeof(luVOID),Matrix);pMatrix2=(myMatrix *)SearchKey((char *)&((xx+1)->x),sizeof(luVOID),Matrix);if(!pMatrix1 || !pMatrix2) break;//对象句柄无效,不是矩阵if(pMatrix1->Dim[0]!=pMatrix2->Dim[0] || pMatrix1->Dim[1]!=pMatrix2->Dim[1]) break;//维数不相同pMatrix3=NewMatrix(pMatrix1->Dim[0],pMatrix1->Dim[1]);//生成新矩阵if(!pMatrix3) break;for(i=0;i<pMatrix1->ArrayLen;i++) pMatrix3->Array[i]=pMatrix1->Array[i]*pMatrix2->Array[i];//矩阵点乘FunReObj(hFor);//告诉Lu,返回一个动态对象a.BType=Matrix; a.VType=Matrix; a.x=0; *(luVOID *)&(a.x)=(luVOID)pMatrix3;break;case 46://重载函数newif(mm<2) break;if((xx+1)->x<1 || (xx+2)->x<1 || (xx+1)->BType!=luStaData_int64 || (xx+2)->BType!=luStaData_int64) break;pMatrix3=NewMatrix((luVOID)(xx+1)->x,(luVOID)(xx+2)->x);//生成新矩阵if(!pMatrix3) break;for(j=0,i=3;i<=mm;i++,j++)//赋初值{if(j>=pMatrix3->ArrayLen) break;if((xx+i)->BType!=luStaData_double) break;//只接受实数参数pMatrix3->Array[j]=*(double *)&((xx+i)->x);}FunReObj(hFor);//告诉Lu,返回一个动态对象a.BType=Matrix; a.VType=Matrix; a.x=0; *(luVOID *)&(a.x)=(luVOID)pMatrix3;break;case 49://重载函数opMessage=(luMessage)SearchKey("\0\0\0\0",sizeof(luVOID),luPubKey_User);if(!pMessage) break;pMatrix1=(myMatrix *)SearchKey((char *)&(xx->x),sizeof(luVOID),Matrix);if(!pMatrix1) break;//对象句柄无效,不是矩阵pa=pMatrix1->Array;m=pMatrix1->Dim[0]; n=pMatrix1->Dim[1]; k=0;for(i=0; i<m; i++)//输出矩阵{pMessage(L"\r\n"); k+=2;for(j=0; j<n; j++){_gcvt_s(chNum,pa[i*n+j],16);for(u=0;chNum[u];u++) {wchNum[u]=chNum[u]; k++;}wchNum[u]='\0';pMessage(wchNum); pMessage(L" "); k+=2;}}pMessage(L"\r\n"); k+=2;a.BType=luStaData_int64; a.VType=luStaData_int64; a.x=k;//按函数o的要求,返回输出的字符总数break;default:break;}return a;}void main(void){void *hFor;//表达式句柄luINT nPara;//存放表达式的自变量个数LuData *pPara;//存放输入自变量的数组指针luINT ErrBegin,ErrEnd;//表达式编译出错的初始位置和结束位置int ErrCode;//错误代码void *v;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.]}";//字符串表达式,矩阵乘//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.]}";//字符串表达式,矩阵点乘LuData Val;if(!InitLu()) return;//初始化Luwhile(LockKey(Matrix,DelMatrix,OpMatrix)){Matrix--;}//锁定一个键,用于存储矩阵扩展类型Val.BType=luStaData_int64; Val.VType=luStaData_int64; Val.x=Matrix;//定义整数常量SetConst(L"matrix",&Val);//设置整数常量InsertKey("\0\0\0\0",4,luPubKey_User,LuMessage,NULL,NULL,1,v); //使Lu运行时可输出函数信息wcout.imbue(locale("chs"));//设置输出的locale为中文 ErrCode=LuCom(ForStr,0,0,0,hFor,nPara,pPara,ErrBegin,ErrEnd); //编译表达式if(ErrCode){wcout<<L"表达式有错误!错误代码:"<<ErrCode<<endl;}else{LuCal(hFor,pPara);//计算表达式的值}LockKey(Matrix,NULL,OpMatrix);//解锁键Matrix,本例中,该函数可以不用FreeLu();//释放Lu}
习题:
(1)自定义矩阵的加、减、左除、右除、点左除等运算,自编测试字符串代码,重新编译运行程序,观察计算结果。
(2)小矩阵乘效率测试。编译运行以下Lu字符串代码:
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"}
C/C++中的字符串定义为:
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\"}";//字符串表达式
结果:
4. 5.
5. 4.
time=0.797 seconds.
请按任意键继续. . .
Matlab 2009a 代码:
a=[1.,2.;2.,1.];
b=[2.,1.;1.,2.];
c=[2/3.,-1/3.;-1/3.,2/3.];
tic,
d=a*b;
for i=1:1000000
d=d*c*b;
end
d,
toc
结果:
d =
4 5 5 4
Elapsed time is 2.903034 seconds.
本例矩阵乘效率测试,Lu的速度超过了Matlab,主要在于Lu有更高的动态对象管理效率。
与上例相比较可以知道,自定义数据类型和系统内置类型有近乎相同的效率。
11结语[返回页首]
虽然还可以添加更多的例子,但是作为一个入门教程,就先写到这儿了。
如果你对本文有什么意见或建议,请给我发E-mail:forcal@sina.com 。
版权所有© Lu程序设计 2011-2011,保留所有权利
E-mail: forcal@sina.com QQ:630715621
最近更新: 2011年10月25日
- 循序渐进Lu例程
- 循序渐进Forcal例程
- LU
- 循序渐进
- 循序渐进
- 循序渐进
- 循序渐进
- lu-PS && lu-CS
- LU算法
- LU decomposition
- lu基础
- LU Decomposition
- LU分解
- LU分解
- LU分解
- LU分解
- LU算法
- Lu decomposition
- struts-config.xml中action配置--> attribute和name的区别(转)
- 为C# Window Form程序设置热键。
- 数据库树型结构中获取目录串的高性能方法,sys_connect_by_path与自定义函数性能对比
- 79. Bad news has wings. 好事不出门,坏事传千里
- 黑马程序员之移动通信分析学习
- 循序渐进Lu例程
- 在文件每行后加上指定符号的批处理
- 黑马程序员之银行系统的学习分析
- 适易信息管理系统架构、配置实现增删改查思路及总结
- CSDN,我梦想的乐土
- 适易信息管理系统架构、配置实现增删改查中工具类介绍
- 在Servlet程序中使用Cookie
- Project Server 2007安装配置过程图解
- Cookie