--- a/src/convex.rs Tue Dec 31 08:30:02 2024 -0500
+++ b/src/convex.rs Tue Dec 31 09:02:55 2024 -0500
@@ -2,8 +2,10 @@
Some convex analysis basics
*/
+use std::marker::PhantomData;
use crate::types::*;
use crate::mapping::{Mapping, Space};
+use crate::linops::IdOp;
use crate::instance::{Instance, InstanceMut, DecompositionMut};
use crate::norms::*;
@@ -11,16 +13,15 @@
///
/// TODO: should constrain `Mapping::Codomain` to implement a partial order,
/// but this makes everything complicated with little benefit.
-pub trait ConvexMapping<Domain : Space> : Mapping<Domain>
+pub trait ConvexMapping<Domain : Space, F : Num = f64> : Mapping<Domain, Codomain = F>
{}
/// Trait for mappings with a Fenchel conjugate
///
/// The conjugate type has to implement [`ConvexMapping`], but a `Conjugable` mapping need
/// not be convex.
-pub trait Conjugable<Domain : Space> : Mapping<Domain> {
- type DualDomain : Space;
- type Conjugate<'a> : ConvexMapping<Self::DualDomain> where Self : 'a;
+pub trait Conjugable<Domain : HasDual<F>, F : Num = f64> : Mapping<Domain> {
+ type Conjugate<'a> : ConvexMapping<Domain::DualSpace, F> where Self : 'a;
fn conjugate(&self) -> Self::Conjugate<'_>;
}
@@ -28,10 +29,13 @@
/// Trait for mappings with a Fenchel preconjugate
///
/// In contrast to [`Conjugable`], the preconjugate need not implement [`ConvexMapping`],
-/// but a `Preconjugable` mapping has be convex.
-pub trait Preconjugable<Domain : Space> : ConvexMapping<Domain> {
- type PredualDomain : Space;
- type Preconjugate<'a> : Mapping<Self::PredualDomain> where Self : 'a;
+/// but a `Preconjugable` mapping has to be convex.
+pub trait Preconjugable<Domain, Predual, F : Num = f64> : ConvexMapping<Domain, F>
+where
+ Domain : Space,
+ Predual : HasDual<F>
+{
+ type Preconjugate<'a> : Mapping<Predual> where Self : 'a;
fn preconjugate(&self) -> Self::Preconjugate<'_>;
}
@@ -65,20 +69,13 @@
pub struct NormConjugate<F : Float, E : NormExponent>(NormMapping<F, E>);
-impl<Domain, E, F> ConvexMapping<Domain> for NormMapping<F, E>
+impl<Domain, E, F> ConvexMapping<Domain, F> for NormMapping<F, E>
where
Domain : Space,
E : NormExponent,
F : Float,
- Self : Mapping<Domain, Codomain=F> {}
-
-
-impl<Domain, E, F> ConvexMapping<Domain> for NormConjugate<F, E>
-where
- Domain : Space,
- E : NormExponent,
- F : Float,
- Self : Mapping<Domain, Codomain=F> {}
+ Self : Mapping<Domain, Codomain=F>
+{}
impl<F, E, Domain> Mapping<Domain> for NormConjugate<F, E>
@@ -98,20 +95,121 @@
}
}
+impl<Domain, E, F> ConvexMapping<Domain, F> for NormConjugate<F, E>
+where
+ Domain : Space,
+ E : NormExponent,
+ F : Float,
+ Self : Mapping<Domain, Codomain=F>
+{}
+
+
+impl<E, F, Domain> Conjugable<Domain, F> for NormMapping<F, E>
+where
+ E : HasDualExponent,
+ F : Float,
+ Domain : HasDual<F> + Norm<F, E> + Space,
+ <Domain as HasDual<F>>::DualSpace : Norm<F, E::DualExp>
+{
+ type Conjugate<'a> = NormConjugate<F, E::DualExp> where Self : 'a;
+
+ fn conjugate(&self) -> Self::Conjugate<'_> {
+ NormConjugate(self.exponent.dual_exponent().as_mapping())
+ }
+}
-impl<E, F, Domain> Conjugable<Domain> for NormMapping<F, E>
-where
- E : NormExponent + Clone,
- F : Float,
- Domain : Norm<F, E> + Space,
-{
+/// The zero mapping
+pub struct Zero<Domain : Space, F : Num>(PhantomData<(Domain, F)>);
+
+impl<Domain : Space, F : Num> Zero<Domain, F> {
+ pub fn new() -> Self {
+ Zero(PhantomData)
+ }
+}
+
+impl<Domain : Space, F : Num> Mapping<Domain> for Zero<Domain, F> {
+ type Codomain = F;
- type DualDomain = Domain;
- type Conjugate<'a> = NormConjugate<F, E> where Self : 'a;
+ /// Compute the value of `self` at `x`.
+ fn apply<I : Instance<Domain>>(&self, _x : I) -> Self::Codomain {
+ F::ZERO
+ }
+}
+
+impl<Domain : Space, F : Num> ConvexMapping<Domain, F> for Zero<Domain, F> { }
+
+impl<Domain : HasDual<F>, F : Float> Conjugable<Domain, F> for Zero<Domain, F> {
+ type Conjugate<'a> = ZeroIndicator<Domain::DualSpace, F> where Self : 'a;
+
+ #[inline]
fn conjugate(&self) -> Self::Conjugate<'_> {
- NormConjugate(self.clone())
+ ZeroIndicator::new()
}
}
+impl<Domain, Predual, F : Float> Preconjugable<Domain, Predual, F> for Zero<Domain, F>
+where
+ Domain : Space,
+ Predual : HasDual<F>
+{
+ type Preconjugate<'a> = ZeroIndicator<Predual, F> where Self : 'a;
+
+ #[inline]
+ fn preconjugate(&self) -> Self::Preconjugate<'_> {
+ ZeroIndicator::new()
+ }
+}
+
+impl<Domain : Space + Clone, F : Num> Prox<Domain> for Zero<Domain, F> {
+ type Prox<'a> = IdOp<Domain> where Self : 'a;
+
+ #[inline]
+ fn prox_mapping(&self, _τ : Self::Codomain) -> Self::Prox<'_> {
+ IdOp::new()
+ }
+}
+
+
+/// The zero indicator
+pub struct ZeroIndicator<Domain : Space, F : Num>(PhantomData<(Domain, F)>);
+
+impl<Domain : Space, F : Num> ZeroIndicator<Domain, F> {
+ pub fn new() -> Self {
+ ZeroIndicator(PhantomData)
+ }
+}
+
+impl<Domain : Normed<F>, F : Float> Mapping<Domain> for ZeroIndicator<Domain, F> {
+ type Codomain = F;
+
+ /// Compute the value of `self` at `x`.
+ fn apply<I : Instance<Domain>>(&self, x : I) -> Self::Codomain {
+ x.eval(|x̃| if x̃.is_zero() { F::ZERO } else { F::INFINITY })
+ }
+}
+
+impl<Domain : Normed<F>, F : Float> ConvexMapping<Domain, F> for ZeroIndicator<Domain, F> { }
+
+impl<Domain : HasDual<F>, F : Float> Conjugable<Domain, F> for ZeroIndicator<Domain, F> {
+ type Conjugate<'a> = Zero<Domain::DualSpace, F> where Self : 'a;
+
+ #[inline]
+ fn conjugate(&self) -> Self::Conjugate<'_> {
+ Zero::new()
+ }
+}
+
+impl<Domain, Predual, F : Float> Preconjugable<Domain, Predual, F> for ZeroIndicator<Domain, F>
+where
+ Domain : Normed<F>,
+ Predual : HasDual<F>
+{
+ type Preconjugate<'a> = Zero<Predual, F> where Self : 'a;
+
+ #[inline]
+ fn preconjugate(&self) -> Self::Preconjugate<'_> {
+ Zero::new()
+ }
+}