Art einer Funktion in d

Question

Ich bin daran interessiert, ein Funktionsivat zu erstellen, das eine Funktion zurückgibt, die irgendwann die Ableitung einer Funktion ist, die an sie übergeben wird. Ich möchte dies jedoch spezialisieren können, damit ich für bestimmte Funktionen die analytische Lösung zurückgeben kann.

Also suche ich so etwas:

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

Ich habe derzeit BSPLINE so definiert:

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

Die Typ -Signatur auf BSPLINE wird also eine echte Funktion (real, real) sein, was nicht differenzierbar von einer anderen Art von Funktion. Ist der Weg, dies zu lösen, um eine "BSPLINE" -Klasse mit opcall definiert zu erstellen? Oder kann ich eine Art Typedef machen, um diese Funktion zu identifizieren?

Vielen Dank!

Answer 1

Um eine Vorlage zu spezialisieren, müssen Sie die verwenden : Notation:

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

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