Trait alga::general::AbstractModule

source ·
pub trait AbstractModule<OpGroup: Operator = Additive, OpAdd: Operator = Additive, OpMul: Operator = Multiplicative>: AbstractGroupAbelian<OpGroup> {
    type AbstractRing: AbstractRingCommutative<OpAdd, OpMul>;

    // Required method
    fn multiply_by(&self, r: Self::AbstractRing) -> Self;
}
Expand description

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

Required Associated Types§

source

type AbstractRing: AbstractRingCommutative<OpAdd, OpMul>

The underlying scalar field.

Required Methods§

source

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

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

Object Safety§

This trait is not object safe.

Implementations on Foreign Types§

source§

impl AbstractModule for f32

§

type AbstractRing = f32

source§

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

source§

impl AbstractModule for f64

§

type AbstractRing = f64

source§

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

source§

impl AbstractModule for i8

§

type AbstractRing = i8

source§

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

source§

impl AbstractModule for i16

§

type AbstractRing = i16

source§

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

source§

impl AbstractModule for i32

§

type AbstractRing = i32

source§

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

source§

impl AbstractModule for i64

§

type AbstractRing = i64

source§

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

source§

impl AbstractModule for isize

§

type AbstractRing = isize

source§

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

source§

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

§

type AbstractRing = N

source§

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

Implementors§