Struct FiniteDimensionalModule 

pub struct FiniteDimensionalModule<A: Algebra> {
    algebra: Arc<A>,
    pub name: String,
    graded_dimension: BiVec<usize>,
    gen_names: BiVec<Vec<String>>,
    actions: BiVec<BiVec<Vec<Vec<FpVector>>>>,
}

Fields

algebra: Arc<A>

name: String

graded_dimension: BiVec<usize>

gen_names: BiVec<Vec<String>>

actions: BiVec<BiVec<Vec<Vec<FpVector>>>>

Implementations

impl<A: Algebra> FiniteDimensionalModule<A>

pub fn test_equal(&self, other: &Self) -> Result<(), String>

impl<A: Algebra> FiniteDimensionalModule<A>

pub fn new( algebra: Arc<A>, name: String, graded_dimension: BiVec<usize>, ) -> Self

pub fn set_basis_element_name(&mut self, degree: i32, idx: usize, name: String)

fn allocate_actions( algebra: &Arc<A>, graded_dimension: &BiVec<usize>, ) -> BiVec<BiVec<Vec<Vec<FpVector>>>>

pub fn add_generator(&mut self, degree: i32, name: String)

pub fn string_to_basis_element(&self, string: &str) -> Option<(i32, usize)>

pub fn set_action( &mut self, operation_degree: i32, operation_idx: usize, input_degree: i32, input_idx: usize, output: &[u32], )

pub fn action( &self, operation_degree: i32, operation_idx: usize, input_degree: i32, input_idx: usize, ) -> &FpVector

This function will panic if you call it with input such that module.dimension(input_degree + operation_degree) = 0.

pub fn action_mut( &mut self, operation_degree: i32, operation_idx: usize, input_degree: i32, input_idx: usize, ) -> &mut FpVector

This function will panic if you call it with input such that module.dimension(input_degree + operation_degree) = 0.

impl<A: GeneratedAlgebra> FiniteDimensionalModule<A>

pub fn from_json(algebra: Arc<A>, json: &Value) -> Result<Self>

pub fn to_json(&self, json: &mut Value)

pub fn parse_action( &mut self, gen_to_idx: impl for<'a> Fn(&'a str) -> Result<(i32, usize)>, entry: &str, overwrite: bool, ) -> Result<()>

pub fn check_validity( &self, input_deg: i32, output_deg: i32, ) -> Result<(), ModuleFailedRelationError>

pub fn extend_actions(&mut self, input_deg: i32, output_deg: i32)

fn actions_to_json(&self) -> Value

Trait Implementations

impl<A: Algebra> Clone for FiniteDimensionalModule<A>

fn clone(&self) -> Self

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<A: Algebra> Display for FiniteDimensionalModule<A>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<M: Module> From<&M> for FiniteDimensionalModule<M::Algebra>

fn from(module: &M) -> Self

This should really by try_from but orphan rules prohibit this

impl<A: Algebra> Module for FiniteDimensionalModule<A>

type Algebra = A

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

The algebra the module is over.

fn min_degree(&self) -> i32

The minimum degree of the module, which is required to be bounded below

fn max_computed_degree(&self) -> i32

The maximum t for which the module is fully defined at t. See Module documentation for more details.

fn compute_basis(&self, _degree: i32)

Compute internal data of the module so that we can query information up to degree degree. This should be run by the user whenever they want to query such information.

fn dimension(&self, degree: i32) -> usize

The dimension of a module at the given degree

fn basis_element_to_string(&self, degree: i32, idx: usize) -> String

The name of a basis element. This is useful for debugging and printing results.

fn act_on_basis( &self, result: FpSliceMut<'_>, coeff: u32, op_degree: i32, op_index: usize, mod_degree: i32, mod_index: usize, )

fn max_degree(&self) -> Option<i32>

max_degree is the a degree such that if t > max_degree, then self.dimension(t) = 0.

fn is_unit(&self) -> bool

Whether this is the unit module.

fn prime(&self) -> ValidPrime

The prime the module is over, which should be equal to the prime of the algebra.

fn max_generator_degree(&self) -> Option<i32>

Maximum degree of a generator under the Steenrod action. Every element in higher degree must be obtainable from applying a Steenrod action to a lower degree element.

fn total_dimension(&self) -> usize

fn act( &self, result: FpSliceMut<'_>, coeff: u32, op_degree: i32, op_index: usize, input_degree: i32, input: FpSlice<'_>, )

The length of input need not be equal to the dimension of the module in said degree. Missing entries are interpreted to be 0, while extra entries must be zero.

fn act_by_element( &self, result: FpSliceMut<'_>, coeff: u32, op_degree: i32, op: FpSlice<'_>, input_degree: i32, input: FpSlice<'_>, )

fn act_by_element_on_basis( &self, result: FpSliceMut<'_>, coeff: u32, op_degree: i32, op: FpSlice<'_>, input_degree: i32, input_index: usize, )

fn element_to_string(&self, degree: i32, element: FpSlice<'_>) -> String

Gives the name of an element. The default implementation is derived from Module::basis_element_to_string in the obvious way.

impl<A: Algebra> PartialEq for FiniteDimensionalModule<A>

fn eq(&self, other: &Self) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<A: Algebra> ZeroModule for FiniteDimensionalModule<A>

fn zero_module(algebra: Arc<A>, min_degree: i32) -> Self

impl<A: Algebra> Eq for FiniteDimensionalModule<A>