Mercurial > repos > alg_tools / changeset

--- a/src/direct_product.rs	Mon Dec 30 15:46:28 2024 -0500
+++ b/src/direct_product.rs	Tue Dec 31 10:51:32 2024 -0500
@@ -287,6 +287,11 @@
 
     type Owned = Pair<A::Owned, B::Owned>;
 
+    fn add_mul<I : Instance<Pair<U,V>>>(self, α : F, x : I, β : F) -> Self::Owned {
+        let Pair(u, v) = x.decompose();
+        Pair(self.0.add_mul(α, u, β), self.1.add_mul(α, v, β))
+    }
+
     fn axpy<I : Instance<Pair<U,V>>>(&mut self, α : F, x : I, β : F) {
         let Pair(u, v) = x.decompose();
         self.0.axpy(α, u, β);

--- a/src/linops.rs	Mon Dec 30 15:46:28 2024 -0500
+++ b/src/linops.rs	Tue Dec 31 10:51:32 2024 -0500
@@ -24,6 +24,9 @@
 {
     type Owned : AXPY<F, X>;
 
+    /// Computes  `βy + αx`, where `y` is `Self`.
+    fn add_mul<I : Instance<X>>(self, α : F, x : I, β : F) -> Self::Owned ;
+
     /// Computes  `y = βy + αx`, where `y` is `Self`.
     fn axpy<I : Instance<X>>(&mut self, α : F, x : I, β : F);
 
@@ -47,6 +50,7 @@
 /// Efficient in-place application for [`Linear`] operators.
 #[replace_float_literals(F::cast_from(literal))]
 pub trait GEMV<F : Num, X : Space, Y = <Self as Mapping<X>>::Codomain> : Linear<X> {
+    
     /// Computes  `y = αAx + βy`, where `A` is `Self`.
     fn gemv<I : Instance<X>>(&self, y : &mut Y, α : F, x : I, β : F);
 

--- a/src/loc.rs	Mon Dec 30 15:46:28 2024 -0500
+++ b/src/loc.rs	Tue Dec 31 10:51:32 2024 -0500
@@ -709,6 +709,12 @@
     type Owned = Self;
 
     #[inline]
+    fn add_mul<I : Instance<Loc<F, N>>>(mut self, α : F, x : I, β : F) -> Self {
+        self.axpy(α, x, β);
+        self
+    }
+
+    #[inline]
     fn axpy<I : Instance<Loc<F, N>>>(&mut self, α : F, x : I, β : F) {
         x.eval(|x̃| {
             if β == F::ZERO {

--- a/src/nalgebra_support.rs	Mon Dec 30 15:46:28 2024 -0500
+++ b/src/nalgebra_support.rs	Tue Dec 31 10:51:32 2024 -0500
@@ -91,6 +91,13 @@
     type Owned = OVector<E, M>;
 
     #[inline]
+    fn add_mul<I : Instance<Vector<E,M,SV1>>>(self, α : E, x : I, β : E) -> Self::Owned {
+        let mut owned = self.into_owned();
+        x.eval(|x̃| Matrix::axpy(&mut owned, α, x̃, β));
+        owned
+    }
+
+    #[inline]
     fn axpy<I : Instance<Vector<E,M,SV1>>>(&mut self, α : E, x : I, β : E) {
         x.eval(|x̃| Matrix::axpy(self, α, x̃, β))
     }