tipo de función en D

Question

Estoy interesado en crear un derivado de funciones que devuelva una función que sea la derivada de alguna función que se le pase, en algún momento. Sin embargo, quiero poder especializar esto para que, para funciones específicas, pueda devolver la solución analítica.

Entonces, estoy buscando algo como esto:

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

Sin embargo, actualmente tengo Bspline definido de esta manera:

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

Entonces, la firma de tipo en BSPLINE será una función real (real, real), que no es diferenciable de ningún otro tipo de función. ¿La forma de resolver esto para crear una clase de "Bspline" con Opcall definida? ¿O puedo hacer algún tipo de typedef para identificar esta función?

¡Gracias!

Answer 1

Para especializar una plantilla, debe usar el : notación:

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

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