Enum modtype::cartridges::AllowFlexibleRhs

pub enum AllowFlexibleRhs<C: Cartridge> {
    Infallible(Infallible, PhantomData<fn() -> C>),
}

Allows flexible RHSes.

use modtype::cartridges::{AllowFlexibleRhs, Field};
use num::{BigInt, BigRational};

#[modtype::use_modtype]
type F = modtype::ModType<AllowFlexibleRhs<Field<u64>>, 1_000_000_007u64>;

let mut x = F(1);
x += F(1);
x += 1u64;
x += 1i32;
x += 1f64;
x += BigInt::from(1u32);
x += BigRational::new(BigInt::from(1u32), BigInt::from(1u32));
assert_eq!(x, F(7));

Variants

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

Trait Implementations

impl<C: Cartridge> Cartridge for AllowFlexibleRhs<C>

type Target = C::Target

type AssumePrimeModulus = C::AssumePrimeModulus

type AssumeAlwaysAdjusted = C::AssumeAlwaysAdjusted

type Equality = C::Equality

type Order = C::Order

type Deref = C::Deref

type PartialAddition = C::PartialAddition

type PartialSubtraction = C::PartialSubtraction

type PartialMultiplication = C::PartialMultiplication

type PartialDivision = C::PartialDivision

type FlexibleRhs = True

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

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

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

Whether to call Self::[adjust].

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 sqrt(value: C::Target, modulus: C::Target) -> Option<C::Target> where
    C::PartialMultiplication: IsTrue, 

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Implementation for [From]<[BigUint]>.

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

Implementation for [From]<[BigInt]>.

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

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

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

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

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

Implementation for [PartialEq]::[eq].

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

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

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

Implementation for [Display].

fn fmt_debug(
    value: C::Target,
    modulus: C::Target,
    ty: &'static str,
    fmt: &mut Formatter
) -> Result

Implementation for [Debug].

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

Implementation for [FromStr].

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

Implementation for [Neg].

fn add(lhs: C::Target, rhs: C::Target, modulus: C::Target) -> C::Target where
    C::PartialAddition: IsTrue, 

Implementation for [Add].

fn sub(lhs: C::Target, rhs: C::Target, modulus: C::Target) -> C::Target where
    C::PartialSubtraction: IsTrue, 

Implementation for [Sub].

fn mul(lhs: C::Target, rhs: C::Target, modulus: C::Target) -> C::Target where
    C::PartialMultiplication: IsTrue, 

Implementation for [Mul].

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

Implementation for [Div].

fn rem(lhs: C::Target, rhs: C::Target, modulus: C::Target) -> C::Target where
    C::PartialDivision: IsTrue, 

Implementation for [Rem].

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

Implementation for [Inv].

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

Implementation for [Num].

fn zero(modulus: C::Target) -> C::Target where
    C::PartialAddition: IsTrue, 

Implementation for [Zero]::[zero].

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

Implementation for [Zero]::[is_zero].

fn one(modulus: C::Target) -> C::Target where
    C::PartialMultiplication: IsTrue, 

Implementation for [One]::[one].

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

Implementation for [One]::[is_one].

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

Implementation for [CheckedNeg].

fn checked_add(
    lhs: C::Target,
    rhs: C::Target,
    modulus: C::Target
) -> Option<C::Target> where
    C::PartialAddition: IsTrue, 

Implementation for [CheckedAdd].

fn checked_sub(
    lhs: C::Target,
    rhs: C::Target,
    modulus: C::Target
) -> Option<C::Target> where
    C::PartialSubtraction: IsTrue, 

Implementation for [CheckedSub].

fn checked_mul(
    lhs: C::Target,
    rhs: C::Target,
    modulus: C::Target
) -> Option<C::Target> where
    C::PartialMultiplication: IsTrue, 

Implementation for [CheckedMul].

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

Implementation for [CheckedDiv].

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

Implementation for [CheckedRem].

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

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

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

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