Enum DuchonNullspaceOrder 

pub enum DuchonNullspaceOrder {
    Zero,
    Linear,
    Degree(usize),
}

Duchon null-space polynomial degree.

Controls the polynomial null space of the Duchon / polyharmonic spline. The Duchon seminorm ‖D^m f‖² annihilates all polynomials of total degree < m, so those polynomials must be handled as explicit unpenalized columns.

The user-facing order knob selects the polynomial degree cutoff r, and the resulting polynomial null space has dimension C(d + r, r) where d is the covariate dimension. In the duchon(...) formula DSL:

order=	Variant	max total degree	null-space dim
0	Zero	0	C(d+0,0) = 1
1	Linear	1	C(d+1,1) = d+1
k≥2	Degree(k)	k	C(d+k,k)

How the polynomial null space is consumed during basis construction:

1. polynomial_block_from_order materialises an (n, C(d+r,r)) block P of monomials up to total degree r at the selected centers.
2. kernel_constraint_nullspace computes Z = null(P_centers^T), a (k, k − C(d+r,r)) matrix. Reparameterising the radial kernel coefficients as α = Z γ enforces the side condition P_centers^T α = 0 and yields k − C(d+r,r) free kernel parameters.
3. The polynomial block P_data evaluated at the data rows is appended to the kernel block Φ Z, giving a total of (k − C(d+r,r)) + C(d+r,r) = k columns before the spatial identifiability transform. Crucially, the total width equals the requested center count k, not k + C(d+r,r).

Example — duchon(PC1, PC2, PC3, centers=10, order=1) (d=3):

• Polynomial null space: C(3+1,1) = 4 monomials {1, x₁, x₂, x₃}.
• Kernel columns after constraint: 10 − 4 = 6.
• Appended polynomial block: 4 columns.
• Pre-identifiability total: 6 + 4 = 10 columns, i.e. exactly centers.

The variant naming matches the Duchon m parameter: Zero → m=1, Linear → m=2, Degree(k) → m=k+1.

Variants

Zero

Linear

Degree(usize)

Trait Implementations

impl Clone for DuchonNullspaceOrder

fn clone(&self) -> DuchonNullspaceOrder

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Copy for DuchonNullspaceOrder

impl Debug for DuchonNullspaceOrder

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for DuchonNullspaceOrder

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Eq for DuchonNullspaceOrder

impl Hash for DuchonNullspaceOrder

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq for DuchonNullspaceOrder

fn eq(&self, other: &DuchonNullspaceOrder) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Serialize for DuchonNullspaceOrder

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for DuchonNullspaceOrder