alg_tools: comparison src/mapping.rs

-:2f1798c65fd6
+:c4e394a9c84c
 Traits for mathematical functions.
 */
 use crate::error::DynResult;
 use crate::instance::MyCow;
-pub use crate::instance::{BasicDecomposition, Decomposition, Instance, Space};
+pub use crate::instance::{BasicDecomposition, ClosedSpace, Decomposition, Instance, Space};
 use crate::loc::Loc;
 use crate::norms::{Norm, NormExponent};
 use crate::operator_arithmetic::{Constant, Weighted};
 use crate::types::{ClosedMul, Float, Num};
 use std::marker::PhantomData;
 use std::ops::Mul;
 /// A mapping from `Domain` to `Self::Codomain`.
 pub trait Mapping<Domain: Space> {
-type Codomain: Space;
+type Codomain: ClosedSpace;
 /// Compute the value of `self` at `x`.
 fn apply<I: Instance<Domain>>(&self, x: I) -> Self::Codomain;
 #[inline]
 /// Form the composition `self ∘ other`
 fn compose<X: Space, T: Mapping<X, Codomain = Domain>>(self, other: T) -> Composition<Self, T>
 where
 Self: Sized,
 {
-Composition {
+Composition { outer: self, inner: other, intermediate_norm_exponent: () }
-outer: self,
-inner: other,
-intermediate_norm_exponent: (),
-}
 }
 #[inline]
 /// Form the composition `self ∘ other`, assigning a norm to the inermediate space
 fn compose_with_norm<F, X, T, E>(self, other: T, norm: E) -> Composition<Self, T, E>
 T: Mapping<X, Codomain = Domain>,
 E: NormExponent,
 Domain: Norm<E, F>,
 F: Num,
 {
-Composition {
+Composition { outer: self, inner: other, intermediate_norm_exponent: norm }
-outer: self,
-inner: other,
-intermediate_norm_exponent: norm,
-}
 }
 /// Multiply `self` by the scalar `a`.
 #[inline]
 fn weigh<C>(self, a: C) -> Weighted<Self, C>
 where
 Self: Sized,
 C: Constant,
 Self::Codomain: ClosedMul<C::Type>,
 {
-Weighted {
+Weighted { weight: a, base_fn: self }
-weight: a,
-base_fn: self,
-}
 }
 }
 /// Automatically implemented shorthand for referring to [`Mapping`]s from [`Loc<N, F>`] to `F`.
 pub trait RealMapping<const N: usize, F: Float = f64>: Mapping<Loc<N, F>, Codomain = F> {}
 /// A differentiable mapping from `Domain` to [`Mapping::Codomain`], with differentials
 /// `Differential`.
 ///
 /// This is automatically implemented when [`DifferentiableImpl`] is.
 pub trait DifferentiableMapping<Domain: Space>: Mapping<Domain> {
-type DerivativeDomain: Space;
+type DerivativeDomain: ClosedSpace;
 type Differential<'b>: Mapping<Domain, Codomain = Self::DerivativeDomain>
 where
 Self: 'b;
 /// Calculate differential at `x`
 {
 }
 /// Helper trait for implementing [`DifferentiableMapping`]
 pub trait DifferentiableImpl<X: Space>: Sized {
-type Derivative: Space;
+type Derivative: ClosedSpace;
 /// Compute the differential of `self` at `x`, consuming the input.
 fn differential_impl<I: Instance<X>>(&self, x: I) -> Self::Derivative;
 }
 fn differential<I: Instance<Domain>>(&self, x: I) -> Self::DerivativeDomain {
 self.differential_impl(x)
 }
 fn diff(self) -> Differential<'static, Domain, Self> {
-Differential {
+Differential { g: MyCow::Owned(self), _space: PhantomData }
-g: MyCow::Owned(self),
-_space: PhantomData,
-}
 }
 fn diff_ref(&self) -> Differential<'_, Domain, Self> {
-Differential {
+Differential { g: MyCow::Borrowed(self), _space: PhantomData }
-g: MyCow::Borrowed(self),
-_space: PhantomData,
-}
 }
 }
 /// Container for the differential [`Mapping`] of a [`DifferentiableMapping`].
 pub struct Differential<'a, X, G> {
 /// An auto-trait for constructing a [`FlattenCodomain`] structure for
 /// flattening the codomain of a [`Mapping`] from [`Loc`]`<F, 1>` to `F`.
 pub trait FlattenCodomain<X: Space, F>: Mapping<X, Codomain = Loc<1, F>> + Sized {
 /// Flatten the codomain from [`Loc`]`<F, 1>` to `F`.
 fn flatten_codomain(self) -> FlattenedCodomain<X, F, Self> {
-FlattenedCodomain {
+FlattenedCodomain { g: self, _phantoms: PhantomData }
-g: self,
-_phantoms: PhantomData,
-}
 }
 }
 impl<X: Space, F, G: Sized + Mapping<X, Codomain = Loc<1, F>>> FlattenCodomain<X, F> for G {}
 Mapping<X, Codomain = Loc<N, F>> + Sized
 {
 /// Flatten the codomain from [`Loc`]`<F, 1>` to `F`.
 fn slice_codomain(self, slice: usize) -> SlicedCodomain<'static, X, F, Self, N> {
 assert!(slice < N);
-SlicedCodomain {
+SlicedCodomain { g: MyCow::Owned(self), slice, _phantoms: PhantomData }
-g: MyCow::Owned(self),
-slice,
-_phantoms: PhantomData,
-}
 }
 /// Flatten the codomain from [`Loc`]`<F, 1>` to `F`.
 fn slice_codomain_ref(&self, slice: usize) -> SlicedCodomain<'_, X, F, Self, N> {
 assert!(slice < N);
-SlicedCodomain {
+SlicedCodomain { g: MyCow::Borrowed(self), slice, _phantoms: PhantomData }
-g: MyCow::Borrowed(self),
-slice,
-_phantoms: PhantomData,
-}
 }
 }
 impl<X: Space, F: Copy, G: Sized + Mapping<X, Codomain = Loc<N, F>>, const N: usize>
 SliceCodomain<X, N, F> for G
 T: DifferentiableImpl<X> + Mapping<X>,
 S: DifferentiableImpl<T::Codomain>,
 E: Copy,
 //Composition<S::Derivative, T::Derivative, E>: Space,
 S::Derivative: Mul<T::Derivative, Output = Y>,
-Y: Space,
+Y: ClosedSpace,
 {
 //type Derivative = Composition<S::Derivative, T::Derivative, E>;
 type Derivative = Y;
 /// Compute the differential of `self` at `x`, consuming the input.

Mercurial > repos > alg_tools / file comparison

comparison: src/mapping.rs

src/mapping.rs