Struct libbgs::numbers::SylowElem

pub struct SylowElem<S, const L: usize, C: SylowDecomposable<S>> {
    pub coords: [u128; L],
    /* private fields */
}

An element of the decomposition of a finite cyclic group into the direct sum of its Sylow subgroups.

Fields

coords: [u128; L]

The powers on the generators of the Sylow subgroups. In particular, if an element of a group $G$ with generators $g_1,\ldots,g_n$ is $$g = \prod_{i = 1}^n g_i^{r_i},$$ then the coordinates of that element are $r_1,\ldots,r_n$.

Implementations

impl<S, const L: usize, C: SylowDecomposable<S>> SylowElem<S, L, C>

pub const fn new(coords: [u128; L]) -> SylowElem<S, L, C>

Returns an element of the Sylow decomposition with the given coordinates.

pub fn to_product(&self, g: &SylowDecomp<S, L, C>) -> C

Returns the element of the original group with the given coordinates.

pub fn order(&self) -> u128

Returns the positive integer represented by this Factorization.

Trait Implementations

impl<S, const L: usize, C: SylowDecomposable<S>> Clone for SylowElem<S, L, C>

fn clone(&self) -> Self

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<S, const L: usize, C: SylowDecomposable<S>> Debug for SylowElem<S, L, C>

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

Formats the value using the given formatter.

impl<S, const L: usize, C: SylowDecomposable<S>> Factor<S> for SylowElem<S, L, C>

const FACTORS: Factorization = _

The prime factorization of this object.

impl<S, const L: usize, C> GroupElem for SylowElem<S, L, C>where C: SylowDecomposable<S> + Eq,

const ONE: Self = _

The unique identity element of this group.

const SIZE: u128 = C::SIZE

The size of the group this element belongs to.

fn multiply(&self, other: &SylowElem<S, L, C>) -> SylowElem<S, L, C>

Returns the product of two elements under the group binary operator. If you implement this trait, you must guarantee that the operation is associative; that is, a.multiply(b.multiply(c)) == a.multiply(b).multiply(c).

fn inverse(&self) -> SylowElem<S, L, C>

Returns the multiplicative inverse of this element. If you implement this trait, you must guarantee x.inverse().multiply(x) and x.multiply(x.inverse()) both evaluate to ONE.

const ONE_256: [Self; 256] = _

👎Deprecated: To be replaced by inline const expressions once stabilized.

! 256 copies of Self::ONE in an array.

fn pow(&self, n: u128) -> Self

Raises this element to the power of n.

fn order<S>(&self) -> u128where Self: Factor<S>,

Returns the order of this element, that is, the smallest positive power p for which a.pow(p).is_one() returns True.

impl<S, const L: usize, C: SylowDecomposable<S>> PartialEq<SylowElem<S, L, C>> for SylowElem<S, L, C>

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

This method tests for self and other values to be equal, and is used by ==.

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

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

impl<S, const L: usize, C: SylowDecomposable<S>> SylowDecomposable<S> for SylowElem<S, L, C>

fn find_sylow_generator(i: usize) -> Self

Finds a Sylow generator for the Sylow subgroup of prime power index i.

fn is_sylow_generator(candidate: &Self, d: (u128, usize)) -> Option<Self>

True if the given element is a generator of the Sylow subgroup of the prime power represented by d.

fn count_elements_of_order(ds: &[usize]) -> u128

Returns the number of elements of a particular order. The argument is the powers of the prime factors of the group’s order.

impl<S, const L: usize, C: SylowDecomposable<S>> Copy for SylowElem<S, L, C>

impl<S, const L: usize, C: SylowDecomposable<S>> Eq for SylowElem<S, L, C>