Enum modtype::cartridges::ManuallyAdjust

pub enum ManuallyAdjust<T: UnsignedPrimitive> {
    Infallible(Infallible, PhantomData<fn() -> T>),
}

A Cartridge which does not automatically adjust the inner value.

use num::CheckedAdd as _;

#[modtype::use_modtype]
type Z = modtype::ModType<modtype::cartridges::ManuallyAdjust<u64>, 1_000_000_007u64>;

let mut x = Z(1_000_000_006);

x += Z(u64::max_value() - 1_000_000_006);
assert_eq!(*x.get_mut_unchecked(), u64::max_value());

x.adjust();
assert_eq!(*x.get_mut_unchecked(), u64::max_value() % 1_000_000_007);

Variants

Infallible(Infallible, PhantomData<fn() -> T>)

Trait Implementations

impl<T: UnsignedPrimitive> Cartridge for ManuallyAdjust<T>

type Target = T

type AssumePrimeModulus = False

type AssumeAlwaysAdjusted = False

type Equality = False

type Order = False

type Deref = False

type PartialAddition = True

type PartialSubtraction = True

type PartialMultiplication = True

type PartialDivision = False

type FlexibleRhs = False

fn should_adjust<S: PrimInt>(_: S, _: S) -> bool

Whether to call Self::[adjust].

fn sqrt(_: T, _: T) -> Option<T>

Implementation for modtype{, ::thread_local, ::non_static}::ModType::sqrt.

fn fmt_debug(
    value: T,
    modulus: T,
    _ty: &'static str,
    fmt: &mut Formatter
) -> Result

Implementation for [Debug].

fn add(lhs: T, rhs: T, modulus: T) -> T

Implementation for [Add].

fn sub(lhs: T, rhs: T, modulus: T) -> T

Implementation for [Sub].

fn mul(lhs: T, rhs: T, modulus: T) -> T

Implementation for [Mul].

fn checked_add(lhs: T, rhs: T, modulus: T) -> Option<T>

Implementation for [CheckedAdd].

fn checked_sub(lhs: T, rhs: T, modulus: T) -> Option<T>

Implementation for [CheckedSub].

fn checked_mul(lhs: T, rhs: T, modulus: T) -> Option<T>

Implementation for [CheckedMul].

fn new<T: PrimInt>(raw: T, modulus: T) -> T

Implementation for [From]<Self::Target> and modtype{, ::thread_local}::ModType::new.

fn adjust<T: PrimInt>(raw: &mut T, modulus: T)

Make *raw *raw % modulus.

fn adjusted<T: PrimInt>(raw: T, modulus: T) -> T

Make raw raw % modulus.

fn from_u8(value: u8, modulus: Self::Target) -> Self::Target

Implementation for [From]::<[u8]> and [FromPrimitive]::[from_u8].

fn from_u16(value: u16, modulus: Self::Target) -> Self::Target

Implementation for [From]::<[u16]> and [FromPrimitive]::[from_u16].

fn from_u32(value: u32, modulus: Self::Target) -> Self::Target

Implementation for [From]::<[u32]> and [FromPrimitive]::[from_u32].

fn from_u64(value: u64, modulus: Self::Target) -> Self::Target

Implementation for [From]::<[u64]> and [FromPrimitive]::[from_u64].

fn from_u128(value: u128, modulus: Self::Target) -> Self::Target

Implementation for [From]::<[u128]> and [FromPrimitive]::[from_u128].

fn from_usize(value: usize, modulus: Self::Target) -> Self::Target

Implementation for [From]::<[usize]> and [FromPrimitive]::[from_usize].

fn from_i8(value: i8, modulus: Self::Target) -> Self::Target where
    Self::PartialSubtraction: IsTrue, 

Implementation for [From]::<[i8]> and [FromPrimitive]::[from_i8].

fn from_i16(value: i16, modulus: Self::Target) -> Self::Target where
    Self::PartialSubtraction: IsTrue, 

Implementation for [From]::<[i16]> and [FromPrimitive]::[from_i16].

fn from_i32(value: i32, modulus: Self::Target) -> Self::Target where
    Self::PartialSubtraction: IsTrue, 

Implementation for [From]::<[i32]> and [FromPrimitive]::[from_i32].

fn from_i64(value: i64, modulus: Self::Target) -> Self::Target where
    Self::PartialSubtraction: IsTrue, 

Implementation for [From]::<[i64]> and [FromPrimitive]::[from_i64].

fn from_i128(value: i128, modulus: Self::Target) -> Self::Target where
    Self::PartialSubtraction: IsTrue, 

Implementation for [From]::<[i128]> and [FromPrimitive]::[from_i128].

fn from_isize(value: isize, modulus: Self::Target) -> Self::Target where
    Self::PartialSubtraction: IsTrue, 

Implementation for [From]::<[isize]> and [FromPrimitive]::[from_isize].

fn from_float_prim<F: FloatPrimitive>(
    value: F,
    modulus: Self::Target
) -> Self::Target where
    Self::AssumePrimeModulus: IsTrue,
    Self::PartialSubtraction: IsTrue,
    Self::PartialMultiplication: IsTrue,
    Self::PartialDivision: IsTrue, 

Implementation for [From]::<[f32], [f64]> and [FromPrimitive]::{[from_f32], [from_f64]}.

fn from_biguint(value: BigUint, modulus: Self::Target) -> Self::Target

Implementation for [From]<[BigUint]>.

fn from_bigint(value: BigInt, modulus: Self::Target) -> Self::Target where
    Self::PartialSubtraction: IsTrue, 

Implementation for [From]<[BigInt]>.

fn from_biguint_ratio(
    value: Ratio<BigUint>,
    modulus: Self::Target
) -> Self::Target where
    Self::AssumePrimeModulus: IsTrue,
    Self::PartialDivision: IsTrue, 

Implementation for [From]<[Ratio]<[BigUint]>>.

fn from_bigint_ratio(
    value: Ratio<BigInt>,
    modulus: Self::Target
) -> Self::Target where
    Self::AssumePrimeModulus: IsTrue,
    Self::PartialSubtraction: IsTrue,
    Self::PartialDivision: IsTrue, 

Implementation for [From]<[Ratio]<[BigInt]>>.

fn eq(lhs: Self::Target, rhs: Self::Target, modulus: Self::Target) -> bool where
    Self::Equality: IsTrue, 

Implementation for [PartialEq]::[eq].

fn cmp(lhs: Self::Target, rhs: Self::Target, modulus: Self::Target) -> Ordering where
    Self::Equality: IsTrue,
    Self::Order: IsTrue, 

Implementation for [PartialOrd]::[partial_cmp] and [Ord]::[cmp].

fn fmt_display(
    value: Self::Target,
    modulus: Self::Target,
    fmt: &mut Formatter
) -> Result

Implementation for [Display].

fn from_str(
    str: &str,
    modulus: Self::Target
) -> Result<Self::Target, ParseIntError>

Implementation for [FromStr].

fn neg(value: Self::Target, modulus: Self::Target) -> Self::Target where
    Self::PartialSubtraction: IsTrue, 

Implementation for [Neg].

fn div(
    lhs: Self::Target,
    rhs: Self::Target,
    modulus: Self::Target
) -> Self::Target where
    Self::PartialDivision: IsTrue, 

Implementation for [Div].

fn rem(
    _lhs: Self::Target,
    rhs: Self::Target,
    modulus: Self::Target
) -> Self::Target where
    Self::PartialDivision: IsTrue, 

Implementation for [Rem].

fn inv(value: Self::Target, modulus: Self::Target) -> Self::Target where
    Self::PartialDivision: IsTrue, 

Implementation for [Inv].

fn from_str_radix(
    str: &str,
    radix: u32,
    modulus: Self::Target
) -> Result<Self::Target, ParseIntError> where
    Self::AssumePrimeModulus: IsTrue,
    Self::Equality: IsTrue,
    Self::Order: IsTrue,
    Self::PartialAddition: IsTrue,
    Self::PartialSubtraction: IsTrue,
    Self::PartialMultiplication: IsTrue,
    Self::PartialDivision: IsTrue, 

Implementation for [Num].

fn zero(_modulus: Self::Target) -> Self::Target where
    Self::PartialAddition: IsTrue, 

Implementation for [Zero]::[zero].

fn is_zero(value: Self::Target, modulus: Self::Target) -> bool where
    Self::PartialAddition: IsTrue, 

Implementation for [Zero]::[is_zero].

fn one(_modulus: Self::Target) -> Self::Target where
    Self::PartialMultiplication: IsTrue, 

Implementation for [One]::[one].

fn is_one(value: Self::Target, modulus: Self::Target) -> bool where
    Self::Equality: IsTrue,
    Self::PartialMultiplication: IsTrue, 

Implementation for [One]::[is_one].

fn checked_neg(
    value: Self::Target,
    modulus: Self::Target
) -> Option<Self::Target> where
    Self::PartialSubtraction: IsTrue, 

Implementation for [CheckedNeg].

fn checked_div(
    lhs: Self::Target,
    rhs: Self::Target,
    modulus: Self::Target
) -> Option<Self::Target> where
    Self::PartialDivision: IsTrue, 

Implementation for [CheckedDiv].

fn checked_rem(
    _lhs: Self::Target,
    rhs: Self::Target,
    modulus: Self::Target
) -> Option<Self::Target> where
    Self::PartialDivision: IsTrue, 

Implementation for [CheckedRem].

fn pow_unsigned<E: UnsignedPrimitive>(
    base: Self::Target,
    exp: E,
    modulus: Self::Target
) -> Self::Target where
    Self::PartialMultiplication: IsTrue, 

Implementation for [Pow]<{[u8], [u16], [u32], [u64], [u128], [usize]}>.

fn pow_signed<E: SignedPrimitive>(
    base: Self::Target,
    exp: E,
    modulus: Self::Target
) -> Self::Target where
    Self::AssumePrimeModulus: IsTrue,
    Self::PartialMultiplication: IsTrue,
    Self::PartialDivision: IsTrue, 

Implementation for [Pow]<{[i8], [i16], [i32], [i64], [i128], [isize]}>.