cmpa 0.1.6

// SPDX-License-Identifier: Apache-2.0
// Copyright 2023, 2026 SUSE LLC
// Author: Nicolai Stange <nstange@suse.de>

//! Implementation of multiprecision integer comparison primitives.

use super::limb::{LimbChoice, LimbType, ct_is_zero_l, ct_leq_l_l, ct_lt_or_eq_l_l};
use super::limbs::MpUIntCommon;
#[cfg(test)]
use super::limbs::{MpMutUInt, MpMutUIntSlice};

/// Compare two multiprecision integers for `==`.
///
/// The two multiprecision integers may be of different representations and
/// of arbitrary [lengths in units of bytes](MpUIntCommon::len), independently
/// of each other.
///
/// Returns a [`LimbChoice`] representing `true` if `op0` is equal to `op1`
/// in value and `false` otherwise.
///
/// Execution time depends only on the multiprecision integers' [lengths in
/// units of bytes](MpUIntCommon::len) and is otherwise constant as far as
/// branching is concerned. See [`ct_is_zero_mp()`] and [`ct_is_one_mp()`]
/// for comparing against zero or one.
///
/// # Arguments
///
/// * `op0` - The first operand.
/// * `op1` - The second operand.
pub fn ct_eq_mp_mp<T0: MpUIntCommon, T1: MpUIntCommon>(op0: &T0, op1: &T1) -> LimbChoice {
    let op0_nlimbs = op0.nlimbs();
    let op1_nlimbs = op1.nlimbs();
    let common_nlimbs = op0_nlimbs.min(op1_nlimbs);

    let mut is_neq = 0;
    for i in 0..common_nlimbs {
        let op0_val = op0.load_l(i);
        let op1_val = op1.load_l(i);
        is_neq |= op0_val ^ op1_val;
    }

    for i in common_nlimbs..op0_nlimbs {
        let op0_val = op0.load_l(i);
        is_neq |= op0_val;
    }

    for i in common_nlimbs..op1_nlimbs {
        let op1_val = op1.load_l(i);
        is_neq |= op1_val;
    }

    LimbChoice::from(ct_is_zero_l(is_neq))
}

#[cfg(test)]
fn test_ct_eq_mp_mp<T0: MpMutUIntSlice, T1: MpMutUIntSlice>() {
    use super::limb::LIMB_BYTES;

    let mut op0 = tst_mk_mp_backing_vec!(T0, 2 * LIMB_BYTES);
    let mut op0 = T0::from_slice(&mut op0).unwrap();
    let mut op1 = tst_mk_mp_backing_vec!(T1, 2 * LIMB_BYTES);
    let mut op1 = T1::from_slice(&mut op1).unwrap();
    // [0 1]
    op0.store_l(0, 1);
    // [0 1]
    op1.store_l(0, 1);
    assert_eq!(ct_eq_mp_mp(&op0, &op1).unwrap(), 1);

    let mut op0 = tst_mk_mp_backing_vec!(T0, LIMB_BYTES);
    let mut op0 = T0::from_slice(&mut op0).unwrap();
    let mut op1 = tst_mk_mp_backing_vec!(T1, 2 * LIMB_BYTES);
    let mut op1 = T1::from_slice(&mut op1).unwrap();
    // [1]
    op0.store_l(0, 1);
    // [0 1]
    op1.store_l(0, 1);
    assert_eq!(ct_eq_mp_mp(&op0, &op1).unwrap(), 1);

    let mut op0 = tst_mk_mp_backing_vec!(T0, 2 * LIMB_BYTES);
    let mut op0 = T0::from_slice(&mut op0).unwrap();
    let mut op1 = tst_mk_mp_backing_vec!(T1, LIMB_BYTES);
    let mut op1 = T1::from_slice(&mut op1).unwrap();
    // [0 1]
    op0.store_l(0, 1);
    // [1]
    op1.store_l(0, 1);
    assert_eq!(ct_eq_mp_mp(&op0, &op1).unwrap(), 1);

    let mut op0 = tst_mk_mp_backing_vec!(T0, 2 * LIMB_BYTES);
    let mut op0 = T0::from_slice(&mut op0).unwrap();
    let mut op1 = tst_mk_mp_backing_vec!(T1, 2 * LIMB_BYTES);
    let mut op1 = T1::from_slice(&mut op1).unwrap();
    // [2 1]
    op0.store_l(0, 1);
    op0.store_l(1, 2);
    // [2 1]
    op1.store_l(0, 1);
    op1.store_l(1, 2);
    assert_eq!(ct_eq_mp_mp(&op0, &op1).unwrap(), 1);

    let mut op0 = tst_mk_mp_backing_vec!(T0, LIMB_BYTES);
    let mut op0 = T0::from_slice(&mut op0).unwrap();
    let mut op1 = tst_mk_mp_backing_vec!(T1, 2 * LIMB_BYTES);
    let mut op1 = T1::from_slice(&mut op1).unwrap();
    // [1]
    op0.store_l(0, 1);
    // [2 1]
    op1.store_l(0, 1);
    op1.store_l(1, 2);
    assert_eq!(ct_eq_mp_mp(&op0, &op1).unwrap(), 0);

    let mut op0 = tst_mk_mp_backing_vec!(T0, 2 * LIMB_BYTES);
    let mut op0 = T0::from_slice(&mut op0).unwrap();
    let mut op1 = tst_mk_mp_backing_vec!(T1, LIMB_BYTES);
    let mut op1 = T1::from_slice(&mut op1).unwrap();
    // [2 1]
    op0.store_l(0, 1);
    op0.store_l(1, 2);
    // [1]
    op1.store_l(0, 1);
    assert_eq!(ct_eq_mp_mp(&op0, &op1).unwrap(), 0);

    let mut op0 = tst_mk_mp_backing_vec!(T0, 2 * LIMB_BYTES);
    let mut op0 = T0::from_slice(&mut op0).unwrap();
    let mut op1 = tst_mk_mp_backing_vec!(T1, 2 * LIMB_BYTES);
    let mut op1 = T1::from_slice(&mut op1).unwrap();
    // [0 1]
    op0.store_l(0, 1);
    // [0 2]
    op1.store_l(0, 2);
    assert_eq!(ct_eq_mp_mp(&op0, &op1).unwrap(), 0);

    let mut op0 = tst_mk_mp_backing_vec!(T0, LIMB_BYTES);
    let mut op0 = T0::from_slice(&mut op0).unwrap();
    let mut op1 = tst_mk_mp_backing_vec!(T1, 2 * LIMB_BYTES);
    let mut op1 = T1::from_slice(&mut op1).unwrap();
    // [1]
    op0.store_l(0, 1);
    // [0 2]
    op1.store_l(0, 2);
    assert_eq!(ct_eq_mp_mp(&op0, &op1).unwrap(), 0);

    let mut op0 = tst_mk_mp_backing_vec!(T0, 2 * LIMB_BYTES);
    let mut op0 = T0::from_slice(&mut op0).unwrap();
    let mut op1 = tst_mk_mp_backing_vec!(T1, LIMB_BYTES);
    let mut op1 = T1::from_slice(&mut op1).unwrap();
    // [0 1]
    op0.store_l(0, 1);
    // [2]
    op1.store_l(0, 2);
    assert_eq!(ct_eq_mp_mp(&op0, &op1).unwrap(), 0);
}

#[test]
fn test_ct_eq_be_be() {
    use super::limbs::MpMutBigEndianUIntByteSlice;
    test_ct_eq_mp_mp::<MpMutBigEndianUIntByteSlice, MpMutBigEndianUIntByteSlice>()
}

#[test]
fn test_ct_eq_le_le() {
    use super::limbs::MpMutLittleEndianUIntByteSlice;
    test_ct_eq_mp_mp::<MpMutLittleEndianUIntByteSlice, MpMutLittleEndianUIntByteSlice>()
}

#[test]
fn test_ct_eq_ne_ne() {
    use super::limbs::MpMutNativeEndianUIntLimbsSlice;
    test_ct_eq_mp_mp::<MpMutNativeEndianUIntLimbsSlice, MpMutNativeEndianUIntLimbsSlice>()
}

/// Compare two multiprecision integers for `!=`.
///
/// The two multiprecision integers may be of different representations and
/// of arbitrary [lengths in units of bytes](MpUIntCommon::len), independently
/// of each other.
///
/// Returns a [`LimbChoice`] representing `true` if `op0` is not equal to `op1`
/// in value and `false` otherwise.
///
/// Execution time depends only on the multiprecision integers' [lengths in
/// units of bytes](MpUIntCommon::len) and is otherwise constant as far as
/// branching is concerned.
///
/// # Arguments
///
/// * `op0` - The first operand.
/// * `op1` - The second operand.
pub fn ct_neq_mp_mp<T0: MpUIntCommon, T1: MpUIntCommon>(op0: &T0, op1: &T1) -> LimbChoice {
    !ct_eq_mp_mp(op0, op1)
}

/// Incremental, limb-wise `<=` comparison of two multiprecision integers.
///
/// Used for comparing two multiprecision integers' values while their limbs are
/// being produced or consumed one at a time, e.g. by some arithmetic primitive,
/// without a separate pass over them. The limbs are to be fed to
/// [`update()`](Self::update) in pairs, from least to most significant.
/// [`finish()`](Self::finish) then returns the comparison's result.
///
/// Each step runs in constant time.
struct CtLeqMpMpKernel {
    /// Whether the multiprecision integers' parts inspected so far, i.e. their
    /// least significant limbs up to and including the most recently
    /// [`update()`](Self::update)d ones, compare as `<=`. Either `0` or `1`.
    tail_is_leq: LimbType,
}

impl CtLeqMpMpKernel {
    /// Start a new comparison.
    ///
    /// Before any limbs have been fed, i.e. for two empty multiprecision
    /// integers, the result is `true`.
    pub fn new() -> Self {
        Self { tail_is_leq: 1 }
    }

    /// Feed the next, more significant pair of limbs.
    ///
    /// # Arguments
    ///
    /// * `v0_val` - The next limb of the first operand, `op0`.
    /// * `v1_val` - The next limb of the second operand, `op1`.
    pub fn update(&mut self, v0_val: LimbType, v1_val: LimbType) {
        let (is_lt, is_eq) = ct_lt_or_eq_l_l(v0_val, v1_val);
        // Consider the result from the tail comparisons only if the currently
        // inspected limbs are equal.
        self.tail_is_leq &= is_eq;
        // If the current v0_val is < v1_val, the tail does not matter.
        self.tail_is_leq |= is_lt;
    }

    /// Finish the comparison.
    ///
    /// Returns a [`LimbChoice`] representing `true` if the first operand,
    /// composed of all `v0_val` limbs fed to [`update()`](Self::update), is
    /// less than or equal to the second one, composed of all `v1_val` limbs,
    /// and `false` otherwise.
    pub fn finish(self) -> LimbChoice {
        LimbChoice::from(self.tail_is_leq)
    }
}

/// Incremental, limb-wise `>=` comparison of two multiprecision integers.
///
/// The `>=` counterpart of [`CtLeqMpMpKernel`], see there for the usage. The
/// limbs are to be fed to [`update()`](Self::update) in pairs, from least to
/// most significant. [`finish()`](Self::finish) then returns the comparison's
/// result.
///
/// Each step runs in constant time.
pub(super) struct CtGeqMpMpKernel {
    /// The underlying `<=` comparison, fed with the operands swapped.
    leq_kernel: CtLeqMpMpKernel,
}

impl CtGeqMpMpKernel {
    /// Start a new comparison.
    ///
    /// Before any limbs have been fed, i.e. for two empty multiprecision
    /// integers, the result is `true`.
    pub fn new() -> Self {
        Self {
            leq_kernel: CtLeqMpMpKernel::new(),
        }
    }

    /// Feed the next, more significant pair of limbs.
    ///
    /// # Arguments
    ///
    /// * `v0_val` - The next limb of the first operand, `op0`.
    /// * `v1_val` - The next limb of the second operand, `op1`.
    pub fn update(&mut self, v0_val: LimbType, v1_val: LimbType) {
        self.leq_kernel.update(v1_val, v0_val)
    }

    /// Finish the comparison.
    ///
    /// Returns a [`LimbChoice`] representing `true` if the first operand,
    /// composed of all `v0_val` limbs fed to [`update()`](Self::update), is
    /// greater than or equal to the second one, composed of all `v1_val`
    /// limbs, and `false` otherwise.
    pub fn finish(self) -> LimbChoice {
        self.leq_kernel.finish()
    }
}

/// Compare two multiprecision integers for `<=`.
///
/// The two multiprecision integers may be of different representations and
/// of arbitrary [lengths in units of bytes](MpUIntCommon::len), independently
/// of each other.
///
/// Returns a [`LimbChoice`] representing `true` if `op0` is less than or
/// equal to `op1` in value and `false` otherwise.
///
/// Execution time depends only on the multiprecision integers' [lengths in
/// units of bytes](MpUIntCommon::len) and is otherwise constant as far as
/// branching is concerned. See [`ct_leq_mp_l()`] for comparing against a single
/// [`LimbType`].
///
/// # Arguments
///
/// * `op0` - The first operand.
/// * `op1` - The second operand.
pub fn ct_leq_mp_mp<T0: MpUIntCommon, T1: MpUIntCommon>(op0: &T0, op1: &T1) -> LimbChoice {
    let op0_nlimbs = op0.nlimbs();
    let op1_nlimbs = op1.nlimbs();
    let common_nlimbs = op0_nlimbs.min(op1_nlimbs);

    let mut leq_kernel = CtLeqMpMpKernel::new();
    for i in 0..common_nlimbs {
        leq_kernel.update(op0.load_l(i), op1.load_l(i));
    }
    for i in common_nlimbs..op0_nlimbs {
        leq_kernel.update(op0.load_l(i), 0);
    }
    for i in common_nlimbs..op1_nlimbs {
        leq_kernel.update(0, op1.load_l(i));
    }

    leq_kernel.finish()
}

#[cfg(test)]
fn test_ct_leq_mp_mp<T0: MpMutUIntSlice, T1: MpMutUIntSlice>() {
    use super::limb::LIMB_BYTES;

    let mut op0 = tst_mk_mp_backing_vec!(T0, LIMB_BYTES);
    let op0 = T0::from_slice(&mut op0).unwrap();
    let mut op1 = tst_mk_mp_backing_vec!(T1, LIMB_BYTES);
    let op1 = T1::from_slice(&mut op1).unwrap();
    assert_eq!(ct_leq_mp_mp(&op0, &op1).unwrap(), 1);

    let mut op0 = tst_mk_mp_backing_vec!(T0, LIMB_BYTES);
    let op0 = T0::from_slice(&mut op0).unwrap();
    let mut op1 = tst_mk_mp_backing_vec!(T1, 2 * LIMB_BYTES);
    let op1 = T1::from_slice(&mut op1).unwrap();
    assert_eq!(ct_leq_mp_mp(&op0, &op1).unwrap(), 1);

    let mut op0 = tst_mk_mp_backing_vec!(T0, LIMB_BYTES);
    let op0 = T0::from_slice(&mut op0).unwrap();
    let mut op1 = tst_mk_mp_backing_vec!(T1, 2 * LIMB_BYTES);
    let mut op1 = T1::from_slice(&mut op1).unwrap();
    // [0 1]
    op1.store_l(0, 1);
    assert_eq!(ct_leq_mp_mp(&op0, &op1).unwrap(), 1);

    let mut op0 = tst_mk_mp_backing_vec!(T0, LIMB_BYTES);
    let mut op0 = T0::from_slice(&mut op0).unwrap();
    let mut op1 = tst_mk_mp_backing_vec!(T1, LIMB_BYTES);
    let op1 = T1::from_slice(&mut op1).unwrap();
    // [1]
    op0.store_l(0, 1);
    assert_eq!(ct_leq_mp_mp(&op0, &op1).unwrap(), 0);

    let mut op0 = tst_mk_mp_backing_vec!(T0, LIMB_BYTES);
    let mut op0 = T0::from_slice(&mut op0).unwrap();
    let mut op1 = tst_mk_mp_backing_vec!(T1, 2 * LIMB_BYTES);
    let mut op1 = T1::from_slice(&mut op1).unwrap();
    // [1]
    op0.store_l(0, 1);
    // [0 1]
    op1.store_l(0, 1);
    assert_eq!(ct_leq_mp_mp(&op0, &op1).unwrap(), 1);

    let mut op0 = tst_mk_mp_backing_vec!(T0, LIMB_BYTES);
    let mut op0 = T0::from_slice(&mut op0).unwrap();
    let mut op1 = tst_mk_mp_backing_vec!(T1, 2 * LIMB_BYTES);
    let mut op1 = T1::from_slice(&mut op1).unwrap();
    // [1]
    op0.store_l(0, 1);
    // [0 2]
    op1.store_l(0, 2);
    assert_eq!(ct_leq_mp_mp(&op0, &op1).unwrap(), 1);

    let mut op0 = tst_mk_mp_backing_vec!(T0, LIMB_BYTES);
    let mut op0 = T0::from_slice(&mut op0).unwrap();
    let mut op1 = tst_mk_mp_backing_vec!(T1, 2 * LIMB_BYTES);
    let mut op1 = T1::from_slice(&mut op1).unwrap();
    // [1]
    op0.store_l(0, 1);
    // [1 0]
    op1.store_l(1, 1);
    assert_eq!(ct_leq_mp_mp(&op0, &op1).unwrap(), 1);

    let mut op0 = tst_mk_mp_backing_vec!(T0, 2 * LIMB_BYTES);
    let mut op0 = T0::from_slice(&mut op0).unwrap();
    let mut op1 = tst_mk_mp_backing_vec!(T1, LIMB_BYTES);
    let op1 = T1::from_slice(&mut op1).unwrap();
    // [0 1]
    op0.store_l(0, 1);
    assert_eq!(ct_leq_mp_mp(&op0, &op1).unwrap(), 0);

    let mut op0 = tst_mk_mp_backing_vec!(T0, 2 * LIMB_BYTES);
    let mut op0 = T0::from_slice(&mut op0).unwrap();
    let mut op1 = tst_mk_mp_backing_vec!(T1, LIMB_BYTES);
    let mut op1 = T1::from_slice(&mut op1).unwrap();
    // [0 1]
    op0.store_l(0, 1);
    // [1]
    op1.store_l(0, 1);
    assert_eq!(ct_leq_mp_mp(&op0, &op1).unwrap(), 1);

    let mut op0 = tst_mk_mp_backing_vec!(T0, 2 * LIMB_BYTES);
    let mut op0 = T0::from_slice(&mut op0).unwrap();
    let mut op1 = tst_mk_mp_backing_vec!(T1, LIMB_BYTES);
    let mut op1 = T1::from_slice(&mut op1).unwrap();
    // [0 1]
    op0.store_l(0, 1);
    // [2]
    op1.store_l(0, 2);
    assert_eq!(ct_leq_mp_mp(&op0, &op1).unwrap(), 1);

    let mut op0 = tst_mk_mp_backing_vec!(T0, 2 * LIMB_BYTES);
    let mut op0 = T0::from_slice(&mut op0).unwrap();
    let mut op1 = tst_mk_mp_backing_vec!(T1, 2 * LIMB_BYTES);
    let mut op1 = T1::from_slice(&mut op1).unwrap();
    // [0 1]
    op0.store_l(0, 1);
    // [0 1]
    op1.store_l(0, 1);
    assert_eq!(ct_leq_mp_mp(&op0, &op1).unwrap(), 1);

    let mut op0 = tst_mk_mp_backing_vec!(T0, 2 * LIMB_BYTES);
    let mut op0 = T0::from_slice(&mut op0).unwrap();
    let mut op1 = tst_mk_mp_backing_vec!(T1, 2 * LIMB_BYTES);
    let mut op1 = T1::from_slice(&mut op1).unwrap();
    // [0 1]
    op0.store_l(0, 1);
    // [0 2]
    op1.store_l(0, 2);
    assert_eq!(ct_leq_mp_mp(&op0, &op1).unwrap(), 1);

    let mut op0 = tst_mk_mp_backing_vec!(T0, 2 * LIMB_BYTES);
    let mut op0 = T0::from_slice(&mut op0).unwrap();
    let mut op1 = tst_mk_mp_backing_vec!(T1, 2 * LIMB_BYTES);
    let mut op1 = T1::from_slice(&mut op1).unwrap();
    // [0 1]
    op0.store_l(0, 1);
    // [1 0]
    op1.store_l(1, 1);
    assert_eq!(ct_leq_mp_mp(&op0, &op1).unwrap(), 1);

    let mut op0 = tst_mk_mp_backing_vec!(T0, 2 * LIMB_BYTES);
    let mut op0 = T0::from_slice(&mut op0).unwrap();
    let mut op1 = tst_mk_mp_backing_vec!(T1, 2 * LIMB_BYTES);
    let op1 = T1::from_slice(&mut op1).unwrap();
    // [1 0]
    op0.store_l(1, 1);
    assert_eq!(ct_leq_mp_mp(&op0, &op1).unwrap(), 0);

    let mut op0 = tst_mk_mp_backing_vec!(T0, 2 * LIMB_BYTES);
    let mut op0 = T0::from_slice(&mut op0).unwrap();
    let mut op1 = tst_mk_mp_backing_vec!(T1, LIMB_BYTES);
    let mut op1 = T1::from_slice(&mut op1).unwrap();
    // [1 0]
    op0.store_l(1, 1);
    // [1]
    op1.store_l(0, 1);
    assert_eq!(ct_leq_mp_mp(&op0, &op1).unwrap(), 0);

    let mut op0 = tst_mk_mp_backing_vec!(T0, 2 * LIMB_BYTES);
    let mut op0 = T0::from_slice(&mut op0).unwrap();
    let mut op1 = tst_mk_mp_backing_vec!(T1, 2 * LIMB_BYTES);
    let mut op1 = T1::from_slice(&mut op1).unwrap();
    // [1 0]
    op0.store_l(1, 1);
    // [0 1]
    op1.store_l(0, 1);
    assert_eq!(ct_leq_mp_mp(&op0, &op1).unwrap(), 0);

    let mut op0 = tst_mk_mp_backing_vec!(T0, 2 * LIMB_BYTES);
    let mut op0 = T0::from_slice(&mut op0).unwrap();
    let mut op1 = tst_mk_mp_backing_vec!(T1, LIMB_BYTES);
    let mut op1 = T1::from_slice(&mut op1).unwrap();
    // [1 1]
    op0.store_l(0, 1);
    op0.store_l(1, 1);
    // [1]
    op1.store_l(0, 1);
    assert_eq!(ct_leq_mp_mp(&op0, &op1).unwrap(), 0);

    let mut op0 = tst_mk_mp_backing_vec!(T0, 2 * LIMB_BYTES);
    let mut op0 = T0::from_slice(&mut op0).unwrap();
    let mut op1 = tst_mk_mp_backing_vec!(T1, 2 * LIMB_BYTES);
    let mut op1 = T1::from_slice(&mut op1).unwrap();
    // [1 1]
    op0.store_l(0, 1);
    op0.store_l(1, 1);
    // [0 1]
    op1.store_l(0, 1);
    assert_eq!(ct_leq_mp_mp(&op0, &op1).unwrap(), 0);

    let mut op0 = tst_mk_mp_backing_vec!(T0, 2 * LIMB_BYTES);
    let mut op0 = T0::from_slice(&mut op0).unwrap();
    let mut op1 = tst_mk_mp_backing_vec!(T1, 2 * LIMB_BYTES);
    let mut op1 = T1::from_slice(&mut op1).unwrap();
    // [1 1]
    op0.store_l(0, 1);
    op0.store_l(1, 1);
    // [1 0]
    op1.store_l(1, 1);
    assert_eq!(ct_leq_mp_mp(&op0, &op1).unwrap(), 0);

    let mut op0 = tst_mk_mp_backing_vec!(T0, 2 * LIMB_BYTES);
    let mut op0 = T0::from_slice(&mut op0).unwrap();
    let mut op1 = tst_mk_mp_backing_vec!(T1, 2 * LIMB_BYTES);
    let mut op1 = T1::from_slice(&mut op1).unwrap();
    // [1 1]
    op0.store_l(0, 1);
    op0.store_l(1, 1);
    // [1 1]
    op1.store_l(0, 1);
    op1.store_l(1, 1);
    assert_eq!(ct_leq_mp_mp(&op0, &op1).unwrap(), 1);
}

#[test]
fn test_ct_leq_be_be() {
    use super::limbs::MpMutBigEndianUIntByteSlice;
    test_ct_leq_mp_mp::<MpMutBigEndianUIntByteSlice, MpMutBigEndianUIntByteSlice>()
}

#[test]
fn test_ct_leq_le_le() {
    use super::limbs::MpMutLittleEndianUIntByteSlice;
    test_ct_leq_mp_mp::<MpMutLittleEndianUIntByteSlice, MpMutLittleEndianUIntByteSlice>()
}

#[test]
fn test_ct_leq_ne_ne() {
    use super::limbs::MpMutNativeEndianUIntLimbsSlice;
    test_ct_leq_mp_mp::<MpMutNativeEndianUIntLimbsSlice, MpMutNativeEndianUIntLimbsSlice>()
}

/// Compare two multiprecision integers for `<`.
///
/// The two multiprecision integers may be of different representations and
/// of arbitrary [lengths in units of bytes](MpUIntCommon::len), independently
/// of each other.
///
/// Returns a [`LimbChoice`] representing `true` if `op0` is less than `op1`
/// in value and `false` otherwise.
///
/// Execution time depends only on the multiprecision integers' [lengths in
/// units of bytes](MpUIntCommon::len) and is otherwise constant as far as
/// branching is concerned.
///
/// # Arguments
///
/// * `op0` - The first operand.
/// * `op1` - The second operand.
pub fn ct_lt_mp_mp<T0: MpUIntCommon, T1: MpUIntCommon>(op0: &T0, op1: &T1) -> LimbChoice {
    !ct_geq_mp_mp(op0, op1)
}

/// Compare two multiprecision integers for `>=`.
///
/// The two multiprecision integers may be of different representations and
/// of arbitrary [lengths in units of bytes](MpUIntCommon::len), independently
/// of each other.
///
/// Returns a [`LimbChoice`] representing `true` if `op0` is greater than or
/// equal to `op1` in value and `false` otherwise.
///
/// Execution time depends only on the multiprecision integers' [lengths in
/// units of bytes](MpUIntCommon::len) and is otherwise constant as far as
/// branching is concerned.
///
/// # Arguments
///
/// * `op0` - The first operand.
/// * `op1` - The second operand.
pub fn ct_geq_mp_mp<T0: MpUIntCommon, T1: MpUIntCommon>(op0: &T0, op1: &T1) -> LimbChoice {
    ct_leq_mp_mp(op1, op0)
}

/// Compare two multiprecision integers for `>`.
///
/// The two multiprecision integers may be of different representations and
/// of arbitrary [lengths in units of bytes](MpUIntCommon::len), independently
/// of each other.
///
/// Returns a [`LimbChoice`] representing `true` if `op0` is greater than `op1`
/// in value and `false` otherwise.
///
/// Execution time depends only on the multiprecision integers' [lengths in
/// units of bytes](MpUIntCommon::len) and is otherwise constant as far as
/// branching is concerned.
///
/// # Arguments
///
/// * `op0` - The first operand.
/// * `op1` - The second operand.
pub fn ct_gt_mp_mp<T0: MpUIntCommon, T1: MpUIntCommon>(op0: &T0, op1: &T1) -> LimbChoice {
    !ct_leq_mp_mp(op0, op1)
}

/// Test whether a multiprecision integer is zero.
///
/// Returns a [`LimbChoice`] representing `true` if `op0` is zero in value and
/// `false` otherwise. An empty multiprecision integer is zero.
///
/// Execution time depends only on `op0`'s [length in units of
/// bytes](MpUIntCommon::len) and is otherwise constant as far as branching is
/// concerned. This is a specialized variant of [`ct_eq_mp_mp()`] for comparing
/// against zero.
///
/// # Arguments
///
/// * `op0` - The multiprecision integer to test.
pub fn ct_is_zero_mp<T0: MpUIntCommon>(op0: &T0) -> LimbChoice {
    let mut is_nz: LimbType = 0;
    for i in 0..op0.nlimbs() {
        let op0_val = op0.load_l(i);
        is_nz |= op0_val;
    }
    LimbChoice::from(ct_is_zero_l(is_nz))
}

/// Test whether a multiprecision integer is one.
///
/// Returns a [`LimbChoice`] representing `true` if `op0` is one in value and
/// `false` otherwise. An empty multiprecision integer is zero, hence not one.
///
/// Execution time depends only on `op0`'s [length in units of
/// bytes](MpUIntCommon::len) and is otherwise constant as far as branching is
/// concerned. This is a specialized variant of [`ct_eq_mp_mp()`] for comparing
/// against one.
///
/// # Arguments
///
/// * `op0` - The multiprecision integer to test.
pub fn ct_is_one_mp<T0: MpUIntCommon>(op0: &T0) -> LimbChoice {
    if op0.is_empty() {
        return LimbChoice::from(0);
    }

    let tail_is_not_one = op0.load_l(0) ^ 1;

    let mut head_is_nz: LimbType = 0;
    for i in 1..op0.nlimbs() {
        let op0_val = op0.load_l(i);
        head_is_nz |= op0_val;
    }

    LimbChoice::from(ct_is_zero_l(tail_is_not_one | head_is_nz))
}

/// Compare a multiprecision integer and a [`LimbType`] for `<=`.
///
/// Returns a [`LimbChoice`] representing `true` if `op0` is less than or equal
/// to `op1` in value and `false` otherwise. An empty multiprecision integer is
/// zero, hence less than or equal to any `op1`.
///
/// Execution time depends only on `op0`'s [length in units of
/// bytes](MpUIntCommon::len) and is otherwise constant as far as branching is
/// concerned. This is a specialized variant of [`ct_leq_mp_mp()`] for a single
/// [`LimbType`] second operand.
///
/// # Arguments
///
/// * `op0` - The multiprecision integer to compare. Its [length in units of
///   bytes](MpUIntCommon::len) isn't restricted.
/// * `op1` - The [`LimbType`] to compare against.
pub fn ct_leq_mp_l<T0: MpUIntCommon>(op0: &T0, op1: LimbType) -> LimbChoice {
    if op0.is_empty() {
        return LimbChoice::from(1);
    }

    let l0_is_leq = ct_leq_l_l(op0.load_l(0), op1);

    let mut head_is_nz: LimbType = 0;
    for i in 1..op0.nlimbs() {
        let op0_val = op0.load_l(i);
        head_is_nz |= op0_val;
    }

    l0_is_leq & LimbChoice::from(ct_is_zero_l(head_is_nz))
}