Struct DifferentialPrivacyEngine 

pub struct DifferentialPrivacyEngine {
    pub budget: BudgetTracker,
    /* private fields */
}

Production-grade differential-privacy engine.

Manages a privacy budget, generates calibrated noise, and records an auditable history of answered queries.

Fields

budget: BudgetTracker

Live budget tracker.

Implementations

impl DifferentialPrivacyEngine

pub fn new(epsilon_budget: f64, delta_budget: f64, max_history: usize) -> Self

Construct a new engine with the given budget parameters.

The PRNG is seeded with 0xDEADBEEF42.

pub fn compute_noise_scale(mechanism: &PrivacyMechanism) -> NoiseScale

Compute the noise scale for a given mechanism.

• Laplace: scale = sensitivity / epsilon
• Gaussian: scale = sensitivity * sqrt(2 * ln(1.25 / delta)) / epsilon
• Randomized: scale = 1 / (exp(epsilon) + 1) (flip probability)

pub fn sample_laplace(&mut self, scale: f64) -> f64

Sample from Laplace(0, scale) using the inverse-CDF method.

Formula: -scale * sign(u - 0.5) * ln(1 - 2 * |u - 0.5|). If the argument to ln is ≤ 0, uses 1e-10 as a floor.

pub fn sample_gaussian(&mut self, scale: f64) -> f64

Sample from Gaussian(0, scale) using the Box-Muller transform.

Draws two uniform samples u1, u2 ∈ (0,1), then: z = sqrt(-2 * ln(u1)) * cos(2π * u2). If u1 ≤ 0, uses 1e-10 as a floor.

pub fn apply_mechanism( &mut self, query: &DpQuery, true_value: f64, ) -> Result<DpResult, DpError>

Answer a single differentially-private query.

1. Validates mechanism parameters.
2. Checks that the budget is not exhausted.
3. Generates calibrated noise.
4. Charges epsilon (and delta for Gaussian) to the budget.
5. Records the result in history and returns it.

pub fn apply_batch( &mut self, queries: &[(DpQuery, f64)], ) -> Vec<Result<DpResult, DpError>>

Answer a batch of queries, applying each in sequence.

Each result is Ok if the query succeeded, or Err if the budget was exhausted or parameters were invalid. Later queries in the batch see the already-reduced budget from earlier queries.

pub fn compose_sequential(results: &[DpResult]) -> f64

Sequential composition: total epsilon = sum of per-query privacy costs.

pub fn compose_advanced(results: &[DpResult], delta: f64) -> f64

Advanced composition theorem (Dwork et al. 2010).

For k independent (ε, 0)-DP mechanisms:

ε_total = sqrt(2k ln(1/δ)) * ε + k * ε * (exp(ε) - 1)

where ε is the maximum per-query cost and k is the number of queries. Returns the sequential bound when results is empty.

pub fn sensitivity_clip(values: &[f64], sensitivity: f64) -> Vec<f64>

Clip each value to the range [-sensitivity, sensitivity].

This enforces global sensitivity bounds before computing statistics.

pub fn budget_stats(&self) -> BudgetTracker

Return a clone of the current budget tracker.

pub fn history(&self) -> &VecDeque<DpResult>

Return a reference to the bounded query-result history.

pub fn budget_mut(&mut self) -> &mut BudgetTracker

Return a mutable reference to the budget tracker (for testing / integration).

pub fn reseed(&mut self, seed: u64)

Reset the PRNG to a known seed for reproducible testing.

pub fn clear_history(&mut self)

Clear the query history.