Curvature(t)
    // This returns the scalar curvature on the curve at time t. This is computed as
    //
    //   k(t) = ||Bézier'(t) x Bézier''(t)|| / ||Bézier'(t)||**3
    //
    // where x denotes the cross product. Even though this is a plane curve, for the
    // purposes of this method, when computing the cross product we treat the points
    // as though they are embedded on the Z-plane of an XYZ-space. That is, the X and
    // Y components can vary as needed but Z is fixed to zero.

    var
        // First derivative of Bézier(x) with respect to x, at time t.
        dx = 0
        dy = 0

        // Second derivative of Bézier(x) with respect to x, at time t.
        dx2 = 0
        dy2 = 0

        list/Data = TransformPointCache ? TransformPointCache : Points
        N = Length()

    if(N == 2)
        // If N == 2 (N < 2 is not allowed) then the Bézier curve is simply a line,
        // and thus has curvature zero.
        return 0

    if(t == 0)
        // Simplifications we can make when t == 0.

        dx = (N-1) * (Data[3] - Data[1])
        dy = (N-1) * (Data[4] - Data[2])

        // Bézier''(x) can be simplified to this.
        dx2 = (N-1)*(N-2) * (Data[5] - 2*Data[3] + Data[1])
        dy2 = (N-1)*(N-2) * (Data[6] - 2*Data[4] + Data[2])

    else if(t == 1)
        // Similar to above, but when t == 1.

        dx = (N-1) * (Data[Data.len-1] - Data[Data.len-3])
        dy = (N-1) * (Data[Data.len  ] - Data[Data.len-2])

        dx2 = (N-1)*(N-2) * (Data[Data.len-1] - 2*Data[Data.len-3] + Data[Data.len-5])
        dy2 = (N-1)*(N-2) * (Data[Data.len  ] - 2*Data[Data.len-2] + Data[Data.len-4])

    else
        // For the rest, we'll compute the first and second derivatives using the following
        // formulas, where b(n,k) = Choose(n,k) t**k * (1-t)**(n-k) and P(n) denotes the nth
        // control point.
        //
        //   Bézier'(t)  = n * Sum( b(n-1,k) * (P(k+1) - P(k)) ) from k = 0 to n-1.
        //   Bézier''(t) = n*(n-1) * Sum( b(n-2,k) * (P(k+2) - 2*P(k+1) + P(k)) ) from k = 0 to n-2.

        BinomialCache = new
        BinomialCache.len = N

        var
            dt_coefficient
            dt2_coefficient

            // Coordinates for the point P(k).
            P0_x = Data[1]
            P0_y = Data[2]

            // Coordinates for the point P(k+1).
            P1_x = Data[3]
            P1_y = Data[4]

            // Coordinates for the point P(k+2)
            P2_x = Data[5]
            P2_y = Data[6]

            q = 1
            r = (1-t)**(N-2)

        for(var/k = 0, k < (N-1), k ++)
            // Computing the sum for Bézier'(t)

            dt_coefficient = (N-1) * _Choose(N-2,k) * q*r
            dx += dt_coefficient * (P1_x - P0_x)
            dy += dt_coefficient * (P1_y - P0_y)

            // This must be done before Bézier''(t), because it has the value that
            // Bezier'(t) will have on the next iteration.
            r /= (1-t)

            if(k < (N-2))
                // And for Bézier''(t).

                dt2_coefficient = (N-1)*(N-2) * _Choose(N-3,k) * q*r
                dx2 += dt2_coefficient * (P2_x - 2*P1_x + P0_x)
                dy2 += dt2_coefficient * (P2_y - 2*P1_y + P0_y)

            // Shift P0, P1, and P2 appropriately.

            P0_x = P1_x
            P0_y = P1_y

            P1_x = P2_x
            P1_y = P2_y

            if(k < (N-3))
                P2_x = Data[2*k+7]
                P2_y = Data[2*k+8]

            // Both Bézier' and Bézier'' share the same value for q at each step, so this
            // must be done last.
            q *= t

        BinomialCache = null

    // Because A x B is perpendicular to both A and B, it's guaranteed that Bézier' x Bézier''
    // will lie entirely on the Z axis, as Bézier(t) lies entirely on the XY-plane. Thus, we
    // can simply compute the Z coordinate and take its absolute value in order to gets
    // its length.
    . = abs(dx*dy2 - dx2*dy)

    // And this is |Bézier'(t)|.
    var/denom = sqrt(dx*dx + dy*dy)
    return . / (denom*denom*denom)