Les dérivés de C/C++?

J'ai mis en place de telles bibliothèques dans plusieurs langues différentes, mais malheureusement pas C. Si vous traitez uniquement avec des polynômes (sommes, produits, les variables, les constantes et les pouvoirs), il est assez facile. Fonctions trigonométriques sont aussi pas trop mal. Rien de plus compliqué et vous aurez probablement être mieux de prendre le temps de maîtriser quelqu'un d'autre bibliothèque.

Si vous décidez de rouler, j'ai quelques suggestions pour vous simplifier la vie:

• Utilisation immuable des structures de données (purement fonctionnelle des structures de données pour représenter des expressions.

• Utilisation Hans Boehm garbage collector pour gérer la mémoire pour vous.

• Pour représenter une somme linéaire, l'utilisation d'un fini de la carte (par exemple, un arbre de recherche binaire) à la carte de chaque variable à son coefficient.

Si vous êtes prêt à intégrer Lua dans votre code C et faites vos calculs, j'ai mis mon code Lua à http://www.cs.tufts.edu/~nr/drop/lua. L'une des fonctionnalités les plus agréables, c'est qu'il peut prendre une expression symbolique, de les différencier, et de compiler les résultats en Lua. Vous pourrez bien sûr trouver aucune documentation n'importe quoi 🙁

Si vous faites numérique de la différenciation ("évaluer la dérivée de f(x) à x = x0") et vous savez que vous êtes équations à l'avance (c'est à dire, pas la saisie de l'utilisateur), alors je vous recommande de FADBAD++. C'est un C++ bibliothèque de modèles pour la résolution numérique des instruments dérivés à l'aide de La différentiation automatique. C'est très rapide, et précis.

Si c'est vraiment le genre de fonction que vous souhaitez utiliser, il serait assez facile d'écrire une bibliothèque de classe. Commencez avec un seul Terme, avec un coefficient et un exposant. Ont un Polynôme qui serait constitué d'un ensemble de Termes.

Si vous définissez une interface pour les méthodes mathématiques d'intérêt (par exemple, add/sub/mul/div/différencier/intégration), vous êtes à la recherche à un GoF Composite modèle. À la fois le Terme et le Polynôme serait à implémenter cette interface. Le Polynôme serait tout simplement de faire une itération sur chaque Terme dans sa Collection.

Désolé d'avoir ce jusqu'au bout de 6 ans. Cependant, j'ai été à la recherche pour une bibliothèque de mon projet et j'ai vu @eduffy suggère FADBAD++. J'ai lu la documentation et revint à votre question. Je sens que ma réponse sera bénéfique, par conséquent, le code suivant est à votre cas.

#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;
}

La sortie est

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

Un autre exemple, disons que nous nous sommes intéressés à la dérivée première de sin(). Analytiquement, il est cos. C'est génial parce que nous avons besoin de comparer la vraie dérivée d'une fonction donnée et ses numérique de contrepartie pour calculer l'erreur vraie.

#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;
}

Le résultat est

       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
==========================

C'est le genre d'un côté car il s'applique à Lisp et pas de C/C++, mais il peut aider d'autres personnes à la recherche pour des tâches similaires ou vous pourriez obtenir quelques idées sur la mise en œuvre de quelque chose de similaire en C/C++ sur votre propre. SICP a quelques conférences sur le sujet pour lisp:

1. dérivés règles 3b
2. algébrique règles 4a

En Lisp, c'est assez simple (et dans d'autres langages fonctionnels, avec un puissant filtrage et de types polymorphes). En C, vous aurait probablement fortement d'utiliser les énumérations et les structures pour obtenir la même puissance (pour ne pas mentionner d'allocation/libération de la mémoire). On pourrait définitivement code ce dont vous avez besoin en ocaml, en moins d'une heure --je dirais que la vitesse de frappe est le facteur limitant. Si vous avez besoin de C, vous pouvez réellement appeler ocaml à partir de C (et vice versa).

Ont un coup d'oeil à Théano, il prend en charge différentiation symbolique (dans le contexte de réseaux de Neurones). Le projet est open source si donc vous devriez être en mesure de voir comment ils le font.