type d'une fonction de D

Question

Je suis intéressé par la création d'une fonction dérivée qui retourne une fonction qui est la dérivée d'une fonction qui lui a été transmis, à un moment donné. Cependant, je veux être en mesure de se spécialiser cela pour que, pour des fonctions spécifiques, je peux retourner la solution analytique.

Alors, je cherche quelque chose comme ceci:

auto Derivate(alias Function)(x)
{ return (Function(x+h) - Function(x-h))/(2h);}

auto Derivate(BSpline!(k)(x))(x)
{ return k * BSpline!(k-1)(x) + x * BSpline!(k-1)(x); }

Cependant, j'ai actuellement BSpline défini ainsi:

pure Real BSpline(int k : 0, Real)(scope Real x, scope const(Real)[] t)
{
    if (t[0] <= x && x < t[k+1])
        return 1;
    else
        return 0;
}

pure Real BSpline(int k, Real)(scope Real x, scope const(Real)[] t)
{
    if (t[0] <= x && x < t[k+1])
    {
        Real a = (x - t[0]) / (t[k] - t[0]);
        Real b = (t[k+1] - x) / (t[k+1] - t[1]);
        Real c = BSpline!(k-1,Real)(x, t[0..k+1]);
        Real d = BSpline!(k-1,Real)(x, t[1..k+2]);
        Real rv = (c?c*a:c) + (d?d*b:d);
        return rv;
    }
    else
        return 0;
}

Ainsi, la signature de type sur BSpline va être fonction réel (Real, Real), ce qui est différenciable de tout autre type de fonction. La façon de résoudre ce pour créer une classe « BSpline » avec défini opCall? Ou puis-je faire une sorte de typedef pour identifier cette fonction?

Merci!

Answer 1

Pour se spécialiser un modèle, vous devez utiliser la notation ::

auto foo(alias F_, X_)(X_ x) {
    /* code here ... */
}

auto foo(alias F_ : BSpline, X_)(X_ x) {
    /* specialized version here */
}