使用 Lua 评估数学表达式

Question

在我的上一个问题中，我正在寻找一种在 C 中评估复杂数学表达式的方法，大多数建议需要实现某种类型的解析器。

然而一个答案，建议使用Lua来评估表达式。 我对这种方法很感兴趣，但我对Lua一无所知。

有 Lua 经验的人可以透露一些信息吗？

具体来说我想知道的是 Lua 提供哪个 API 可以计算作为字符串传入的数学表达式？如果没有 API 可以完成这样的事情，可能有人可以解释链接的答案，因为它似乎是一个很好的方法:)

谢谢

我想要评估的表达式类型给出了一些用户输入，例如

y = x^2 + 1/x - cos(x)

评估 y 的 x 值范围

Answer 1

设置 Lua 解释器实例并向其传递要计算的表达式，然后返回一个要调用的计算表达式的函数非常简单。 您甚至可以让用户拥有变量...

这是我编写并编辑到我的其他答案中的示例代码。 无论如何，它可能最好放在标记为 Lua 的问题上，所以我也将其添加到此处。 我编译了这个并尝试了一些情况，但如果不注意错误处理等，它肯定不应该在生产代码中被信任。 所有常见的注意事项都适用于此。

我使用 Lua for Windows 中的 Lua 5.1.4 在 Windows 上编译并测试了它。 在其他平台上，您必须从常用来源或 www.lua.org 中找到 Lua。

更新：此示例使用简单直接的技术将 Lua API 的全部功能和复杂性隐藏在尽可能简单的界面后面。 它可能按原样有用，但可以通过多种方式进行改进。

我鼓励读者研究更多可用于生产的 ae 库，由 lhf 编写，用于利用 API 来避免一些快速而肮脏的字符串操作的代码用过。 他的库还将数学库提升到全局名称空间，以便用户可以说 sin(x) 或 2 * pi 而不必说 math.sin 等等。

LE 的公共接口

这是文件 le.h：

/* Public API for the LE library.
 */
int le_init();
int le_loadexpr(char *expr, char **pmsg);
double le_eval(int cookie, char **pmsg);
void le_unref(int cookie);
void le_setvar(char *name, double value);
double le_getvar(char *name);

使用 LE 的示例代码

这是文件 t-le.c，演示了该库的简单使用。 它采用单个命令行参数，将其作为表达式加载，并使用全局变量 x 在 11 个步骤中从 0.0 变为 1.0 对其进行求值：

#include <stdio.h>
#include "le.h"

int main(int argc, char **argv)
{
    int cookie;
    int i;
    char *msg = NULL;

    if (!le_init()) {
    printf("can't init LE\n");
    return 1;
    }
    if (argc<2) {
    printf("Usage: t-le \"expression\"\n");
    return 1;
    }
    cookie = le_loadexpr(argv[1], &msg);
    if (msg) {
    printf("can't load: %s\n", msg);
    free(msg);
    return 1;
    }
    printf("  x    %s\n"
       "------ --------\n", argv[1]);
    for (i=0; i<11; ++i) {
    double x = i/10.;
    double y;

    le_setvar("x",x);
    y = le_eval(cookie, &msg);
    if (msg) {
        printf("can't eval: %s\n", msg);
        free(msg);
        return 1;
    }
    printf("%6.2f %.3f\n", x,y);
    }
}

这是 t-le 的一些输出：

E:...>t-le "math.sin(math.pi * x)"
  x    math.sin(math.pi * x)
------ --------
  0.00 0.000
  0.10 0.309
  0.20 0.588
  0.30 0.809
  0.40 0.951
  0.50 1.000
  0.60 0.951
  0.70 0.809
  0.80 0.588
  0.90 0.309
  1.00 0.000

E:...>

LE 的实现

这里是 le .c，实现 Lua 表达式求值器：

#include <lua.h>
#include <lauxlib.h>

#include <stdlib.h>
#include <string.h>

static lua_State *L = NULL;

/* Initialize the LE library by creating a Lua state.
 *
 * The new Lua interpreter state has the "usual" standard libraries
 * open.
 */
int le_init()
{
    L = luaL_newstate();
    if (L) 
    luaL_openlibs(L);
    return !!L;
}

/* Load an expression, returning a cookie that can be used later to
 * select this expression for evaluation by le_eval(). Note that
 * le_unref() must eventually be called to free the expression.
 *
 * The cookie is a lua_ref() reference to a function that evaluates the
 * expression when called. Any variables in the expression are assumed
 * to refer to the global environment, which is _G in the interpreter.
 * A refinement might be to isolate the function envioronment from the
 * globals.
 *
 * The implementation rewrites the expr as "return "..expr so that the
 * anonymous function actually produced by lua_load() looks like:
 *
 *     function() return expr end
 *
 *
 * If there is an error and the pmsg parameter is non-NULL, the char *
 * it points to is filled with an error message. The message is
 * allocated by strdup() so the caller is responsible for freeing the
 * storage.
 * 
 * Returns a valid cookie or the constant LUA_NOREF (-2).
 */
int le_loadexpr(char *expr, char **pmsg)
{
    int err;
    char *buf;

    if (!L) {
    if (pmsg)
        *pmsg = strdup("LE library not initialized");
    return LUA_NOREF;
    }
    buf = malloc(strlen(expr)+8);
    if (!buf) {
    if (pmsg)
        *pmsg = strdup("Insufficient memory");
    return LUA_NOREF;
    }
    strcpy(buf, "return ");
    strcat(buf, expr);
    err = luaL_loadstring(L,buf);
    free(buf);
    if (err) {
    if (pmsg)
        *pmsg = strdup(lua_tostring(L,-1));
    lua_pop(L,1);
    return LUA_NOREF;
    }
    if (pmsg)
    *pmsg = NULL;
    return luaL_ref(L, LUA_REGISTRYINDEX);
}

/* Evaluate the loaded expression.
 * 
 * If there is an error and the pmsg parameter is non-NULL, the char *
 * it points to is filled with an error message. The message is
 * allocated by strdup() so the caller is responsible for freeing the
 * storage.
 * 
 * Returns the result or 0 on error.
 */
double le_eval(int cookie, char **pmsg)
{
    int err;
    double ret;

    if (!L) {
    if (pmsg)
        *pmsg = strdup("LE library not initialized");
    return 0;
    }
    lua_rawgeti(L, LUA_REGISTRYINDEX, cookie);
    err = lua_pcall(L,0,1,0);
    if (err) {
    if (pmsg)
        *pmsg = strdup(lua_tostring(L,-1));
    lua_pop(L,1);
    return 0;
    }
    if (pmsg)
    *pmsg = NULL;
    ret = (double)lua_tonumber(L,-1);
    lua_pop(L,1);
    return ret;
}


/* Free the loaded expression.
 */
void le_unref(int cookie)
{
    if (!L)
    return;
    luaL_unref(L, LUA_REGISTRYINDEX, cookie);    
}

/* Set a variable for use in an expression.
 */
void le_setvar(char *name, double value)
{
    if (!L)
    return;
    lua_pushnumber(L,value);
    lua_setglobal(L,name);
}

/* Retrieve the current value of a variable.
 */
double le_getvar(char *name)
{
    double ret;

    if (!L)
    return 0;
    lua_getglobal(L,name);
    ret = (double)lua_tonumber(L,-1);
    lua_pop(L,1);
    return ret;
}

备注

上面的示例总共由 189 行代码组成，包括少量的注释、空行和演示。 对于一个知道如何计算一个变量的合理任意表达式的快速函数求值器来说还不错，并且具有 丰富的标准数学函数库随叫随到。

您在这一切的基础上拥有图灵完备的语言，并且它将是一个简单的扩展，允许用户定义完整的函数以及评估简单的表达式。

Answer 2

由于您很懒，像大多数程序员一样，这里有一个简单示例的链接，您可以使用它来解析一些 Lua 的任意代码。 从这里开始，创建表达式解析器应该很简单。

Answer 3

这适用于正在寻找“eval”的 Lua 等价物的 Lua 用户。

曾经的神奇词是 loadstring，但现在，从 Lua 5.2 开始，它是 load 的升级版本。

 i=0
 f = load("i = i + 1") -- f is a function
 f() ; print(i) -- will produce 1
 f() ; print(i) -- will produce 2

另一个例子，传递一个值：

f=load('return 2+3')
print(f()) -- print 5

作为一种快速而肮脏的方法，您可以考虑以下等效的 eval(s)，其中 s 是要评估的字符串：

load(s)()

一如既往，应尽可能避免 eval 机制，因为它们价格昂贵并且生成的代码难以阅读。
我个人将这种机制与 LuaTex/LuaLatex 结合使用，在 Latex 中进行数学运算。

Answer 4

Lua 文档包含标题为应用程序编程接口的部分，其中描述了如何从你的 C 程序中调用 Lua。 Lua 的文档非常好，您甚至可以在那里找到您想要执行的操作的示例。

这是一个很大的世界，所以无论你选择自己的解析解决方案还是像 Lua 这样的嵌入式解释器，你都需要做一些工作！

Answer 5

function calc(operation)
    return load("return " .. operation)()
end