# HG changeset patch
# User Tuomo Valkonen <tuomov@iki.fi>
# Date 1747143881 18000
# Node ID 26df914dda6720e01bfe2ea8cc42ae4f3dfa8d1a
# Parent  f78885441218cbb08af89f7566f581a53c51983c
Generalise ZeroOp

diff -r f78885441218 -r 26df914dda67 src/linops.rs
--- a/src/linops.rs	Tue May 13 00:24:51 2025 -0500
+++ b/src/linops.rs	Tue May 13 08:44:41 2025 -0500
@@ -47,9 +47,6 @@
 {
     type Field: Num;
     type Owned: AXPY<X, Field = Self::Field>;
-    // type OriginGen<'a>: OriginGenerator<Self::Owned, F>
-    // where
-    //     Self: 'a;
 
     /// Computes  `y = βy + αx`, where `y` is `Self`.
     fn axpy<I: Instance<X>>(&mut self, α: Self::Field, x: I, β: Self::Field);
@@ -306,57 +303,123 @@
     }
 }
 
+pub trait OriginGenerator<Y: AXPY> {
+    type Ref<'b>: OriginGenerator<Y>
+    where
+        Self: 'b;
+
+    fn origin(&self) -> Y::Owned;
+    fn as_ref(&self) -> Self::Ref<'_>;
+}
+
+impl<Y: AXPY> OriginGenerator<Y> for Y {
+    type Ref<'b>
+        = &'b Y
+    where
+        Self: 'b;
+
+    #[inline]
+    fn origin(&self) -> Y::Owned {
+        return self.similar_origin();
+    }
+
+    #[inline]
+    fn as_ref(&self) -> Self::Ref<'_> {
+        self
+    }
+}
+
+impl<'b, Y: AXPY> OriginGenerator<Y> for &'b Y {
+    type Ref<'c>
+        = Self
+    where
+        Self: 'c;
+
+    #[inline]
+    fn origin(&self) -> Y::Owned {
+        return self.similar_origin();
+    }
+
+    #[inline]
+    fn as_ref(&self) -> Self::Ref<'_> {
+        self
+    }
+}
+
 /// A zero operator that can be eitherh dualised or predualised (once).
 /// This is achieved by storing an oppropriate zero.
-pub struct ZeroOp<X, Y: AXPY<Field = F>, C, O, F: Float = f64> {
-    codomain_sample: C,
-    other_sample: O,
+pub struct ZeroOp<X, Y: AXPY<Field = F>, OY: OriginGenerator<Y>, O, F: Float = f64> {
+    codomain_origin_generator: OY,
+    other_origin_generator: O,
     _phantoms: PhantomData<(X, Y, F)>,
 }
 
-impl<'b, X, Y, F> ZeroOp<X, Y, &'b Y, &'b X::DualSpace, F>
+impl<X, Y, OY, F> ZeroOp<X, Y, OY, (), F>
 where
-    X: HasDual<F>,
-    Y: HasDual<F>,
-    Y::Owned: Clone,
+    OY: OriginGenerator<Y>,
+    X: AXPY<Field = F>,
+    Y: AXPY<Field = F>,
     F: Float,
 {
-    pub fn new_dualisable(x_dual_sample: &'b X::DualSpace, y_sample: &'b Y) -> Self {
+    pub fn new(y_og: OY) -> Self {
         ZeroOp {
-            codomain_sample: y_sample,
-            other_sample: x_dual_sample,
+            codomain_origin_generator: y_og,
+            other_origin_generator: (),
             _phantoms: PhantomData,
         }
     }
 }
 
-impl<'b, X, Y, O, F> Mapping<X> for ZeroOp<X, Y, &'b Y, O, F>
+impl<X, Y, OY, OXprime, Xprime, Yprime, F> ZeroOp<X, Y, OY, OXprime, F>
+where
+    OY: OriginGenerator<Y>,
+    OXprime: OriginGenerator<Xprime>,
+    X: HasDual<F, DualSpace = Xprime>,
+    Y: HasDual<F, DualSpace = Yprime>,
+    F: Float,
+    Xprime: AXPY<Field = F, Owned = Xprime>,
+    Xprime::Owned: AXPY<Field = F>,
+    Yprime: Space + Instance<Yprime>,
+{
+    pub fn new_dualisable(y_og: OY, xprime_og: OXprime) -> Self {
+        ZeroOp {
+            codomain_origin_generator: y_og,
+            other_origin_generator: xprime_og,
+            _phantoms: PhantomData,
+        }
+    }
+}
+
+impl<X, Y, O, OY, F> Mapping<X> for ZeroOp<X, Y, OY, O, F>
 where
     X: Space + Instance<X>,
     Y: AXPY<Field = F>,
     F: Float,
+    OY: OriginGenerator<Y>,
 {
     type Codomain = Y::Owned;
 
     fn apply<I: Instance<X>>(&self, _x: I) -> Y::Owned {
-        self.codomain_sample.similar_origin()
+        self.codomain_origin_generator.origin()
     }
 }
 
-impl<'b, X, Y, O, F> Linear<X> for ZeroOp<X, Y, &'b Y, O, F>
+impl<X, Y, OY, O, F> Linear<X> for ZeroOp<X, Y, OY, O, F>
 where
     X: Space + Instance<X>,
     Y: AXPY<Field = F>,
     F: Float,
+    OY: OriginGenerator<Y>,
 {
 }
 
 #[replace_float_literals(F::cast_from(literal))]
-impl<'b, X, Y, O, F> GEMV<F, X, Y> for ZeroOp<X, Y, &'b Y, O, F>
+impl<X, Y, OY, O, F> GEMV<F, X, Y> for ZeroOp<X, Y, OY, O, F>
 where
     X: Space + Instance<X>,
-    Y: AXPY<Field = F>,
+    Y: AXPY<Field = F, Owned = Y>,
     F: Float,
+    OY: OriginGenerator<Y>,
 {
     // Computes  `y = αAx + βy`, where `A` is `Self`.
     fn gemv<I: Instance<X>>(&self, y: &mut Y, _α: F, _x: I, β: F) {
@@ -368,7 +431,7 @@
     }
 }
 
-impl<'b, X, Y, O, F, E1, E2> BoundedLinear<X, E1, E2, F> for ZeroOp<X, Y, &'b Y, O, F>
+impl<X, Y, OY, O, F, E1, E2> BoundedLinear<X, E1, E2, F> for ZeroOp<X, Y, OY, O, F>
 where
     X: Space + Instance<X> + Norm<E1, F>,
     Y: AXPY<Field = F>,
@@ -376,13 +439,15 @@
     F: Float,
     E1: NormExponent,
     E2: NormExponent,
+    OY: OriginGenerator<Y>,
 {
     fn opnorm_bound(&self, _xexp: E1, _codexp: E2) -> DynResult<F> {
         Ok(F::ZERO)
     }
 }
 
-impl<'b, X, Y, Xprime, Yprime, F> Adjointable<X, Yprime> for ZeroOp<X, Y, &'b Y, &'b Xprime, F>
+impl<'b, X, Y, OY, OXprime, Xprime, Yprime, F> Adjointable<X, Yprime>
+    for ZeroOp<X, Y, OY, OXprime, F>
 where
     X: HasDual<F, DualSpace = Xprime>,
     Y: HasDual<F, DualSpace = Yprime>,
@@ -390,184 +455,25 @@
     Xprime: AXPY<Field = F, Owned = Xprime>,
     Xprime::Owned: AXPY<Field = F>,
     Yprime: Space + Instance<Yprime>,
+    OY: OriginGenerator<Y>,
+    OXprime: OriginGenerator<X::DualSpace>,
 {
     type AdjointCodomain = Xprime;
     type Adjoint<'c>
-        = ZeroOp<Yprime, Xprime, &'b Xprime, (), F>
+        = ZeroOp<Yprime, Xprime, OXprime::Ref<'c>, (), F>
     where
         Self: 'c;
     // () means not (pre)adjointable.
 
     fn adjoint(&self) -> Self::Adjoint<'_> {
         ZeroOp {
-            codomain_sample: self.other_sample,
-            other_sample: (),
-            _phantoms: PhantomData,
-        }
-    }
-}
-
-/*
-/// Trait for forming origins (zeroes) in vector spaces
-pub trait OriginGenerator<X, F: Num = f64> {
-    fn make_origin(&self) -> X;
-}
-
-/// Origin generator for statically sized Euclidean spaces.
-pub struct StaticEuclideanOriginGenerator;
-
-impl<X, F: Float> OriginGenerator<X, F> for StaticEuclideanOriginGenerator
-where
-    X: StaticEuclidean<F> + Euclidean<F, Output = X>,
-{
-    #[inline]
-    fn make_origin(&self) -> X {
-        X::origin()
-    }
-}
-
-/// Origin generator arbitrary spaces that implement [`AXPY`], based on a sample vector.
-pub struct SimilarOriginGenerator<'a, X>(&'a X);
-
-impl<'a, X, F: Float> OriginGenerator<X, F> for SimilarOriginGenerator<'a, X>
-where
-    X: AXPY<F, Owned = X>,
-{
-    #[inline]
-    fn make_origin(&self) -> X {
-        self.0.similar_origin()
-    }
-}
-
-pub struct NotAnOriginGenerator;
-
-/// The zero operator
-#[derive(Clone, Copy, Debug, Serialize, Eq, PartialEq)]
-pub struct ZeroOp<X, Y, YOrigin, XDOrigin = NotAnOriginGenerator, F: Num = f64> {
-    y_origin: YOrigin,
-    xd_origin: XDOrigin,
-    _phantoms: PhantomData<(X, Y, F)>,
-}
-
-// TODO: Need to make Zero in Instance.
-
-impl<X, Y, F, YOrigin, XDOrigin> ZeroOp<X, Y, YOrigin, XDOrigin, F>
-where
-    F: Num,
-    YOrigin: OriginGenerator<Y, F>,
-{
-    pub fn new(y_origin: YOrigin, xd_origin: XDOrigin) -> Self {
-        ZeroOp {
-            y_origin,
-            xd_origin,
+            codomain_origin_generator: self.other_origin_generator.as_ref(),
+            other_origin_generator: (),
             _phantoms: PhantomData,
         }
     }
 }
 
-impl<X, Y, F, YOrigin, XDOrigin> Mapping<X> for ZeroOp<X, Y, YOrigin, XDOrigin, F>
-where
-    F: Num,
-    YOrigin: OriginGenerator<Y, F>,
-    Y: Space,
-    X: Space + Instance<X>,
-{
-    type Codomain = Y;
-
-    fn apply<I: Instance<X>>(&self, _: I) -> Y {
-        self.y_origin.make_origin()
-    }
-}
-
-impl<X, Y, F, YOrigin, XDOrigin> Linear<X> for ZeroOp<X, Y, YOrigin, XDOrigin, F>
-where
-    F: Num,
-    YOrigin: OriginGenerator<Y, F>,
-    Y: Space,
-    X: Space + Instance<X>,
-{
-}
-
-#[replace_float_literals(F::cast_from(literal))]
-impl<X, Y, F, YOrigin, XDOrigin> GEMV<F, X, Y> for ZeroOp<X, Y, YOrigin, XDOrigin, F>
-where
-    F: Num,
-    YOrigin: OriginGenerator<Y, F>,
-    Y: Space + AXPY<F>,
-    X: Space + Instance<X>,
-{
-    // Computes  `y = αAx + βy`, where `A` is `Self`.
-    fn gemv<I: Instance<X>>(&self, y: &mut Y, _α: F, _x: I, β: F) {
-        *y *= β;
-    }
-
-    fn apply_mut<I: Instance<X>>(&self, y: &mut Y, _x: I) {
-        y.set_zero();
-    }
-}
-
-impl<X, Y, F, YOrigin, XDOrigin, E1, E2> BoundedLinear<X, E1, E2, F>
-    for ZeroOp<X, Y, YOrigin, XDOrigin, F>
-where
-    F: Num,
-    YOrigin: OriginGenerator<Y, F>,
-    Y: Space + AXPY<F> + Norm<E2, F>,
-    X: Space + Instance<X> + Norm<E1, F>,
-    E1: NormExponent,
-    E2: NormExponent,
-{
-    fn opnorm_bound(&self, _xexp: E1, _codexp: E2) -> DynResult<F> {
-        Ok(F::ZERO)
-    }
-}
-
-impl<X, Y, Yprime, F, YOrigin, XDOrigin> Adjointable<X, Yprime>
-    for ZeroOp<X, Y, YOrigin, XDOrigin, F>
-where
-    F: Num,
-    YOrigin: OriginGenerator<Y, F>,
-    Y: Space + AXPY<F>,
-    X: Space + Instance<X> + HasDual<F>,
-    XDOrigin: OriginGenerator<X::DualSpace, F> + Clone,
-    Yprime: Space + Instance<Yprime>,
-{
-    type AdjointCodomain = X::DualSpace;
-    type Adjoint<'b>
-        = ZeroOp<Yprime, X::DualSpace, XDOrigin, NotAnOriginGenerator, F>
-    where
-        Self: 'b;
-    // () means not (pre)adjointable.
-
-    fn adjoint(&self) -> Self::Adjoint<'_> {
-        ZeroOp::new(self.xd_origin.clone(), NotAnOriginGenerator)
-    }
-}
-*/
-
-/*
-impl<X, Y, Ypre, Xpre, F, YOrigin, XDOrigin> Preadjointable<X, Ypre>
-    for ZeroOp<X, Y, YOrigin, XDOrigin, F>
-where
-    F: Num,
-    YOrigin: OriginGenerator<Y, F>,
-    Y: Space + AXPY<F>,
-    X: Space + Instance<X> + HasDual<F>,
-    XDOrigin: OriginGenerator<Xpre, F> + Clone,
-    Ypre: Space + Instance<Ypre> + HasDual<DualSpace = X>,
-{
-    type PreadjointCodomain = Xpre;
-    type Preadjoint<'b>
-        = ZeroOp<Ypre, Xpre, XDOrigin, NotAnOriginGenerator, F>
-    where
-        Self: 'b;
-    // () means not (pre)adjointable.
-
-    fn adjoint(&self) -> Self::Adjoint<'_> {
-        ZeroOp::new(self.xpre_origin.clone(), NotAnOriginGenerator)
-    }
-}
-*/
-
 impl<S, T, E, X> Linear<X> for Composition<S, T, E>
 where
     X: Space,