Struct FiniteAugmentedChainComplex 

pub struct FiniteAugmentedChainComplex<M, F1, F2, CC>
where
    M: Module,
    CC: ChainComplex<Algebra = M::Algebra>,
    F1: ModuleHomomorphism<Source = M, Target = M>,
    F2: ModuleHomomorphism<Source = M, Target = CC::Module>,
{
    cc: FiniteChainComplex<M, F1>,
    target_cc: Arc<CC>,
    chain_maps: Vec<Arc<F2>>,
}

Fields

cc: FiniteChainComplex<M, F1>

target_cc: Arc<CC>

chain_maps: Vec<Arc<F2>>

Implementations

impl<M, CC> FiniteAugmentedChainComplex<M, FullModuleHomomorphism<M>, FullModuleHomomorphism<M, CC::Module>, CC>

where M: Module, CC: ChainComplex<Algebra = M::Algebra>,

pub fn map<N: Module<Algebra = M::Algebra>>( &self, f: impl FnMut(&M) -> N, ) -> FiniteAugmentedChainComplex<N, FullModuleHomomorphism<N>, FullModuleHomomorphism<N, CC::Module>, CC>

Trait Implementations

impl<M, F1, F2, CC> AugmentedChainComplex for FiniteAugmentedChainComplex<M, F1, F2, CC>

where M: Module, CC: ChainComplex<Algebra = M::Algebra>, F1: ModuleHomomorphism<Source = M, Target = M>, F2: ModuleHomomorphism<Source = M, Target = CC::Module>,

fn chain_map(&self, s: i32) -> Arc<Self::ChainMap>

This currently crashes if s is greater than the s degree of the class this came from.

type ChainMap = F2

type TargetComplex = CC

fn target(&self) -> Arc<Self::TargetComplex>

impl<M, F1, F2, CC> BoundedChainComplex for FiniteAugmentedChainComplex<M, F1, F2, CC>

where M: Module, CC: ChainComplex<Algebra = M::Algebra>, F1: ModuleHomomorphism<Source = M, Target = M>, F2: ModuleHomomorphism<Source = M, Target = CC::Module>,

fn max_s(&self) -> i32

fn euler_characteristic(&self, t: i32) -> isize

impl<M, F1, F2, CC> ChainComplex for FiniteAugmentedChainComplex<M, F1, F2, CC>

where M: Module, CC: ChainComplex<Algebra = M::Algebra>, F1: ModuleHomomorphism<Source = M, Target = M>, F2: ModuleHomomorphism<Source = M, Target = CC::Module>,

type Algebra = <M as Module>::Algebra

type Homomorphism = F1

type Module = M

fn algebra(&self) -> Arc<M::Algebra>

fn min_degree(&self) -> i32

fn has_computed_bidegree(&self, b: Bidegree) -> bool

If the complex has been computed at bidegree (s, t). This means the module has been computed at (s, t), and so has the differential at (s, t). In the case of a free module, the target of the differential, namely the bidegree (s - 1, t), need not be computed, as long as all the generators hit by the differential have already been computed.

fn zero_module(&self) -> Arc<Self::Module>

fn module(&self, s: i32) -> Arc<Self::Module>

fn differential(&self, s: i32) -> Arc<Self::Homomorphism>

This returns the differential starting from the sth module.

fn compute_through_bidegree(&self, b: Bidegree)

Ensure all bidegrees less than or equal to (s, t) have been computed

fn next_homological_degree(&self) -> i32

The first s such that self.module(s) is not defined.

fn prime(&self) -> ValidPrime

fn iter_stem(&self) -> StemIterator<'_, Self>

Iterate through all defined bidegrees in increasing order of stem.

fn apply_quasi_inverse<T, S>( &self, results: &mut [T], b: Bidegree, inputs: &[S], ) -> bool

where for<'a> &'a mut T: Into<FpSliceMut<'a>>, for<'a> &'a S: Into<FpSlice<'a>>,

Apply the quasi-inverse of the (s, t)th differential to the list of inputs and results. This defaults to applying self.differentials(s).quasi_inverse(t), but in some cases the quasi-inverse might be stored separately on disk.

fn save_dir(&self) -> &SaveDirectory

A directory used to save information about the chain complex.

fn save_file(&self, kind: SaveKind, b: Bidegree) -> SaveFile<Self::Algebra>

Get the save file of a bidegree

impl<M, F1, F2, CC> From<FiniteAugmentedChainComplex<M, F1, F2, CC>> for FiniteChainComplex<M, F1>

where M: Module, CC: ChainComplex<Algebra = M::Algebra>, F1: ModuleHomomorphism<Source = M, Target = M>, F2: ModuleHomomorphism<Source = M, Target = CC::Module>,

fn from(c: FiniteAugmentedChainComplex<M, F1, F2, CC>) -> Self

Converts to this type from the input type.