当前位置：文江博客话题详情

C/C++ 的衍生物？

发布于 2024-07-12 02:55:13 字数 347 浏览 7 评论 0原文

我有一些表达式，例如 x^2+y^2，我想将其用于一些数学计算。我想做的一件事是对表达式求偏导数。

因此，如果 f(x,y) = x^2 + y^2 则 f 相对于 x 的部分将为 >2x，相对于 y 的部分将为 2y。

我使用有限差分法编写了一个很小的函数，但我遇到了很多浮点精度问题。例如，我最终得到 1.99234 而不是 2。有没有支持符号微分的库？还有其他建议吗？

原文

分享到QQ

分享到微博

如果你对这篇内容有疑问，欢迎到本站社区发帖提问参与讨论，获取更多帮助，或者扫码二维码加入 Web 技术交流群。

发布评论

需要登录才能够评论，你可以免费注册一个本站的账号。

看海 2024-07-19 02:55:14

仅计算一阶导数的实现起来非常简单。
但让它变得更快是一门艺术。
您需要一个类，其中包含

导数值
与自变量的数组，

然后您将编写用于加法和减法等的运算符以及诸如 sin() 之类的函数，它们实现了此操作的基本且众所周知的规则。

要计算高阶导数，应使用截断泰勒级数来完成。
您还可以将上述类应用到其自身 - 值和派生值的类型应该是模板参数。
但这意味着不止一次计算和存储导数。

截断的泰勒级数 - 有两个库可用于此目的：

http://code.google.com/p /libtaylor/

http://www.foelsche.com/ctaylor

回复收藏 0 原文

挽手叙旧 2024-07-19 02:55:14

看看 Theano，它支持符号微分（在神经网络的背景下）。该项目是开源的，所以您应该能够看到他们是如何做到的。

回复收藏 0 原文

墨落画卷 2024-07-19 02:55:13

我已经用几种不同的语言实现了这样的库，但不幸的是不是 C。如果您只处理多项式（和、乘积、变量、常量和幂），那么这非常简单。三角函数也不错。任何更复杂的事情，你可能最好花时间去掌握别人的库。

如果您决定自己开发，我有一些建议可以简化您的生活：

使用不可变数据结构（纯函数数据结构）来表示表达式。
使用Hans Boehm 的垃圾收集器来为您管理内存。< /p>
要表示线性和，请使用有限映射（例如二叉搜索树）将每个变量映射到其系数。
要表示

如果您愿意将 Lua 嵌入到您的 C 代码中并在那里进行计算，我已经将我的 Lua 代码放入其中在 http://www.cs.tufts.edu/~nr/drop/lua< /a>. 更好的功能之一是它可以采用符号表达式，对其进行微分，然后将结果编译到 Lua 中。您当然不会找到任何文档:-(

回复收藏 0 原文

半城柳色半声笛 2024-07-19 02:55:13

如果您正在进行数值微分（“计算 f(x) 在 x = x0 处的导数”）并且您知道自己在提前方程式（即，不是用户输入），那么我推荐 FADBAD++。它是一个 C++ 模板库，用于使用自动微分求解数值导数。它非常快，而且准确。

回复收藏 0 原文

七月上 2024-07-19 02:55:13

获得“正确”的数值微分（在最小化误差的意义上）可能相当棘手。首先，您可能需要查看数值方法上的数值食谱部分。衍生品。

对于免费的符号数学包，您应该查看 GiNaC。您还可以查看 SymPy，这是一个独立的纯 Python 符号数学包。您会发现 SymPy 更容易探索，因为您可以从 Python 命令行交互地使用它。

在商业端，Mathematica 和 Maple 都有 C API。您需要安装/许可的程序版本才能使用这些库，但是两者都可以轻松地执行您想要的符号微分类型。

回复收藏 0 原文

寂寞笑我太脆弱 2024-07-19 02:55:13

您可以通过两种简单的方法提高数值微分的准确性

使用较小的增量。您似乎使用了大约 1e-2 的值。从 1e-8 开始，并测试是否有任何较小的伤害或帮助。显然，您不能太接近机器精度 - 对于 double 约为 1e-16。
使用中心差异而不是前向（或后向）差异。
即 df_dx =(f(x+delta) - f(x-delta)) / (2.0*delta)
由于与取消较高截断项有关的原因，中心差异估计中的误差为 delta^2 量级，而不是前向差异的增量。请参阅 http://en.wikipedia.org/wiki/Finite_difference

回复收藏 0 原文

榕城若虚 2024-07-19 02:55:13

如果这确实是您想要使用的函数，那么编写一个类库就很容易了。从一个带有系数和指数的项开始。有一个由项集合组成的多项式。

如果您为感兴趣的数学方法定义了一个接口（例如，add/sub/mul/div/Differiate/integrate），您就会看到GoF Composite 模式。 Term 和 Polynomial 都会实现该接口。多项式将简单地迭代其集合中的每个项。

回复收藏 0 原文

梦情居士 2024-07-19 02:55:13

利用现有的包肯定比编写自己的包更容易，但如果您决定编写自己的包，并且准备花一些时间学习 C++ 的一些阴暗角落，则可以使用 Boost.Proto 来自 Boost 来设计您自己的库。

基本上，Boost.Proto 允许您将任何有效的 C++ 表达式（例如 x * x + y * y）转换为表达式模板 -- 基本上是使用嵌套结构的该表达式的解析树的表示 -- 然后执行任意任意操作稍后通过调用 proto::eval() 对该解析树进行计算。默认情况下，proto::eval() 用于评估树，就好像它直接运行一样，尽管您没有理由不能修改每个函数或运算符的行为以获取相反，符号导数。

尽管对于您的问题来说，这将是一个极其复杂的解决方案，但它仍然比尝试使用 C++ 模板元编程技术滚动您自己的表达式模板要容易得多。

回复收藏 0 原文

相思碎 2024-07-19 02:55:13

很抱歉六年后才提起这个问题。但是，我一直在为我的项目寻找这样的库，并且我看到 @eduffy 建议 FADBAD++ 。我已阅读文档并回到您的问题。我觉得我的回答会很有帮助，因此，以下代码适合您的情况。

#include <iostream>
#include "fadiff.h"

using namespace fadbad;

F<double> func(const F<double>& x, const F<double>& y)
{
    return x*x + y*y;
}

int main()
{
    F<double> x,y,f;     // Declare variables x,y,f
    x=1;                 // Initialize variable x
    x.diff(0,2);         // Differentiate with respect to x (index 0 of 2)
    y=1;                 // Initialize variable y
    y.diff(1,2);         // Differentiate with respect to y (index 1 of 2)
    f=func(x,y);         // Evaluate function and derivatives

    double fval=f.x();   // Value of function
    double dfdx=f.d(0);  // Value of df/dx (index 0 of 2)
    double dfdy=f.d(1);  // Value of df/dy (index 1 of 2)

    std::cout << "    f(x,y) = " << fval << std::endl;
    std::cout << "df/dx(x,y) = " << dfdx << std::endl;
    std::cout << "df/dy(x,y) = " << dfdy << std::endl;

    return 0;
}

输出是

    f(x,y) = 2
df/dx(x,y) = 2
df/dy(x,y) = 2

另一个例子，假设我们对 sin() 的一阶导数感兴趣。解析一下，就是cos。这很棒，因为我们需要比较给定函数的真实导数及其对应的数值来计算真实误差。

#include <iostream>
#include "fadiff.h"

using namespace fadbad;

F<double> func(const F<double>& x)
{
    return sin(x);
}



int main()
{
    F<double> f,x;
    double dfdx;
    x = 0.0;
    x.diff(0,1);
    f = func(x);
    dfdx=f.d(0);


    for (int i(0); i < 8; ++i ){
        std::cout << "       x: " << x.val()        << "\n"
                  << "    f(x): " << f.x()          << "\n" 
                  << " fadDfdx: " << dfdx           << "\n"
                  << "trueDfdx: " << cos(x.val())   << std::endl;
        std::cout << "=========================="   << std::endl;

        x += 0.1;
        f = func(x);
        dfdx=f.d(0);
    }


    return 0;
}

结果是

       x: 0
    f(x): 0
 fadDfdx: 1
trueDfdx: 1
==========================
       x: 0.1
    f(x): 0.0998334
 fadDfdx: 0.995004
trueDfdx: 0.995004
==========================
       x: 0.2
    f(x): 0.198669
 fadDfdx: 0.980067
trueDfdx: 0.980067
==========================
       x: 0.3
    f(x): 0.29552
 fadDfdx: 0.955336
trueDfdx: 0.955336
==========================
       x: 0.4
    f(x): 0.389418
 fadDfdx: 0.921061
trueDfdx: 0.921061
==========================
       x: 0.5
    f(x): 0.479426
 fadDfdx: 0.877583
trueDfdx: 0.877583
==========================
       x: 0.6
    f(x): 0.564642
 fadDfdx: 0.825336
trueDfdx: 0.825336
==========================
       x: 0.7
    f(x): 0.644218
 fadDfdx: 0.764842
trueDfdx: 0.764842
==========================

Sorry for bringing this up after 6 years. However, I was looking for such a library to my project and I've seen @eduffy suggests FADBAD++. I've read the documentation and came back to your question. I feel my answer will be beneficial, therefore, the following code is for your case.

#include <iostream>
#include "fadiff.h"

using namespace fadbad;

F<double> func(const F<double>& x, const F<double>& y)
{
    return x*x + y*y;
}

int main()
{
    F<double> x,y,f;     // Declare variables x,y,f
    x=1;                 // Initialize variable x
    x.diff(0,2);         // Differentiate with respect to x (index 0 of 2)
    y=1;                 // Initialize variable y
    y.diff(1,2);         // Differentiate with respect to y (index 1 of 2)
    f=func(x,y);         // Evaluate function and derivatives

    double fval=f.x();   // Value of function
    double dfdx=f.d(0);  // Value of df/dx (index 0 of 2)
    double dfdy=f.d(1);  // Value of df/dy (index 1 of 2)

    std::cout << "    f(x,y) = " << fval << std::endl;
    std::cout << "df/dx(x,y) = " << dfdx << std::endl;
    std::cout << "df/dy(x,y) = " << dfdy << std::endl;

    return 0;
}

The output is

    f(x,y) = 2
df/dx(x,y) = 2
df/dy(x,y) = 2

Another example, let's say that we are interested in the first derivative of sin(). Analytically, it is cos. This is great because we need to compare the true derivative of a given function and its numerical counterpart to compute the true error.

#include <iostream>
#include "fadiff.h"

using namespace fadbad;

F<double> func(const F<double>& x)
{
    return sin(x);
}



int main()
{
    F<double> f,x;
    double dfdx;
    x = 0.0;
    x.diff(0,1);
    f = func(x);
    dfdx=f.d(0);


    for (int i(0); i < 8; ++i ){
        std::cout << "       x: " << x.val()        << "\n"
                  << "    f(x): " << f.x()          << "\n" 
                  << " fadDfdx: " << dfdx           << "\n"
                  << "trueDfdx: " << cos(x.val())   << std::endl;
        std::cout << "=========================="   << std::endl;

        x += 0.1;
        f = func(x);
        dfdx=f.d(0);
    }


    return 0;
}

The result is

       x: 0
    f(x): 0
 fadDfdx: 1
trueDfdx: 1
==========================
       x: 0.1
    f(x): 0.0998334
 fadDfdx: 0.995004
trueDfdx: 0.995004
==========================
       x: 0.2
    f(x): 0.198669
 fadDfdx: 0.980067
trueDfdx: 0.980067
==========================
       x: 0.3
    f(x): 0.29552
 fadDfdx: 0.955336
trueDfdx: 0.955336
==========================
       x: 0.4
    f(x): 0.389418
 fadDfdx: 0.921061
trueDfdx: 0.921061
==========================
       x: 0.5
    f(x): 0.479426
 fadDfdx: 0.877583
trueDfdx: 0.877583
==========================
       x: 0.6
    f(x): 0.564642
 fadDfdx: 0.825336
trueDfdx: 0.825336
==========================
       x: 0.7
    f(x): 0.644218
 fadDfdx: 0.764842
trueDfdx: 0.764842
==========================

回复收藏 0 原文

九歌凝 2024-07-19 02:55:13

这是一种旁白，因为它适用于 Lisp 而不是 C/C++，但它可以帮助其他人寻找类似的任务，或者您可能会得到一些关于自己在 C/C++ 中实现类似的东西的想法。 SICP 有一些关于 lisp 主题的讲座：

导数规则 3b
代数规则 4a

在 Lisp 中，它非常简单（在其他具有强大模式匹配和多态类型的函数式语言中）。在 C 中，您可能必须大量利用枚举和结构才能获得相同的功能（更不用说分配/解除分配）。人们绝对可以在一小时内用 ocaml 编写出所需的代码——我想说打字速度是限制因素。如果您需要 C，您实际上可以从 C 调用 ocaml（反之亦然）。

回复收藏 0 原文

~没有更多了~