c++ - C++ の式テンプレートを使用した記号微分

Question

C++ で式テンプレートを使用して記号微分を実装する方法

Answer 1

一般に、シンボル (つまり、 eg をエンコードする式テンプレート3 * x * x + 42) を表現する方法と、導関数を計算できるメタ関数が必要です。C++ でのメタプログラミングに十分な知識があり、それが何を意味し、何を伴うのかを理解していただければ幸いです。

// This should come from the expression templates
template<typename Lhs, typename Rhs>
struct plus_node;

// Metafunction that computes a derivative
template<typename T>
struct derivative;

// derivative<foo>::type is the result of computing the derivative of foo

// Derivative of lhs + rhs
template<typename Lhs, typename Rhs>
struct derivative<plus_node<Lhs, Rhs> > {
    typedef plus_node<
        typename derivative<Lhs>::type
        , typename derivative<Rhs>::type
    > type;
};

// and so on

次に、使いやすいように 2 つの部分 (表現と計算) を結び付けます。たとえば、「 in xderivative(3 * x * x + 42)(6)の導関数を 6 で計算する」という意味になります。3 * x * x + 42

ただし、式テンプレートを作成するのに何が必要か、C++ でメタプログラムを作成するのに何が必要かを知っていたとしても、この方法で進めることはお勧めしません。テンプレートのメタプログラミングには多くのボイラープレートが必要で、退屈な場合があります。代わりに、天才的な Boost.Protoライブラリを紹介します。これは、(式テンプレートを使用して) EDSL を記述し、それらの式テンプレートを操作するのに役立つように正確に設計されています。使い方を学ぶのは必ずしも簡単ではありませんが、それを使わずに同じことを達成する方法を学ぶのは難しいことがわかりました。実際に を理解して計算できるサンプル プログラムを次に示しますderivative(3 * x * x + 42)(6)。

#include <iostream>

#include <boost/proto/proto.hpp>

using namespace boost::proto;

// Assuming derivative of one variable, the 'unknown'
struct unknown {};

// Boost.Proto calls this the expression wrapper
// elements of the EDSL will have this type
template<typename Expr>
struct expression;

// Boost.Proto calls this the domain
struct derived_domain
: domain<generator<expression>> {};

// We will use a context to evaluate expression templates
struct evaluation_context: callable_context<evaluation_context const> {
    double value;

    explicit evaluation_context(double value)
        : value(value)
    {}

    typedef double result_type;

    double operator()(tag::terminal, unknown) const
    { return value; }
};
// And now we can do:
// evalutation_context context(42);
// eval(expr, context);
// to evaluate an expression as though the unknown had value 42

template<typename Expr>
struct expression: extends<Expr, expression<Expr>, derived_domain> {
    typedef extends<Expr, expression<Expr>, derived_domain> base_type;

    expression(Expr const& expr = Expr())
        : base_type(expr)
    {}

    typedef double result_type;

    // We spare ourselves the need to write eval(expr, context)
    // Instead, expr(42) is available
    double operator()(double d) const
    {
        evaluation_context context(d);
        return eval(*this, context);
    }
};

// Boost.Proto calls this a transform -- we use this to operate
// on the expression templates
struct Derivative
: or_<
    when<
        terminal<unknown>
        , boost::mpl::int_<1>()
    >
    , when<
        terminal<_>
        , boost::mpl::int_<0>()
    >
    , when<
        plus<Derivative, Derivative>
        , _make_plus(Derivative(_left), Derivative(_right))
    >
    , when<
        multiplies<Derivative, Derivative>
        , _make_plus(
            _make_multiplies(Derivative(_left), _right)
            , _make_multiplies(_left, Derivative(_right))
        )
    >
    , otherwise<_>
> {};

// x is the unknown
expression<terminal<unknown>::type> const x;

// A transform works as a functor
Derivative const derivative;

int
main()
{
    double d = derivative(3 * x * x + 3)(6);
    std::cout << d << '\n';
}