首页 > 代码库 > muParser公式库使用简介( 转)
muParser公式库使用简介( 转)
muParser是一个跨平台的公式解析库，它可以自定义多参数函数，自定义常量、变量及一元前缀、后缀操作符，二元操作符等，它将公式编译成字节码，所以计算起来非常快。
当前版本V1.28，官方网址http://sourceforge.net/projects/muparser/，这里是关于该库使用交流https://sourceforge.net/forum/forum.php?forum_id=462843
它提供两种方式使用，一种是将它编译进你的程序中，使用C＋＋类，另一种是将它编译成共享库，可以使用其它语言调用，下面主要介绍C接口方式使用该库，本文大部分例子都是muParser库中自带的，也包括本人使用过程中的一点点心得。
一、初始化公式库
#include “muParserDLL.h”
muParserHandle_t hParser;
hParser = mupCreate();//创建公式对象，并返回该对象的句柄
二、设置公式
muChar_t szLine[100];
mupSetExpr(hParser, szLine);//这里szLine一定要是以\0结尾的字符串
三、计算公式
muFloat_t fVal = 0,
fVal = mupEval(hParser);
计算公式中的数值类都是以浮点处理的，其实就是double类型，除了计算浮点数，还可以处理字符串参数
四、释放公式对象
mupRelease(hParser);
五、变量，常量操作
1.定义字符串常量
mupDefineStrConst(hParser, "strBuf", "Hallo welt");
它表示定义一个值为"Hallo welt”的字符串常量strBuf，你可以在公式引用该常量的值，如：a=strBuf, 它表示将strBuf的值赋给变量a，当然它要求a为字符串变量
2.定义数值常量
mupDefineConst(hParser, "const1", 1); //表示定义一个名为const1值为1的数值常量
注意常量只能引用它的值，不能改变它的值
3.定义数值变量
muFloat_t var;
mupDefineVar(hParser, "a", &var);
在公式中你可以随意引用或改变变量a的值，注意如果你要全局使用自定的变量a，则不能将变量var定义为局部变量，否则会引起内存地址非法访问
六.自定函数
自定义函数有以下几种原型
typedef muFloat_t (*muFun1_t)(muFloat_t);
typedef muFloat_t (*muFun2_t)(muFloat_t, muFloat_t);
typedef muFloat_t (*muFun3_t)(muFloat_t, muFloat_t, muFloat_t);
typedef muFloat_t (*muFun4_t)(muFloat_t, muFloat_t, muFloat_t, muFloat_t);
typedef muFloat_t (*muFun5_t)(muFloat_t, muFloat_t, muFloat_t, muFloat_t, muFloat_t);
typedef muFloat_t (*muMultFun_t)(const muFloat_t*, muInt_t);
typedef muFloat_t (*muStrFun1_t)(const muChar_t*);
typedef muFloat_t (*muStrFun2_t)(const muChar_t*, muFloat_t);
typedef muFloat_t (*muStrFun3_t)(const muChar_t*, muFloat_t, muFloat_t);
分为三大类，即固定数值参数的函数（1个或2个或3个或4个或5个数值参数），固定带字符串参数的函数（1个字符串参数，0个或1个或2个数值参数），可变参数函数（一个数值数组参数，一个数组大小参数），下面分别介绍
1.固定数值参数的函数
函数原型：
API_EXPORT(void) mupDefineFun1(muParserHandle_t a_hParser, const muChar_t *a_szName, muFun1_t a_pFun, muBool_t a_bOptimize);
API_EXPORT(void) mupDefineFun2(muParserHandle_t a_hParser, const muChar_t *a_szName, muFun2_t a_pFun, muBool_t a_bOptimize);
API_EXPORT(void) mupDefineFun3(muParserHandle_t a_hParser, const muChar_t *a_szName, muFun3_t a_pFun, muBool_t a_bOptimize);
API_EXPORT(void) mupDefineFun4(muParserHandle_t a_hParser, const muChar_t *a_szName, muFun4_t a_pFun, muBool_t a_bOptimize);
API_EXPORT(void) mupDefineFun5(muParserHandle_t a_hParser, const muChar_t *a_szName, muFun5_t a_pFun, muBool_t a_bOptimize);
//定义一个参数的函数，对参数平方运算
muFloat_t Power(muFloat_t a）
｛
return a*a;
｝
//定义两个参数的函数，求和
muFloat_t Add(muFloat_t a, muFloat b)
{
return a+b;
}
mupDefineFun1(hParser, “power”, Power, 0);//最后一个参数表示是否对它进行优化
mupDefineFun2(hParser, “add”, Add, 0);
公式使用方法：power(4)*add(3,4)
2.固定带字符串参数的函数
函数原型：
API_EXPORT(void) mupDefineStrFun1(muParserHandle_t a_hParser, const muChar_t *a_szName, muStrFun1_t a_pFun);
API_EXPORT(void) mupDefineStrFun2(muParserHandle_t a_hParser, const muChar_t *a_szName, muStrFun2_t a_pFun);
API_EXPORT(void) mupDefineStrFun3(muParserHandle_t a_hParser, const muChar_t *a_szName, muStrFun3_t a_pFun);
//定义一个带字符串参数的函数，将字符串表示的十六进制数转换成十进制数
muFloat_t hex(const muChar_t* str)
{
int len = strlen(str);
int ret, tmp, i;
if(len <= 0)
return 0;
for (i = 0; i < len; i++)
{
if(str[i]>= ‘0‘&& str[i]<= ‘9‘)
tmp = str[i]-‘0‘;
else if(str[i]>= ‘a‘&& str[i] <= ‘f‘)
tmp = str[i]-‘a‘+10;
else if(str[i]>=‘A‘&& str[i]<=‘F‘)
tmp = str[i]-‘A‘+10;
else
return ret;
ret = (ret<<4) | tmp;
}
return ret;
}
mupDefineStrFun1(hParser, “hex”, hex);
公式使用方法: hex(“0FA0”)，公式中的字符中参数用双引号括起来
3.可变参数函数
函数原型：
API_EXPORT(void) mupDefineMultFun( muParserHandle_t a_hParser,
const muChar_t* a_szName,
muMultFun_t a_pFun,
muBool_t a_bOptimize);
//求多个参数的和，参数个数不确定
double Sum(const double *a_afArg, int a_iArgc)
{
double fRes=0;
int i=0;
for (i=0; i<a_iArgc; ++i)
fRes += a_afArg[i];
return fRes;
}
mupDefineMultFun(hParser, “sum”, sum, 0);
公式使用：sum(1,2,3,4,5,6,7,8,9)
在公式解析的时候，会自动将所有的参数压入到一个数组中，并将该数组和参数个数传给自定义回调函数
七、定义运算操作符（这可是非常有新意的功能）
运算操作符分为前缀一元操作符，后缀一元操作符，二元操作符等
完全可以实现C中的按位运算（&, | ~ << >>)，自加减运算(++ --)，但不能与库的内置操作符冲突
//按位操作运算（注意按位运算只能运算整型，所以运算前要先转换）
double BitAnd(double a, double b)
{
return (int)a&(int)b;
}
double BitOr(double a, double b)
{
return (int)a|(int)b;
}
double BitXor(double a, double b)
{
return (int)a^(int)b;
}
double BitNot(double a)
{
return ~(int)a;
}
double Shll(double a, double b)
{
return (int)a<<(int)b;
}
double Shlr(double a, double b)
{
return (int)a>>(int)b;
}
mupDefineOprt(hParser, "&", BitAnd, 2, 0);
mupDefineOprt(hParser, "|", BitOr, 2, 0);
mupDefineOprt(hParser, "bxor", BitXor, 2, 0);
mupDefineInfixOprt(hParser, "~", BitNot, 5);
mupDefineOprt(hParser, "<<", Shll, 3, 0);
mupDefineOprt(hParser, ">>", Shlr, 3, 0);
公式使用：((a&b)>>8)bxor((a|b)<<8)
注意该库解析还有一些BUG，所以上面公式并不能正确解析，在自定义的运算符与变量之间添加空格可以暂时解决这个问题，如((a & b)>> 8)bxor((a | b)<<8)，在本文后面会介绍如何修正该BUG
八、错误处理
错误处理是很重要的，因为库是用C++写的，对错误采用异常处理方式，所以如果公式解析出错，而又没有捕捉该异常，程序就会挂掉，C接口没有捕捉异常的能力，这里可以使用安装错误处理回调函数解决这个问题，使用方法如下：
void one rror(muParserHandle_t hParser)
{
printf("\nError:\n");
printf("------\n");
printf("Message: %s\n", mupGetErrorMsg(hParser));
printf("Token: %s\n", mupGetErrorToken(hParser));
}
mupSetErrorHandler(hParser, one rror);
九、显示公式对象的已定义变量，常量，表达式
这些功能使用非常简单，首先取得变量或常量或表达式的个数，然后根据对应的索引位置取出它们的值，我就不多说了，附上相关的API声明
API_EXPORT(int) mupGetExprVarNum(muParserHandle_t a_hParser);
API_EXPORT(int) mupGetVarNum(muParserHandle_t a_hParser);
API_EXPORT(int) mupGetConstNum(muParserHandle_t a_hParser);
API_EXPORT(void) mupGetExprVar(muParserHandle_t a_hParser, unsigned a_iVar, const muChar_t** a_pszName, muFloat_t** a_pVar);
API_EXPORT(void) mupGetVar(muParserHandle_t a_hParser, unsigned a_iVar, const muChar_t** a_pszName, muFloat_t** a_pVar);
API_EXPORT(void) mupGetConst(muParserHandle_t a_hParser, unsigned a_iVar, const muChar_t** a_pszName, muFloat_t* a_pVar);
十、变量工厂
也就是在解析到一个未定义的标识符时，根据用户注册的回调函数规则自动创建以该标识符命名的变量，如下示例：
muFloat_t* AddVariable(const muChar_t* a_szName, void* pUserData)
{
static double afValBuf[PARSER_MAXVARS];//定义变量缓冲区
static int iVal = 0;
printf("Generating new variable \"%s\" (slots left: %d)\n", a_szName, PARSER_MAXVARS-iVal);
afValBuf[iVal] = 0;
if (iVal>=PARSER_MAXVARS-1)
{
printf("Variable buffer overflow.");
return NULL;
}
return &afValBuf[iVal++]; //返回存储该变量值的地址
}
mupSetVarFactory(hParser, AddVariable, NULL);
十一、关于BUG
1.解析操作符的问题，如果你定义了“＆”操作符， 那么公式 a&b不会工作，它首先解析出变量a，然后解析”&b”, 发现”&b”即不是操作符，也不是常量，变量，或函数，最后就抛出异常，问题出在muParserTokenReader.cpp文件中的ExtractToken函数的算法上，
int ParserTokenReader::ExtractToken( const char_type *a_szCharSet,
string_type &a_sTok, int a_iPos ) const
{
int iEnd = (int)m_strFormula.find_first_not_of(a_szCharSet, a_iPos);
if (iEnd==(int)string_type::npos)
iEnd = (int)m_strFormula.length();
a_sTok = string_type( m_strFormula.begin()+a_iPos, m_strFormula.begin()+iEnd);
a_iPos = iEnd;
return iEnd;
}
它采用find_first_not_of来搜索给定字符串与指定集合不匹配的第一个元素位置，因为操作符命名可以包含算术运算符，英文字母 ，所以会认为&b也是一个合法的操作符名，但要修正不能修改该函数，因为变量，函数等解析都会调用该函数，我们要修正的只是操作符解析算法，即IsOprt函数
以下是我的解决方法：
bool ParserTokenReader::IsOprt(token_type &a_Tok)
{
string_type strTok;
int iEnd = (int)m_strFormula.find_first_not_of(m_pParser->ValidOprtChars(), m_iPos);
if(iEnd == string_type::npos)
iEnd = m_strFormula.length();
while(iEnd>m_iPos)
{
strTok = string_type(m_strFormula.begin()+m_iPos, m_strFormula.begin()+iEnd);
funmap_type::const_iterator item = m_pOprtDef->find(strTok);
if(item!=m_pOprtDef->end())
break;
iEnd--;
}
//int iEnd = ExtractToken(m_pParser->ValidOprtChars(), strTok, m_iPos);
if (iEnd==m_iPos)
return false;
funmap_type::const_iterator item = m_pOprtDef->find(strTok);
if (item==m_pOprtDef->end())
return false;
a_Tok.Set(item->second, strTok);
if (m_iSynFlags & noOPT)
{
// An operator was found but is not expected to occur at
// this position of the formula, maybe it is an infix
// operator, not a binary operator. Both operator types
// can share characters in their identifiers.
if ( IsInfixOpTok(a_Tok) ) return true;
// nope, no infix operator
Error(ecUNEXPECTED_OPERATOR, m_iPos, a_Tok.GetAsString());
}
m_iPos = (int)iEnd;
m_iSynFlags = noBC | noOPT | noCOMMA | noPOSTOP | noEND | noBC | noASSIGN;
return true;
}
思路是首先读出最长合法操作符名，然后判断是否被定义了，如果没有则再读取次长操作符名判断是否被定义，依次类推，直到字符串为空，如果找到操作符名被定义了，则立即返回，当然此法也可能引起其它的问题。
2.也是关于操作符解析问题，如果你定义了一个名为or的二元操作符，同时还定义了一个名为order的函数，那么解析时会将order解析为or加上未定义的der，不过这个问题在下一个版本中已经修正了。解决方法如下:
将函数ReadNextToken中的如下语句交换即可
if ( IsOprt(tok) ) return SaveBeforeReturn(tok);
if ( IsBuiltIn(tok) ) return SaveBeforeReturn(tok);
//To:
if ( IsBuiltIn(tok) ) return SaveBeforeReturn(tok);
if ( IsOprt(tok) ) return SaveBeforeReturn(tok);
3.在错误处理时应该注意，不能同时调用以下函数，否则程序一定挂掉
API_EXPORT(const muChar_t*) mupGetErrorMsg(muParserHandle_t a_hParser);
API_EXPORT(muInt_t) mupGetErrorCode(muParserHandle_t a_hParser);
API_EXPORT(muInt_t) mupGetErrorPos(muParserHandle_t a_hParser);
API_EXPORT(const muChar_t*) mupGetErrorToken(muParserHandle_t a_hParser);
API_EXPORT(const muChar_t*) mupGetErrorExpr(muParserHandle_t a_hParser);
原因很简单，当解析出错时，一定有错误消息和错误标识符，但不一定有错误码、出错位置、出错表达式（表达式可能为空），这应该是对应C接口上的设计缺陷。
转自：http://blog.chinaunix.net/uid-20619801-id-1612046.html
另外
数学表达式解析器 Expression4J
Expression4J是一个基于Java的开源框架，它用于对数学表达式进行操作，是一个数学公式解析器，在Expression4J中可以将数学表达式存储在字符串对象中，如“f(x,b)=2*x-cos(b)”和“g(x,y)=f(y,x)*-2”等。Expression4J是高度定制的，用户可以自定义文法，其主要功能包括实数和复数的基本数学运算，支持基本数学函数（如sin、cos等函数）、复杂函数（如f(x)=2*x+5、g(x)=3*f(x+2)-x等）以及用户使用Java语言自定义的函数和文法，还可以定义函数目录（函数集）、支持XML配置文件等。目前它还不是一个十分成熟的框架，仍在不断完善中。
项目主页：http://www.open-open.com/lib/view/home/1341366018031