BSpline#

class skfda.representation.basis.BSpline(domain_range=None, n_basis=None, order=4, knots=None)[source]#

BSpline basis.

BSpline basis elements are defined recursively as:

\[B_{i, 1}(x) = 1 \quad \text{if } t_i \le x < t_{i+1}, \quad 0 \text{ otherwise}\]
\[B_{i, k}(x) = \frac{x - t_i}{t_{i+k} - t_i} B_{i, k-1}(x) + \frac{t_{i+k+1} - x}{t_{i+k+1} - t_{i+1}} B_{i+1, k-1}(x)\]

Where k indicates the order of the spline.

Deprecated since version 0.8: Use BSplineBasis instead.

Implementation details: In order to allow a discontinuous behaviour at the boundaries of the domain it is necessary to placing m knots at the boundaries[1]. This is automatically done so that the user only has to specify a single knot at the boundaries.

Parameters:
  • domain_range (DomainRangeLike | None) – A tuple of length 2 containing the initial and end values of the interval over which the basis can be evaluated.

  • n_basis (int | None) – Number of functions in the basis.

  • order (int) – Order of the splines. One greather than their degree.

  • knots (Sequence[float] | None) – List of knots of the spline functions.

Examples

Constructs specifying number of basis and order.

>>> bss = BSpline(n_basis=8, order=4)

If no order is specified defaults to 4 because cubic splines are the most used. So the previous example is the same as:

>>> bss = BSpline(n_basis=8)

It is also possible to create a BSpline basis specifying the knots.

>>> bss = BSpline(knots=[0, 0.2, 0.4, 0.6, 0.8, 1])

Once we create a basis we can evaluate each of its functions at a set of points.

>>> bss = BSpline(n_basis=3, order=3)
>>> bss([0, 0.5, 1])
array([[[ 1.  ],
        [ 0.25],
        [ 0.  ]],
       [[ 0.  ],
        [ 0.5 ],
        [ 0.  ]],
       [[ 0.  ],
        [ 0.25],
        [ 1.  ]]])

And evaluates first derivative

>>> deriv = bss.derivative()
>>> deriv([0, 0.5, 1])
array([[[-2.],
        [-1.],
        [ 0.]],
       [[ 2.],
        [ 0.],
        [-2.]],
       [[ 0.],
        [ 1.],
        [ 2.]]])

References

Methods

coordinate_basis_and_coefs(coefs, key)

Return a fdatabasis for the coordinate functions indexed by key.

copy([domain_range])

Basis copy.

derivative(*[, order])

Construct a FDataBasis object containing the derivative.

derivative_basis_and_coefs(coefs[, order])

Return basis and coefficients of the derivative.

evaluate(eval_points, *[, derivative])

Evaluate Basis objects and its derivatives.

gram_matrix()

Return the Gram Matrix of a basis.

inner_product_matrix([other])

Return the Inner Product Matrix of a pair of basis.

is_domain_range_fixed()

Return wether the domain range has been set explicitly.

plot(*args, **kwargs)

Plot the basis object or its derivatives.

rescale([domain_range])

Return a copy of the basis with a new domain range.

to_basis()

Convert the Basis to FDatabasis.

coordinate_basis_and_coefs(coefs, key)[source]#

Return a fdatabasis for the coordinate functions indexed by key.

Parameters:
Return type:

Tuple[Basis, ndarray[Any, dtype[float64]]]

copy(domain_range=None)[source]#

Basis copy.

Parameters:
Return type:

T

derivative(*, order=1)[source]#

Construct a FDataBasis object containing the derivative.

Parameters:

order (int) – Order of the derivative. Defaults to 1.

Returns:

Derivative object.

Return type:

FDataBasis

derivative_basis_and_coefs(coefs, order=1)[source]#

Return basis and coefficients of the derivative.

Parameters:
  • coefs (ndarray[Any, dtype[float64]]) – Coefficients of a vector expressed in this basis.

  • order (int) – Order of the derivative.

  • self (T) –

Returns:

Tuple with the basis of the derivative and its coefficients.

Return type:

Tuple[T, ndarray[Any, dtype[float64]]]

evaluate(eval_points, *, derivative=0)[source]#

Evaluate Basis objects and its derivatives.

Evaluates the basis functions at a list of given values.

Deprecated since version 0.8: Use normal calling notation instead.

Parameters:
  • eval_points (ArrayLike) – List of points where the basis is evaluated.

  • derivative (int) –

    order of the derivative.

    Deprecated since version 0.4: Use derivative method instead.

Returns:

Matrix whose rows are the values of the each basis function or its derivatives at the values specified in eval_points.

Return type:

ndarray[Any, dtype[float64]]

gram_matrix()[source]#

Return the Gram Matrix of a basis.

The Gram Matrix is defined as

\[G_{ij} = \langle\phi_i, \phi_j\rangle\]

where \(\phi_i\) is the ith element of the basis. This is a symmetric matrix and positive-semidefinite.

Returns:

Gram Matrix of the basis.

Return type:

ndarray[Any, dtype[float64]]

inner_product_matrix(other=None)[source]#

Return the Inner Product Matrix of a pair of basis.

The Inner Product Matrix is defined as

\[I_{ij} = \langle\phi_i, \theta_j\rangle\]

where \(\phi_i\) is the ith element of the basis and \(\theta_j\) is the jth element of the second basis. This matrix helps on the calculation of the inner product between objects on two basis and for the change of basis.

Parameters:

other (Basis | None) – Basis to compute the inner product matrix. If not basis is given, it computes the matrix with itself returning the Gram Matrix

Returns:

Inner Product Matrix of two basis

Return type:

ndarray[Any, dtype[float64]]

is_domain_range_fixed()[source]#

Return wether the domain range has been set explicitly.

This is useful when using a basis for converting a dataset, since if this is not explicitly assigned it can be changed to the domain of the data.

Returns:

True if the domain range has been fixed. False otherwise.

Return type:

bool

plot(*args, **kwargs)[source]#

Plot the basis object or its derivatives.

Parameters:
  • args (Any) – arguments to be passed to the fdata.plot function.

  • kwargs (Any) – keyword arguments to be passed to the fdata.plot function.

Returns:

Figure object in which the graphs are plotted.

Return type:

Figure

rescale(domain_range=None)[source]#

Return a copy of the basis with a new domain range.

Parameters:
Returns:

Rescaled copy.

Return type:

T

to_basis()[source]#

Convert the Basis to FDatabasis.

Returns:

FDataBasis with this basis as its basis, and all basis functions as observations.

Return type:

FDataBasis

Examples using skfda.representation.basis.BSpline#

Basis representation

Basis representation