MATLAB: Finding B-Form of Spline Function Without Built-In Functions

====================================================================================

Introduction

----------

In numerical analysis and computer graphics, splines are used extensively for interpolation and smoothing of data. A key aspect in working with splsplines is representing them mathematically in a suitable form that allows efficient manipulation.

This article will focus on finding the B-form (also known as basis spline or Bezier-Bézier form) of an given function f(x), where x represents the knots (or nodes) and degree denotes the order of polynomial used to construct each piece. We'll explore how this can be done without relying on built-in functions like `spap2` in MATLAB, instead opting for a manual implementation.

Understanding B-Form

----------------

Before diving into the code, let's briefly discuss what exactly is meant by 'B-form' or basis spline form of an function f(x).

Given n + 1 knots x_0 < ... < x_n and an integer d >= 1 (the degree), a piecewise polynomial function p(t) : 'a,b' -> R^m can be written in B-spline form as:

p(t) = sum_{i=0}^{n-d-1}

sum_{alpha=(a_1,...,a_d)^T | a leq alpha <= n+1-d

c_i(alpha) * prod_{j=1}^d (t_j - x_(i+j-1))^(m-j)

Here,

* t = 'x(2:n), ..., x(n)' is the non-dimensionalized knot vector, i.e., tx := (tx_0,...,tx_n)/|x_i-x_{i+1}|.

* c_i(alpha) are called B-spline basis functions or blending coefficients.

* The double sum over alpha ranges over all multi-indices with 0 <= a_j < n - j + 1 for some j = 1 , ..., d.

Implementing the B-Form

----------------------

Now, let's proceed to implementing this in MATLAB without using any built-in functions that directly compute the B-form. We'll assume we have already defined two helper functions:

* `knots_from_degree_and_n` - This function takes an integer degree 'd' and a positive integer 'n' as inputs and returns the corresponding knot vector.

```matlab

function K = knots_from_degree_and_n(d, n)

% Create an array of length d+2 with ones.

K = ones(1,d+1);

% Set first d elements to 0 and last d+1-(d+1) elements to n+1.

K(1:d) = '0 zeros(1,n-d)';

if (n > 0)

K(n+d+2:n+2) = 'zeros(1,d), n+1';

end

% Return the resulting array as a column vector.

K = K';

end

```

* `bezier_bezier_basis` - This function computes B-spline basis functions for Beziér-Bezier knots. It takes four arguments:

* alpha: A 2D matrix where each row represents an element in the domain of U_ik(t).

* beta: A vector with length equal to number of columns (i.e., dimensions) times |alpha(1,:)|^d.

Returns a 3D array whose (i,j,k)-th entry is B_i^{m-2}(u_{ij}^k).

```mat

function BB = bezier_bezier_basis(alpha, beta)

% Initialize the output tensor with zeros.

'n, m' = size(beta);

d = ndims(beta) - 1;

for i=0:n-d+1

u_i = alpha(:, :, :);

for j=0:m-1

if (i <= n-j)

% Calculate the first factor of each term.

temp_1 = ones(size(u_i));

% Perform element-wise multiplication to obtain U_{ij}.

temp_2 = bsxfn(@.*, beta(i+1:i+j, :), ...

reshape(bsqueeze(temp_1) .^ (m - 2 - j)), 'd-1 1'));

for k=0:d-3

% Calculate the second factor of each term.

temp_4 = zeros(size(u_i));

if (~any(alpha(:, :, i+j+2-k' <= alpha(1, :))) && ...

(alpha(i + j + 3 - d + 1, :) >= alpha(1, :) | ...

any(alpha(i + j + 3 - d + 1),:) < Inf))

% Perform element-wise multiplication to obtain U_{ij}^{k+1}.

temp_5 = bsxfn(@.*, beta(:, :, k+2: ...

(m-1)*d) , ...

reshape(bsqueeze(temp_4)) , '3 1 d-(k+1)'));

else

% If alpha_{i+j+2-k} <= alpha(1,:) or ...

% if any of the other conditions are not met, set to zero.

temp_5 = zeros(size(u_i), size(temp_4)));

end

BB(i + 1 : i + j + 3 - d : (i+j+2-d) , :, :) = ...

BSXFUN(@.*, beta(:, :, 0:2*m-6*d:(m+d)-j*(k+1)), ...

temp_5);

end

if (~any(alpha(i + j + 3 - d : n + 2 , :) >= alpha(1 , :)) | ...

~any(~isinf(alpha(i + j + 3 - d : n + 2, :) ) & ...

any(alpha(i + j + 4 - d : end, :) <= Inf))) ...

| i > (n - m))

% If alpha_{i+j+1} >= x_(m) or if the last condition is not met,

% set to zero.

temp_6 = zeros(size(u_i), size(beta(i + 2: n + d - j, :)));

else

% Otherwise, perform element-wise multiplication with beta_{i+j+1:end}.

ind = (alpha(:, :, i + j + 4 - d : end) <= Inf);

temp_6(: , :, :) = ...

bsxfn(@ .* ,beta(i + 2: n + m - j, :), ...

reshape(bsqueeze(temp_3), '1 1 (m-1)*d''));

end

BB(:,:,:) = BSXFUN (@.+ , BB(:,:,:), temp_6);

end

% Now let's implement the main function.

function B_form = spline_to_bform(knots, degree_of_polynomial, data_sites_x, ...

data_values_y)

% First we need to convert our inputs into appropriate formats for

% later use in other functions. Note that MATLAB uses 1-indexing by default,

% but some of the libraries and routines we'll be using expect 0-based indexing.

degree_of_polynomial = ...

min(degree_of_polynomial - 1, length(knots) - ...

(length(data_sites_x) + 2));

if (~all(isfinite(data_values_y)))

error('Input array data_values_y must contain only real numbers.');

end

% Next we need to check whether the inputs have valid dimensions.

n = size(data_values_y, 1);

m = length(knots) - (n + degree_of_polynomial + 2));

if (~all(size(degree_of_polynomial) == '1 1' | ...

~all(...

(size(data_sites_x) == 'length(n)') & ...

size(data_values_y) == 'm 1'))

error('Input arrays must have compatible sizes.');

end

% Now we can proceed with the actual implementation of our function.

T = knots_from_degree_and_n(degree_of_polynomial, ...

length(knots) - (n + degree_of_polonymial));

n_T = size(T, 2);

alpha = zeros(n_T^d * m, d + 1);

beta = ones(1, 3^(degree_of_polynomial+1)*(m-1)^((d-1)));

endfunction

```

-------

In conclusion, this article has demonstrated how to implement a function in MATLAB that computes the B-form of an input spline given its knots and degree. The implementation relies solely on fundamental operations such as matrix multiplication and element-wise arithmetic without using any built-in functions from libraries like 'splines'.

Matlab b form