qfall-math 0.1.1

Mathematical foundations for rapid prototyping of lattice-based cryptography
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83

// Copyright © 2025 Niklas Siemer
//
// This file is part of qFALL-math.
//
// qFALL-math is free software: you can redistribute it and/or modify it under
// the terms of the Mozilla Public License Version 2.0 as published by the
// Mozilla Foundation. See <https://mozilla.org/en-US/MPL/2.0/>.

//! Create benchmarks for `sample_z` and discrete Gaussian sampling in this file.

use criterion::*;
use qfall_math::{
    integer::{MatZ, Z},
    rational::Q,
    utils::sample::discrete_gauss::{DiscreteGaussianIntegerSampler, LookupTableSetting},
};

/// benchmark creating a matrix of size 100x100 sampled by a comparatively wide discrete Gaussian distribution.
pub fn bench_sample_z_wide(c: &mut Criterion) {
    let center = Q::from(0);
    let s = Q::from(100);

    c.bench_function("SampleZ wide 10,000", |b| {
        b.iter(|| MatZ::sample_discrete_gauss(100, 100, &center, &s).unwrap())
    });
}

/// benchmark creating a matrix of size 100x100 sampled by a comparatively narrow discrete Gaussian distribution.
pub fn bench_sample_z_narrow(c: &mut Criterion) {
    let center = Q::from(0);
    let s = Q::from(2);

    c.bench_function("SampleZ narrow 10,000", |b| {
        b.iter(|| MatZ::sample_discrete_gauss(100, 100, &center, &s).unwrap())
    });
}

/// benchmark creating a single integer sampled by a comparatively wide discrete Gaussian distribution.
pub fn bench_sample_z_wide_single(c: &mut Criterion) {
    let center = Q::from(0);
    let s = Q::from(100);

    c.bench_function("SampleZ wide single", |b| {
        b.iter(|| Z::sample_discrete_gauss(&center, &s).unwrap())
    });
}

/// benchmark creating a single integer sampled by a comparatively wide discrete Gaussian distribution.
pub fn bench_sample_z_narrow_single(c: &mut Criterion) {
    let center = Q::from(0);
    let s = Q::from(2);

    c.bench_function("SampleZ narrow single", |b| {
        b.iter(|| Z::sample_discrete_gauss(&center, &s).unwrap())
    });
}

/// benchmark discrete Gaussian sampling using [`DiscreteGaussianIntegerSampler::sample_z`] for a variety of widths.
pub fn bench_sample_z(c: &mut Criterion) {
    let center = 0;
    let gaussian_widths = [
        8, 16, 32, 64, 128, 256, 512, 1024, 2048, 4096, //8192, 16384, 32768,
    ];

    for s in gaussian_widths {
        let mut dgis =
            DiscreteGaussianIntegerSampler::init(center, s, 6.0, LookupTableSetting::Precompute)
                .unwrap();

        c.bench_function("DiscreteGauss RejectionSampling", |b| {
            b.iter(|| dgis.sample_z())
        });
    }
}

criterion_group!(
    benches,
    bench_sample_z_wide,
    bench_sample_z_narrow,
    bench_sample_z_wide_single,
    bench_sample_z_narrow_single,
    bench_sample_z,
);