tipo di una funzione in D

Question

Mi interessa la creazione di una funzione derivato che restituisce una funzione che è la derivata di una funzione che viene passata ad esso, ad un certo punto. Tuttavia, voglio essere in grado di specializzarsi questo in modo che, per funzioni specifiche, posso restituire la soluzione analitica.

Quindi, sto cercando qualcosa di simile:

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

Tuttavia, ho attualmente BSpline definito in questo modo:

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

Quindi la firma di tipo on BSpline sta per essere reale funzione (reale, Real), che non è derivabile da qualsiasi altro tipo di funzione. È il modo per risolvere questo per creare una classe "BSpline" con opCall definito? O posso fare una sorta di typedef per identificare questa funzione?

Grazie!

Answer 1

Per specializzare un modello, è necessario utilizzare la notazione ::

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

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