alg_tools: comparison src/linops.rs

-:848ecc05becf
+:05089fbc0310
 use numeric_literals::replace_float_literals;
 use std::marker::PhantomData;
 use serde::Serialize;
 use crate::types::*;
-pub use crate::mapping::{Mapping, Space};
+pub use crate::mapping::{Mapping, Space, Composition};
 use crate::direct_product::Pair;
 use crate::instance::Instance;
-use crate::norms::{NormExponent, PairNorm, L1, L2, Linfinity};
+use crate::norms::{NormExponent, PairNorm, L1, L2, Linfinity, Norm};
 /// Trait for linear operators on `X`.
 pub trait Linear<X : Space> : Mapping<X>
 { }
 /// Bounded linear operators
 pub trait BoundedLinear<X, XExp, CodExp, F = f64> : Linear<X>
 where
 F : Num,
-X : Space,
+X : Space + Norm<F, XExp>,
 XExp : NormExponent,
 CodExp : NormExponent
 {
 /// A bound on the operator norm $\|A\|$ for the linear operator $A$=`self`.
 /// This is not expected to be the norm, just any bound on it that can be
 }
 }
 impl<F, X, E> BoundedLinear<X, E, E, F> for IdOp<X>
 where
-X : Space + Clone,
+X : Space + Clone + Norm<F, E>,
 F : Num,
 E : NormExponent
 {
 fn opnorm_bound(&self, _xexp : E, _codexp : E) -> F { F::ONE }
 }
 impl<X : Clone + Space> Preadjointable<X,X> for IdOp<X> {
 type PreadjointCodomain=X;
 type Preadjoint<'a> = IdOp<X> where X : 'a;
 fn preadjoint(&self) -> Self::Preadjoint<'_> { IdOp::new() }
+}
+impl<S, T, E, X> Linear<X> for Composition<S, T, E>
+where
+X : Space,
+T : Linear<X>,
+S : Linear<T::Codomain>
+{ }
+impl<F, S, T, E, X, Y> GEMV<F, X, Y> for Composition<S, T, E>
+where
+F : Num,
+X : Space,
+T : Linear<X>,
+S : GEMV<F, T::Codomain, Y>,
+{
+fn gemv<I : Instance<X>>(&self, y : &mut Y, α : F, x : I, β : F) {
+self.outer.gemv(y, α, self.inner.apply(x), β)
+}
+/// Computes `y = Ax`, where `A` is `Self`
+fn apply_mut<I : Instance<X>>(&self, y : &mut Y, x : I){
+self.outer.apply_mut(y, self.inner.apply(x))
+}
+/// Computes `y += Ax`, where `A` is `Self`
+fn apply_add<I : Instance<X>>(&self, y : &mut Y, x : I){
+self.outer.apply_add(y, self.inner.apply(x))
+}
+}
+impl<F, S, T, X, Z, Xexp, Yexp, Zexp> BoundedLinear<X, Xexp, Yexp, F> for Composition<S, T, Zexp>
+where
+F : Num,
+X : Space + Norm<F, Xexp>,
+Z : Space + Norm<F, Zexp>,
+Xexp : NormExponent,
+Yexp : NormExponent,
+Zexp : NormExponent,
+T : BoundedLinear<X, Xexp, Zexp, F, Codomain=Z>,
+S : BoundedLinear<Z, Zexp, Yexp, F>,
+{
+fn opnorm_bound(&self, xexp : Xexp, yexp : Yexp) -> F {
+let zexp = self.intermediate_norm_exponent;
+self.outer.opnorm_bound(zexp, yexp) * self.inner.opnorm_bound(xexp, zexp)
+}
 }
 /// “Row operator” $(S, T)$; $(S, T)(x, y)=Sx + Ty$.
 pub struct RowOp<S, T>(pub S, pub T);
 impl<F, A, B, S, T, ExpA, ExpB, ExpR>
 BoundedLinear<Pair<A, B>, PairNorm<ExpA, ExpB, $expj>, ExpR, F>
 for RowOp<S, T>
 where
 F : Float,
-A : Space,
+A : Space + Norm<F, ExpA>,
-B : Space,
+B : Space + Norm<F, ExpB>,
 S : BoundedLinear<A, ExpA, ExpR, F>,
 T : BoundedLinear<B, ExpB, ExpR, F>,
 S::Codomain : Add<T::Codomain>,
 <S::Codomain as Add<T::Codomain>>::Output : Space,
 ExpA : NormExponent,
 impl<F, A, S, T, ExpA, ExpS, ExpT>
 BoundedLinear<A, ExpA, PairNorm<ExpS, ExpT, $expj>, F>
 for ColOp<S, T>
 where
 F : Float,
-A : Space,
+A : Space + Norm<F, ExpA>,
 S : BoundedLinear<A, ExpA, ExpS, F>,
 T : BoundedLinear<A, ExpA, ExpT, F>,
 ExpA : NormExponent,
 ExpS : NormExponent,
 ExpT : NormExponent,

Mercurial > repos > alg_tools / file comparison

comparison: src/linops.rs

src/linops.rs