Trait alga::general::AbstractModule

pub trait AbstractModule<OpGroup: Operator = Additive, OpAdd: Operator = Additive, OpMul: Operator = Multiplicative>: AbstractGroupAbelian<OpGroup> {
    type AbstractRing: AbstractRingCommutative<OpAdd, OpMul>;
    fn multiply_by(&self, r: Self::AbstractRing) -> Self;
}

A module combines two sets: one with an Abelian group structure and another with a commutative ring structure.

OpGroup denotes the Abelian group operator (usually the addition). In addition, and external multiplicative law noted ∘ is defined. Let S be the ring with multiplicative operator OpMul noted ×, multiplicative identity element noted 1, and additive operator OpAdd. Then:

∀ a, b ∈ S
∀ x, y ∈ Self

a ∘ (x + y) = (a ∘ x) + (a ∘ y)
(a + b) ∘ x = (a ∘ x) + (b ∘ x)
(a × b) ∘ x = a ∘ (b ∘ x)
1 ∘ x       = x

Associated Types

type AbstractRing: AbstractRingCommutative<OpAdd, OpMul>

The underlying scalar field.

Loading content...

Required methods

fn multiply_by(&self, r: Self::AbstractRing) -> Self

Multiplies an element of the ring with an element of the module.

Loading content...

Implementations on Foreign Types

impl<N: AbstractRingCommutative<Additive, Multiplicative> + Num + ClosedNeg> AbstractModule<Additive, Additive, Multiplicative> for Complex<N>

type AbstractRing = N

fn multiply_by(&self, r: N) -> Self

impl AbstractModule<Additive, Additive, Multiplicative> for i8

type AbstractRing = i8

fn multiply_by(&self, r: i8) -> Self

impl AbstractModule<Additive, Additive, Multiplicative> for i16

type AbstractRing = i16

fn multiply_by(&self, r: i16) -> Self

impl AbstractModule<Additive, Additive, Multiplicative> for i32

type AbstractRing = i32

fn multiply_by(&self, r: i32) -> Self

impl AbstractModule<Additive, Additive, Multiplicative> for i64

type AbstractRing = i64

fn multiply_by(&self, r: i64) -> Self

impl AbstractModule<Additive, Additive, Multiplicative> for isize

type AbstractRing = isize

fn multiply_by(&self, r: isize) -> Self

impl AbstractModule<Additive, Additive, Multiplicative> for f32

type AbstractRing = f32

fn multiply_by(&self, r: f32) -> Self

impl AbstractModule<Additive, Additive, Multiplicative> for f64

type AbstractRing = f64

fn multiply_by(&self, r: f64) -> Self

Loading content...

Implementors

Loading content...