diff -r 53136eba9abf -r 6b0db7251ebe src/forward_model/sensor_grid.rs --- a/src/forward_model/sensor_grid.rs Fri Feb 14 23:16:14 2025 -0500 +++ b/src/forward_model/sensor_grid.rs Fri Feb 14 23:46:43 2025 -0500 @@ -2,124 +2,120 @@ Sensor grid forward model */ +use nalgebra::base::{DMatrix, DVector}; use numeric_literals::replace_float_literals; -use nalgebra::base::{ - DMatrix, - DVector -}; use std::iter::Zip; use std::ops::RangeFrom; +use alg_tools::bisection_tree::*; +use alg_tools::error::DynError; +use alg_tools::instance::Instance; +use alg_tools::iter::{MapX, Mappable}; +use alg_tools::lingrid::*; pub use alg_tools::linops::*; -use alg_tools::norms::{ - L1, Linfinity, L2, Norm -}; -use alg_tools::bisection_tree::*; -use alg_tools::mapping::{ - RealMapping, - DifferentiableMapping -}; -use alg_tools::lingrid::*; -use alg_tools::iter::{MapX, Mappable}; +use alg_tools::mapping::{DifferentiableMapping, RealMapping}; +use alg_tools::maputil::map2; use alg_tools::nalgebra_support::ToNalgebraRealField; +use alg_tools::norms::{Linfinity, Norm, L1, L2}; use alg_tools::tabledump::write_csv; -use alg_tools::error::DynError; -use alg_tools::maputil::map2; -use alg_tools::instance::Instance; -use crate::types::*; +use super::{AdjointProductBoundedBy, BoundedCurvature, ForwardModel}; +use crate::frank_wolfe::FindimQuadraticModel; +use crate::kernels::{AutoConvolution, BoundedBy, Convolution}; use crate::measures::{DiscreteMeasure, Radon}; -use crate::seminorms::{ - ConvolutionOp, - SimpleConvolutionKernel, -}; -use crate::kernels::{ - Convolution, - AutoConvolution, - BoundedBy, -}; use crate::preadjoint_helper::PreadjointHelper; -use super::{ - ForwardModel, - BoundedCurvature, - AdjointProductBoundedBy -}; -use crate::frank_wolfe::FindimQuadraticModel; +use crate::seminorms::{ConvolutionOp, SimpleConvolutionKernel}; +use crate::types::*; -type RNDM = DiscreteMeasure, F>; +type RNDM = DiscreteMeasure, F>; -pub type ShiftedSensor = Shift, F, N>; +pub type ShiftedSensor = Shift, F, N>; /// Trait for physical convolution models. Has blanket implementation for all cases. -pub trait Spread -: 'static + Clone + Support + RealMapping + Bounded {} +pub trait Spread: + 'static + Clone + Support + RealMapping + Bounded +{ +} -impl Spread for T -where F : Float, - T : 'static + Clone + Support + Bounded + RealMapping {} +impl Spread for T +where + F: Float, + T: 'static + Clone + Support + Bounded + RealMapping, +{ +} /// Trait for compactly supported sensors. Has blanket implementation for all cases. -pub trait Sensor : Spread + Norm + Norm {} +pub trait Sensor: + Spread + Norm + Norm +{ +} -impl Sensor for T -where F : Float, - T : Spread + Norm + Norm {} - +impl Sensor for T +where + F: Float, + T: Spread + Norm + Norm, +{ +} -pub trait SensorGridBT : -Clone + BTImpl> -where F : Float, - S : Sensor, - P : Spread {} +pub trait SensorGridBT: + Clone + BTImpl> +where + F: Float, + S: Sensor, + P: Spread, +{ +} -impl -SensorGridBT -for T -where T : Clone + BTImpl>, - F : Float, - S : Sensor, - P : Spread {} +impl SensorGridBT for T +where + T: Clone + BTImpl>, + F: Float, + S: Sensor, + P: Spread, +{ +} // We need type alias bounds to access associated types #[allow(type_alias_bounds)] -pub type SensorGridBTFN, const N : usize> -= BTFN, BT, N>; +pub type SensorGridBTFN, const N: usize> = + BTFN, BT, N>; /// Sensor grid forward model #[derive(Clone)] -pub struct SensorGrid -where F : Float, - S : Sensor, - P : Spread, - Convolution : Spread, - BT : SensorGridBT, +pub struct SensorGrid +where + F: Float, + S: Sensor, + P: Spread, + Convolution: Spread, + BT: SensorGridBT, { - domain : Cube, - sensor_count : [usize; N], - sensor : S, - spread : P, - base_sensor : Convolution, - bt : BT, + domain: Cube, + sensor_count: [usize; N], + sensor: S, + spread: P, + base_sensor: Convolution, + bt: BT, } -impl SensorGrid -where F : Float, - BT : SensorGridBT, - S : Sensor, - P : Spread, - Convolution : Spread + LocalAnalysis, +impl SensorGrid +where + F: Float, + BT: SensorGridBT, + S: Sensor, + P: Spread, + Convolution: Spread + LocalAnalysis, { - /// Create a new sensor grid. /// /// The parameter `depth` indicates the search depth of the created [`BT`]s /// for the adjoint values. pub fn new( - domain : Cube, - sensor_count : [usize; N], - sensor : S, - spread : P, - depth : BT::Depth + domain: Cube, + sensor_count: [usize; N], + sensor: S, + spread: P, + depth: BT::Depth, ) -> Self { let base_sensor = Convolution(sensor.clone(), spread.clone()); let bt = BT::new(domain, depth); @@ -141,15 +137,14 @@ } } - -impl SensorGrid -where F : Float, - BT : SensorGridBT, - S : Sensor, - P : Spread, - Convolution : Spread +impl SensorGrid +where + F: Float, + BT: SensorGridBT, + S: Sensor, + P: Spread, + Convolution: Spread, { - /// Return the grid of sensor locations. pub fn grid(&self) -> LinGrid { lingrid_centered(&self.domain, &self.sensor_count) @@ -162,7 +157,7 @@ /// Constructs a sensor shifted by `x`. #[inline] - fn shifted_sensor(&self, x : Loc) -> ShiftedSensor { + fn shifted_sensor(&self, x: Loc) -> ShiftedSensor { self.base_sensor.clone().shift(x) } @@ -174,57 +169,55 @@ /// Returns the maximum number of overlapping sensors $N_\psi$. pub fn max_overlapping(&self) -> F { let w = self.base_sensor.support_hint().width(); - let d = map2(self.domain.width(), &self.sensor_count, |wi, &i| wi/F::cast_from(i)); + let d = map2(self.domain.width(), &self.sensor_count, |wi, &i| { + wi / F::cast_from(i) + }); w.iter() - .zip(d.iter()) - .map(|(&wi, &di)| (wi/di).ceil()) - .reduce(F::mul) - .unwrap() + .zip(d.iter()) + .map(|(&wi, &di)| (wi / di).ceil()) + .reduce(F::mul) + .unwrap() } } -impl Mapping> for SensorGrid +impl Mapping> for SensorGrid where - F : Float, - BT : SensorGridBT, - S : Sensor, - P : Spread, - Convolution : Spread, + F: Float, + BT: SensorGridBT, + S: Sensor, + P: Spread, + Convolution: Spread, { - - type Codomain = DVector; + type Codomain = DVector; #[inline] - fn apply>>(&self, μ : I) -> DVector { + fn apply>>(&self, μ: I) -> DVector { let mut y = self._zero_observable(); self.apply_add(&mut y, μ); y } } - -impl Linear> for SensorGrid +impl Linear> for SensorGrid where - F : Float, - BT : SensorGridBT, - S : Sensor, - P : Spread, - Convolution : Spread, -{ } - + F: Float, + BT: SensorGridBT, + S: Sensor, + P: Spread, + Convolution: Spread, +{ +} #[replace_float_literals(F::cast_from(literal))] -impl GEMV, DVector> for SensorGrid -where F : Float, - BT : SensorGridBT, - S : Sensor, - P : Spread, - Convolution : Spread, +impl GEMV, DVector> for SensorGrid +where + F: Float, + BT: SensorGridBT, + S: Sensor, + P: Spread, + Convolution: Spread, { - - fn gemv>>( - &self, y : &mut DVector, α : F, μ : I, β : F - ) { + fn gemv>>(&self, y: &mut DVector, α: F, μ: I, β: F) { let grid = self.grid(); if β == 0.0 { y.fill(0.0) @@ -243,9 +236,7 @@ } } - fn apply_add>>( - &self, y : &mut DVector, μ : I - ) { + fn apply_add>>(&self, y: &mut DVector, μ: I) { let grid = self.grid(); for δ in μ.ref_instance() { for &d in self.bt.iter_at(&δ.x) { @@ -254,23 +245,20 @@ } } } - } - -impl -BoundedLinear, Radon, L2, F> -for SensorGrid -where F : Float, - BT : SensorGridBT>, - S : Sensor, - P : Spread, - Convolution : Spread + LocalAnalysis +impl BoundedLinear, Radon, L2, F> + for SensorGrid +where + F: Float, + BT: SensorGridBT>, + S: Sensor, + P: Spread, + Convolution: Spread + LocalAnalysis, { - /// An estimate on the operator norm in $𝕃(ℳ(Ω); ℝ^n)$ with $ℳ(Ω)$ equipped /// with the Radon norm, and $ℝ^n$ with the Euclidean norm. - fn opnorm_bound(&self, _ : Radon, _ : L2) -> F { + fn opnorm_bound(&self, _: Radon, _: L2) -> F { // With {x_i}_{i=1}^n the grid centres and φ the kernel, we have // |Aμ|_2 = sup_{|z|_2 ≤ 1} ⟨z,Αμ⟩ = sup_{|z|_2 ≤ 1} ⟨A^*z|μ⟩ // ≤ sup_{|z|_2 ≤ 1} |A^*z|_∞ |μ|_ℳ @@ -287,20 +275,22 @@ } } -type SensorGridPreadjoint<'a, A, F, const N : usize> = PreadjointHelper<'a, A, RNDM>; - +type SensorGridPreadjoint<'a, A, F, const N: usize> = PreadjointHelper<'a, A, RNDM>; -impl -Preadjointable, DVector> -for SensorGrid -where F : Float, - BT : SensorGridBT, - S : Sensor, - P : Spread, - Convolution : Spread + LocalAnalysis +impl Preadjointable, DVector> + for SensorGrid +where + F: Float, + BT: SensorGridBT, + S: Sensor, + P: Spread, + Convolution: Spread + LocalAnalysis, { type PreadjointCodomain = BTFN, BT, N>; - type Preadjoint<'a> = SensorGridPreadjoint<'a, Self, F, N> where Self : 'a; + type Preadjoint<'a> + = SensorGridPreadjoint<'a, Self, F, N> + where + Self: 'a; fn preadjoint(&self) -> Self::Preadjoint<'_> { PreadjointHelper::new(self) @@ -318,7 +308,7 @@ Convolution : Spread + Lipschitz + DifferentiableMapping> + LocalAnalysis, for<'b> as DifferentiableMapping>>::Differential<'b> : Lipschitz, { - + type FloatType = F; fn value_unit_lipschitz_factor(&self) -> Option { @@ -342,96 +332,92 @@ */ #[replace_float_literals(F::cast_from(literal))] -impl<'a, F, S, P, BT, const N : usize> BoundedCurvature -for SensorGrid -where F : Float, - BT : SensorGridBT, - S : Sensor, - P : Spread, - Convolution : Spread + Lipschitz + DifferentiableMapping> + LocalAnalysis, - for<'b> as DifferentiableMapping>>::Differential<'b> : Lipschitz, +impl<'a, F, S, P, BT, const N: usize> BoundedCurvature for SensorGrid +where + F: Float, + BT: SensorGridBT, + S: Sensor, + P: Spread, + Convolution: Spread + + Lipschitz + + DifferentiableMapping> + + LocalAnalysis, + for<'b> as DifferentiableMapping>>::Differential<'b>: + Lipschitz, { - type FloatType = F; - /// Returns a bound $ℓ_F$ on the curvature - /// $$ - /// 𝒦_F(μ, γ) = ∫ B_{F'(μ)} dγ + B_F(μ, μ+Δ). - /// $$ - /// such that $𝒦_F(μ, γ) ≤ ℓ_F ∫ c_2 d|γ|$. + /// Returns factors $ℓ_F$ and $Θ²$ such that + /// $B_{F'(μ)} dγ ≤ ℓ_F c_2$ and $⟨F'(μ)+F'(μ+Δ)|Δ⟩ ≤ Θ²|γ|(c_2)‖γ‖$, + /// where $Δ=(π_♯^1-π_♯^0)γ$. /// - /// For $F(μ)=(1/2)‖Aμ-b‖^2$, we have $B_F(μ, μ+Δ)=(1/2)‖AΔ‖^2$, where $Δ = (π_♯^1-π_♯^0)γ$. - /// So we use Lemma 3.8 for that, bounding - /// $(1/2)‖AΔ‖^2 ≤ Θ ∫ c_2 dγ$ for $Θ=2N_ψML_ψ^2$, where - /// * $L_ψ$ is the 2-norm Lipschitz factor of $ψ$ (sensor * base_spread), and - /// * $N_ψ$ the maximum overlap, - /// * M is a bound on $|γ|(Ω^2)$. - /// - /// We also have $B_{F'(μ)}(x, y) = v(y) - v(x) ⟨∇v(x), x-y⟩$ for $v(x)=A^*(Aμ-b)$. - /// This we want the Lipschitz factor of $∇v$. - /// By Example 4.15, it makes sense to estimate this by $√(2N_ψ)L_{∇ψ}‖b‖$, where - /// $L_{∇ψ}$ is the Lipshitz factor of $∇ψ$. + /// See Lemma 3.8, Lemma 5.10, Remark 5.14, and Example 5.15. fn curvature_bound_components(&self) -> (Option, Option) { let n_ψ = self.max_overlapping(); let ψ_diff_lip = self.base_sensor.diff_ref().lipschitz_factor(L2); let ψ_lip = self.base_sensor.lipschitz_factor(L2); - let a = ψ_diff_lip.map(|l| (2.0 * n_ψ).sqrt() * l); - let b = ψ_lip.map(|l| 2.0 * n_ψ * l.powi(2)); + let ℓ_F = ψ_diff_lip.map(|l| (2.0 * n_ψ).sqrt() * l); + let θ2 = ψ_lip.map(|l| 4.0 * n_ψ * l.powi(2)); - (a, b) + (ℓ_F, θ2) } } - - -#[derive(Clone,Debug)] -pub struct SensorGridSupportGenerator -where F : Float, - S : Sensor, - P : Spread +#[derive(Clone, Debug)] +pub struct SensorGridSupportGenerator +where + F: Float, + S: Sensor, + P: Spread, { - base_sensor : Convolution, - grid : LinGrid, - weights : DVector + base_sensor: Convolution, + grid: LinGrid, + weights: DVector, } -impl SensorGridSupportGenerator -where F : Float, - S : Sensor, - P : Spread, - Convolution : Spread +impl SensorGridSupportGenerator +where + F: Float, + S: Sensor, + P: Spread, + Convolution: Spread, { - #[inline] - fn construct_sensor(&self, id : usize, w : F) -> Weighted, F> { + fn construct_sensor(&self, id: usize, w: F) -> Weighted, F> { let x = self.grid.entry_linear_unchecked(id); self.base_sensor.clone().shift(x).weigh(w) } #[inline] - fn construct_sensor_and_id<'a>(&'a self, (id, w) : (usize, &'a F)) - -> (usize, Weighted, F>) { + fn construct_sensor_and_id<'a>( + &'a self, + (id, w): (usize, &'a F), + ) -> (usize, Weighted, F>) { (id.into(), self.construct_sensor(id, *w)) } } -impl SupportGenerator -for SensorGridSupportGenerator -where F : Float, - S : Sensor, - P : Spread, - Convolution : Spread +impl SupportGenerator for SensorGridSupportGenerator +where + F: Float, + S: Sensor, + P: Spread, + Convolution: Spread, { type Id = usize; type SupportType = Weighted, F>; - type AllDataIter<'a> = MapX<'a, Zip, - std::slice::Iter<'a, F>>, - Self, - (Self::Id, Self::SupportType)> - where Self : 'a; + type AllDataIter<'a> + = MapX< + 'a, + Zip, std::slice::Iter<'a, F>>, + Self, + (Self::Id, Self::SupportType), + > + where + Self: 'a; #[inline] - fn support_for(&self, d : Self::Id) -> Self::SupportType { + fn support_for(&self, d: Self::Id) -> Self::SupportType { self.construct_sensor(d, self.weights[d]) } @@ -442,21 +428,24 @@ #[inline] fn all_data(&self) -> Self::AllDataIter<'_> { - (0..).zip(self.weights.as_slice().iter()).mapX(self, Self::construct_sensor_and_id) + (0..) + .zip(self.weights.as_slice().iter()) + .mapX(self, Self::construct_sensor_and_id) } } -impl ForwardModel, F>, F> -for SensorGrid -where F : Float + ToNalgebraRealField + nalgebra::RealField, - BT : SensorGridBT, - S : Sensor, - P : Spread, - Convolution : Spread + LocalAnalysis, +impl ForwardModel, F>, F> + for SensorGrid +where + F: Float + ToNalgebraRealField + nalgebra::RealField, + BT: SensorGridBT, + S: Sensor, + P: Spread, + Convolution: Spread + LocalAnalysis, { type Observable = DVector; - fn write_observable(&self, b : &Self::Observable, prefix : String) -> DynError { + fn write_observable(&self, b: &Self::Observable, prefix: String) -> DynError { let it = self.grid().into_iter().zip(b.iter()).map(|(x, &v)| (x, v)); write_csv(it, prefix + ".txt") } @@ -467,19 +456,18 @@ } } -impl FindimQuadraticModel, F> -for SensorGrid -where F : Float + ToNalgebraRealField + nalgebra::RealField, - BT : SensorGridBT, - S : Sensor, - P : Spread, - Convolution : Spread + LocalAnalysis +impl FindimQuadraticModel, F> for SensorGrid +where + F: Float + ToNalgebraRealField + nalgebra::RealField, + BT: SensorGridBT, + S: Sensor, + P: Spread, + Convolution: Spread + LocalAnalysis, { - fn findim_quadratic_model( &self, - μ : &DiscreteMeasure, F>, - b : &Self::Observable + μ: &DiscreteMeasure, F>, + b: &Self::Observable, ) -> (DMatrix, DVector) { assert_eq!(b.len(), self.n_sensors()); let mut mA = DMatrix::zeros(self.n_sensors(), μ.len()); @@ -500,25 +488,24 @@ /// /// **This assumes (but does not check) that the sensors are not overlapping.** #[replace_float_literals(F::cast_from(literal))] -impl -AdjointProductBoundedBy, ConvolutionOp> -for SensorGrid -where F : Float + nalgebra::RealField + ToNalgebraRealField, - BT : SensorGridBT, - S : Sensor, - P : Spread, - Convolution : Spread, - K : SimpleConvolutionKernel, - AutoConvolution

: BoundedBy +impl AdjointProductBoundedBy, ConvolutionOp> + for SensorGrid +where + F: Float + nalgebra::RealField + ToNalgebraRealField, + BT: SensorGridBT, + S: Sensor, + P: Spread, + Convolution: Spread, + K: SimpleConvolutionKernel, + AutoConvolution

: BoundedBy, { - type FloatType = F; - fn adjoint_product_bound(&self, seminorm : &ConvolutionOp) -> Option { + fn adjoint_product_bound(&self, seminorm: &ConvolutionOp) -> Option { // Sensors should not take on negative values to allow // A_*A to be upper bounded by a simple convolution of `spread`. if self.sensor.bounds().lower() < 0.0 { - return None + return None; } // Calculate the factor $L_1$ for betwee $ℱ[ψ * ψ] ≤ L_1 ℱ[ρ]$ for $ψ$ the base spread @@ -536,49 +523,51 @@ macro_rules! make_sensorgridsupportgenerator_scalarop_rhs { ($trait:ident, $fn:ident, $trait_assign:ident, $fn_assign:ident) => { - impl - std::ops::$trait_assign - for SensorGridSupportGenerator - where F : Float, - S : Sensor, - P : Spread, - Convolution : Spread { - fn $fn_assign(&mut self, t : F) { + impl std::ops::$trait_assign + for SensorGridSupportGenerator + where + F: Float, + S: Sensor, + P: Spread, + Convolution: Spread, + { + fn $fn_assign(&mut self, t: F) { self.weights.$fn_assign(t); } } - impl - std::ops::$trait - for SensorGridSupportGenerator - where F : Float, - S : Sensor, - P : Spread, - Convolution : Spread { + impl std::ops::$trait for SensorGridSupportGenerator + where + F: Float, + S: Sensor, + P: Spread, + Convolution: Spread, + { type Output = SensorGridSupportGenerator; - fn $fn(mut self, t : F) -> Self::Output { + fn $fn(mut self, t: F) -> Self::Output { std::ops::$trait_assign::$fn_assign(&mut self.weights, t); self } } - impl<'a, F, S, P, const N : usize> - std::ops::$trait - for &'a SensorGridSupportGenerator - where F : Float, - S : Sensor, - P : Spread, - Convolution : Spread { + impl<'a, F, S, P, const N: usize> std::ops::$trait + for &'a SensorGridSupportGenerator + where + F: Float, + S: Sensor, + P: Spread, + Convolution: Spread, + { type Output = SensorGridSupportGenerator; - fn $fn(self, t : F) -> Self::Output { - SensorGridSupportGenerator{ - base_sensor : self.base_sensor.clone(), - grid : self.grid, - weights : (&self.weights).$fn(t) + fn $fn(self, t: F) -> Self::Output { + SensorGridSupportGenerator { + base_sensor: self.base_sensor.clone(), + grid: self.grid, + weights: (&self.weights).$fn(t), } } } - } + }; } make_sensorgridsupportgenerator_scalarop_rhs!(Mul, mul, MulAssign, mul_assign); @@ -586,13 +575,13 @@ macro_rules! make_sensorgridsupportgenerator_unaryop { ($trait:ident, $fn:ident) => { - impl - std::ops::$trait - for SensorGridSupportGenerator - where F : Float, - S : Sensor, - P : Spread, - Convolution : Spread { + impl std::ops::$trait for SensorGridSupportGenerator + where + F: Float, + S: Sensor, + P: Spread, + Convolution: Spread, + { type Output = SensorGridSupportGenerator; fn $fn(mut self) -> Self::Output { self.weights = self.weights.$fn(); @@ -600,55 +589,57 @@ } } - impl<'a, F, S, P, const N : usize> - std::ops::$trait - for &'a SensorGridSupportGenerator - where F : Float, - S : Sensor, - P : Spread, - Convolution : Spread { + impl<'a, F, S, P, const N: usize> std::ops::$trait + for &'a SensorGridSupportGenerator + where + F: Float, + S: Sensor, + P: Spread, + Convolution: Spread, + { type Output = SensorGridSupportGenerator; fn $fn(self) -> Self::Output { - SensorGridSupportGenerator{ - base_sensor : self.base_sensor.clone(), - grid : self.grid, - weights : (&self.weights).$fn() + SensorGridSupportGenerator { + base_sensor: self.base_sensor.clone(), + grid: self.grid, + weights: (&self.weights).$fn(), } } } - } + }; } make_sensorgridsupportgenerator_unaryop!(Neg, neg); -impl<'a, F, S, P, BT, const N : usize> Mapping> -for PreadjointHelper<'a, SensorGrid, RNDM> -where F : Float, - BT : SensorGridBT, - S : Sensor, - P : Spread, - Convolution : Spread + LocalAnalysis, N>, +impl<'a, F, S, P, BT, const N: usize> Mapping> + for PreadjointHelper<'a, SensorGrid, RNDM> +where + F: Float, + BT: SensorGridBT, + S: Sensor, + P: Spread, + Convolution: Spread + LocalAnalysis, N>, { - type Codomain = SensorGridBTFN; - fn apply>>(&self, x : I) -> Self::Codomain { + fn apply>>(&self, x: I) -> Self::Codomain { let fwd = &self.forward_op; - let generator = SensorGridSupportGenerator{ - base_sensor : fwd.base_sensor.clone(), - grid : fwd.grid(), - weights : x.own() + let generator = SensorGridSupportGenerator { + base_sensor: fwd.base_sensor.clone(), + grid: fwd.grid(), + weights: x.own(), }; BTFN::new_refresh(&fwd.bt, generator) } } -impl<'a, F, S, P, BT, const N : usize> Linear> -for PreadjointHelper<'a, SensorGrid, RNDM> -where F : Float, - BT : SensorGridBT, - S : Sensor, - P : Spread, - Convolution : Spread + LocalAnalysis, N>, -{ } - +impl<'a, F, S, P, BT, const N: usize> Linear> + for PreadjointHelper<'a, SensorGrid, RNDM> +where + F: Float, + BT: SensorGridBT, + S: Sensor, + P: Spread, + Convolution: Spread + LocalAnalysis, N>, +{ +}