Trait ModPowPrecomputedAssign

pub trait ModPowPrecomputedAssign<RHS: Two = Self, M = Self>: ModPowPrecomputed<RHS, M> {
    // Required method
    fn mod_pow_precomputed_assign(&mut self, exp: RHS, m: M, data: &Self::Data);
}

Raises a number to a power modulo another number $m$, in place. The base must be already reduced modulo $m$.

If multiple modular exponentiations with the same modulus are necessary, it can be quicker to precompute some piece of data and reuse it in the exponentiation calls. This trait provides a function for using precomputed data during exponentiation. For precomputing the data, use the precompute_mod_pow_data function in ModPowPrecomputed.

Required Methods

fn mod_pow_precomputed_assign(&mut self, exp: RHS, m: M, data: &Self::Data)

Dyn Compatibility

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety", so this trait is not object safe.

Implementations on Foreign Types

impl ModPowPrecomputedAssign for u64

fn mod_pow_precomputed_assign(&mut self, exp: u64, m: u64, data: &Self::Data)

Raises a number to a power modulo another number $m$, in place. The base must be already reduced modulo $m$.

Some precomputed data is provided; this speeds up computations involving several modular exponentiations with the same modulus. The precomputed data should be obtained using precompute_mod_pow_data.

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(1)$

where $T$ is time, $M$ is additional memory, and $n$ is exp.significant_bits().

Examples

See here.

impl ModPowPrecomputedAssign<u64> for u8

fn mod_pow_precomputed_assign(&mut self, exp: u64, m: u8, data: &Self::Data)

Raises a number to a power modulo another number $m$, in place. The base must be already reduced modulo $m$.

Some precomputed data is provided; this speeds up computations involving several modular exponentiations with the same modulus. The precomputed data should be obtained using precompute_mod_pow_data.

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(1)$

where $T$ is time, $M$ is additional memory, and $n$ is exp.significant_bits().

Examples

See here.

impl ModPowPrecomputedAssign<u64> for u16

fn mod_pow_precomputed_assign(&mut self, exp: u64, m: u16, data: &Self::Data)

Raises a number to a power modulo another number $m$, in place. The base must be already reduced modulo $m$.

Some precomputed data is provided; this speeds up computations involving several modular exponentiations with the same modulus. The precomputed data should be obtained using precompute_mod_pow_data.

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(1)$

where $T$ is time, $M$ is additional memory, and $n$ is exp.significant_bits().

Examples

See here.

impl ModPowPrecomputedAssign<u64> for u32

fn mod_pow_precomputed_assign(&mut self, exp: u64, m: u32, data: &Self::Data)

Raises a number to a power modulo another number $m$, in place. The base must be already reduced modulo $m$.

Some precomputed data is provided; this speeds up computations involving several modular exponentiations with the same modulus. The precomputed data should be obtained using precompute_mod_pow_data.

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(1)$

where $T$ is time, $M$ is additional memory, and $n$ is exp.significant_bits().

Examples

See here.

impl ModPowPrecomputedAssign<u64> for u128

fn mod_pow_precomputed_assign(&mut self, exp: u64, m: u128, data: &Self::Data)

Raises a number to a power modulo another number $m$, in place. The base must be already reduced modulo $m$.

Some precomputed data is provided; this speeds up computations involving several modular exponentiations with the same modulus. The precomputed data should be obtained using precompute_mod_pow_data.

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(1)$

where $T$ is time, $M$ is additional memory, and $n$ is exp.significant_bits().

Examples

See here.

impl ModPowPrecomputedAssign<u64> for usize

fn mod_pow_precomputed_assign(&mut self, exp: u64, m: usize, data: &Self::Data)

Raises a number to a power modulo another number $m$, in place. The base must be already reduced modulo $m$.

Some precomputed data is provided; this speeds up computations involving several modular exponentiations with the same modulus. The precomputed data should be obtained using precompute_mod_pow_data.

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(1)$

where $T$ is time, $M$ is additional memory, and $n$ is exp.significant_bits().

Examples

See here.

Implementors