Struct RnsInt 

pub struct RnsInt {
    pub residues: Vec<u32>,
    pub basis: Basis,
}

An exact integer in balanced RNS form (Level 0 of the tower).

Fields

residues: Vec<u32>

residues[i] = value mod basis[i], stored canonically in [0, p).

basis: Basis

Implementations

impl RnsInt

pub fn from_bigint(n: &BigInt, basis: Basis) -> Self

Construct from an arbitrary BigInt (reduced into each channel).

pub fn from_i64(n: i64, basis: Basis) -> Self

Construct from a machine integer.

Examples found in repository

examples/benchmark_backends.rs (line 41)

fn main() {
    let exec = executor();
    let ch = Basis::standard();
    let has_gpu = exec.gpu().is_some();

    println!("== adele-ring :: backend benchmark ({} channels) ==", ch.len());
    println!(
        "GPU available: {}\n",
        if has_gpu {
            exec.gpu().map(|g| g.adapter_name().to_string()).unwrap_or_default()
        } else {
            "no (CPU-only)".to_string()
        }
    );

    println!("{:>10} | {:>14} | {:>12} | winner", "batch_size", "cpu_rayon_us", "gpu_us");
    println!("{}", "-".repeat(56));

    for &size in &[1usize, 16, 128, 1024, 16_384, 65_536] {
        let a = RnsBatch::from_rns_ints(&vec![RnsInt::from_i64(123, ch.clone()); size]);
        let b = RnsBatch::from_rns_ints(&vec![RnsInt::from_i64(456, ch.clone()); size]);

        let iters = if size <= 128 { 2000 } else { 100 };
        let cpu_us = time_backend(|| exec.cpu().batch_add(&a, &b), iters);

        let (gpu_str, winner) = if let Some(gpu) = exec.gpu() {
            let gpu_us = time_backend(|| gpu.batch_add(&a, &b), iters);
            let w = if cpu_us <= gpu_us { "CPU" } else { "GPU" };
            (format!("{gpu_us:>12.2}"), w)
        } else {
            ("         n/a".to_string(), "CPU")
        };

        println!("{size:>10} | {cpu_us:>14.2} | {gpu_str} | {winner}");
    }

    println!(
        "\nNote: CPU wins for small batches (GPU upload/dispatch overhead ~100us);\n\
         GPU pulls ahead once the batch is large enough to amortize that fixed cost."
    );
}

pub fn zero(basis: Basis) -> Self

Additive identity.

pub fn from_residues(residues: Vec<u32>, basis: Basis) -> Self

Build directly from raw channel residues (already reduced into [0, p)).

pub fn to_bigint(&self) -> BigInt

Reconstruct the exact signed value via Garner CRT + balanced folding.

pub fn is_zero(&self) -> bool

true iff every residue is zero.

pub fn add(&self, other: &Self) -> Self

Channel-wise modular addition.

pub fn sub(&self, other: &Self) -> Self

Channel-wise modular subtraction ((a + p - b) % p, no sign-magnitude).

pub fn mul(&self, other: &Self) -> Self

Channel-wise modular multiplication.

pub fn neg(&self) -> Self

Additive inverse (channel-wise (p - r) % p).

Trait Implementations

impl Clone for RnsInt

fn clone(&self) -> RnsInt

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for RnsInt

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

Formats the value using the given formatter.

impl Finite for RnsInt

fn basis(&self) -> &Basis

fn add(&self, o: &Self) -> Self

fn sub(&self, o: &Self) -> Self

fn mul(&self, o: &Self) -> Self

fn try_reconstruct(&self) -> Option<(BigInt, BigInt)>

Reconstruct the exact (p, q) (with q == 1 for integers), or None when the value cannot be recovered within the current basis range.

fn reimage(p: &BigInt, q: &BigInt, basis: &Basis) -> Self

Re-encode a known exact p/q over a (possibly larger) basis.