Struct Basis 

pub struct Basis { /* private fields */ }

An ordered, extensible set of pairwise-coprime moduli.

Implementations

impl Basis

pub fn from_count(n: usize) -> Self

Build directly from a prime count (mainly for tests / fixed-size needs).

pub fn standard() -> Self

A general-purpose default basis (~512 bits ≈ 32 channels). Useful for open-ended Level 0/1 work and as the seed the multimodular pipeline grows.

Examples found in repository

examples/float_comparison.rs (line 23)

fn main() {
    let ch = Basis::standard();
    println!("== adele-ring :: exact vs f64 ==\n");
    println!(
        "{:<16} | {:<10} | {:<22} | {:<12} | ULPs",
        "expression", "exact", "f64 result", "abs error"
    );
    println!("{}", "-".repeat(78));

    // 0.1 + 0.2 = 3/10
    let exact = RnsRational::from_fraction(1, 10, ch.clone())
        .add(&RnsRational::from_fraction(1, 5, ch.clone()));
    row("0.1 + 0.2", &exact.display(), 0.1 + 0.2, exact.to_f64());

    // 1/3 * 3 = 1
    let one = RnsRational::from_fraction(1, 3, ch.clone()).mul(&RnsRational::from_int(3, ch.clone()));
    row("1/3 * 3", &one.display(), (1.0 / 3.0) * 3.0, one.to_f64());

    // sqrt(2) * sqrt(2) = 2  (drops to Integer through the tower)
    let s2 = TowerValue::Algebraic(AlgebraicNumber::sqrt(2, ch.clone()));
    let two = s2.mul(&s2);
    let naive = 2f64.sqrt() * 2f64.sqrt();
    row("sqrt2 * sqrt2", "2", naive, two.to_f64().unwrap());

    // sin(pi) = 0  (exact identity; f64 gives ~1.2e-16)
    let sin_pi = TowerValue::Symbolic(SymbolicExpr::Pi).sin();
    row("sin(pi)", "0", std::f64::consts::PI.sin(), sin_pi.to_f64().unwrap());

    // 1/7 * 7 = 1
    let one7 = RnsRational::from_fraction(1, 7, ch.clone()).mul(&RnsRational::from_int(7, ch));
    row("1/7 * 7", &one7.display(), (1.0 / 7.0) * 7.0, one7.to_f64());

    println!("\nEvery `exact` column is bit-for-bit correct; the f64 column drifts.");
}

examples/benchmark_backends.rs (line 24)

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."
    );
}

examples/engineering.rs (line 8)

fn main() {
    let ch = Basis::standard();
    let f = |p: i64, q: i64| RnsRational::from_fraction(p, q, ch.clone());

    println!("== adele-ring :: exact engineering arithmetic ==\n");

    // Stacked plate thicknesses in inches: 3/8 + 1/4 + 5/16.
    let stack = f(3, 8).add(&f(1, 4)).add(&f(5, 16));
    println!("3/8 + 1/4 + 5/16 in   = {} in   (= {:.6} in)", stack, stack.to_f64());

    // Safety factor 1/1.5 = 2/3 exactly.
    let safety = f(1, 1).div(&f(3, 2));
    println!("1 / 1.5               = {}        (= {:.6})", safety, safety.to_f64());

    // Load ratio: 47 kips / 70 kips — stays exact through combination checks.
    let load_ratio = f(47, 70);
    let with_margin = load_ratio.add(&f(1, 10)); // add a 0.1 utilization margin
    println!(
        "47/70 + 1/10          = {}    (= {:.6})",
        with_margin,
        with_margin.to_f64()
    );

    // AISC-style web area: t_w * d  =  (5/16) * (24/1) in^2.
    let t_w = f(5, 16);
    let d = f(24, 1);
    let web_area = t_w.mul(&d);
    println!("(5/16) * 24           = {} in^2   (= {:.6} in^2)", web_area, web_area.to_f64());

    println!("\n-- base awareness --");
    for (p, q) in [(1, 6), (1, 8), (47, 70)] {
        let r = f(p, q);
        println!(
            "{p}/{q}: natural base = {}, terminates in base 10 = {}, period in base 10 = {}",
            r.natural_base(),
            r.exact_in_base(10),
            r.termination_period_in_base(10)
        );
    }

    // Demonstrate the classic float failure that adele-ring avoids.
    let exact = f(1, 10).add(&f(1, 5)); // 0.1 + 0.2
    let naive = 0.1_f64 + 0.2_f64;
    println!("\n0.1 + 0.2 exact       = {}   (f64 gives {:.17})", exact, naive);
    assert_eq!(exact, f(3, 10));
}

pub fn with_bits(bits: u64) -> Self

The smallest basis whose product exceeds 2^bits.

pub fn len(&self) -> usize

Number of channels.

Examples found in repository

examples/benchmark_backends.rs (line 27)

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 is_empty(&self) -> bool

Whether the basis is empty.

pub fn modulus(&self, i: usize) -> u32

The modulus of channel i.

pub fn moduli(&self) -> &[u32]

All moduli as a slice.

pub fn capacity_bits(&self) -> u64

floor(log2(∏ primes)) — the usable bit capacity.

pub fn modulus_product(&self) -> BigUint

The product M = ∏ primes.

pub fn capacity(&self) -> BigUint

Alias for Basis::modulus_product — total dynamic range M.

pub fn signed_capacity(&self) -> BigInt

Signed range bound ⌊M/2⌋: balanced values live in (-bound, bound].

pub fn extend_to_bits(&self, bits: u64) -> Basis

A basis with at least bits of capacity (extends with more primes if needed; the returned basis shares no state but is cheap to build).

Trait Implementations

impl Clone for Basis

fn clone(&self) -> Basis

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Basis

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

Formats the value using the given formatter.

impl Eq for Basis

impl PartialEq for Basis

fn eq(&self, other: &Self) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.