Struct AtomDomain

pub struct AtomDomain<T: CheckAtom> {
    pub bounds: Option<Bounds<T>>,
    nullable: bool,
}

Proof Definition

AtomDomain(T) is the domain of all values of an atomic type T. If bounds are set, then the domain is restricted to the bounds. If nullable is set, then null value(s) are included in the domain.

Notes

If nullable is set, a domain may have multiple possible null values, like in the case of floating-point numbers, which have ~2^MANTISSA_BITS null values.

Because domains are defined in terms of a union, null values need a conceptual definition of equality to uniquely identify them in a set. In order to construct a well-defined set of members in the domain, we consider null values to have the same identity if their bit representation is equal.

Example

// Create a domain that includes all values `{0, 1, ..., 2^32 - 1}`.
use opendp::domains::AtomDomain;
let i32_domain = AtomDomain::<i32>::default();

// 1 is a member of the i32_domain
use opendp::core::Domain;
assert!(i32_domain.member(&1)?);

// Create a domain that includes all non-null 32-bit floats.
let f32_domain = AtomDomain::<f32>::default();

// 1. is a member of the f32_domain
assert!(f32_domain.member(&1.)?);
// NAN is not a member of the f32_domain
assert!(!f32_domain.member(&f32::NAN)?);

Null Example

use opendp::domains::{Null, AtomDomain};
let all_domain = AtomDomain::default();
let null_domain = AtomDomain::new_nullable();

use opendp::core::Domain;
// f64 NAN is not a member of all_domain, but is a member of null_domain
assert!(!all_domain.member(&f64::NAN)?);
assert!(null_domain.member(&f64::NAN)?);

Fields

bounds: Option<Bounds<T>>

nullable: bool

Implementations

impl<T: CheckAtom> AtomDomain<T>

pub fn new(bounds: Option<Bounds<T>>, nullable: Option<Null<T>>) -> Self

pub fn nullable(&self) -> bool

pub fn assert_non_null(&self) -> Fallible<()>

pub fn bounds(&self) -> Option<&Bounds<T>>

impl<T: CheckAtom + InherentNull> AtomDomain<T>

pub fn new_nullable() -> Self

impl<T: CheckAtom + ProductOrd + Debug> AtomDomain<T>

pub fn new_closed(bounds: (T, T)) -> Fallible<Self>

pub fn get_closed_bounds(&self) -> Fallible<(T, T)>

Trait Implementations

impl<T: Clone + CheckAtom> Clone for AtomDomain<T>

fn clone(&self) -> AtomDomain<T>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T: CheckAtom> Debug for AtomDomain<T>

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

Formats the value using the given formatter.

impl<T: CheckAtom> Default for AtomDomain<T>

fn default() -> Self

Returns the “default value” for a type.

impl<T: CheckAtom> Domain for AtomDomain<T>

type Carrier = T

The underlying type that the Domain specializes. This is the type of a member of a domain, where a domain is any data type that implements this trait.

fn member(&self, val: &Self::Carrier) -> Fallible<bool>

Predicate to test an element for membership in the domain. Not all possible values of ::Carrier are a member of the domain.

impl<T: CheckAtom + InherentNull + Clone> DropNullDomain for AtomDomain<T>

how to standardize into an option, when null represented as T with internal nullity

type Imputed = T

This is the type of Self::Carrier after dropping null.

fn option(value: &Self::Carrier) -> Option<T>

Standardizes D::Carrier into an Option<D::Imputed>, where D::Imputed is never null.

impl<QI: Number> GaussianDomain<ZeroConcentratedDivergence, QI> for AtomDomain<i128>

where f64: InfCast<QI>,

type InputMetric = AbsoluteDistance<QI>

fn make_gaussian( input_domain: Self, input_metric: Self::InputMetric, scale: f64, k: Option<i32>, ) -> Fallible<Measurement<Self, Self::Carrier, Self::InputMetric, ZeroConcentratedDivergence>>

impl<QI: Number> GaussianDomain<ZeroConcentratedDivergence, QI> for AtomDomain<i16>

where f64: InfCast<QI>,

type InputMetric = AbsoluteDistance<QI>

fn make_gaussian( input_domain: Self, input_metric: Self::InputMetric, scale: f64, k: Option<i32>, ) -> Fallible<Measurement<Self, Self::Carrier, Self::InputMetric, ZeroConcentratedDivergence>>

impl<QI: Number> GaussianDomain<ZeroConcentratedDivergence, QI> for AtomDomain<i32>

where f64: InfCast<QI>,

type InputMetric = AbsoluteDistance<QI>

fn make_gaussian( input_domain: Self, input_metric: Self::InputMetric, scale: f64, k: Option<i32>, ) -> Fallible<Measurement<Self, Self::Carrier, Self::InputMetric, ZeroConcentratedDivergence>>

impl<QI: Number> GaussianDomain<ZeroConcentratedDivergence, QI> for AtomDomain<i64>

where f64: InfCast<QI>,

type InputMetric = AbsoluteDistance<QI>

fn make_gaussian( input_domain: Self, input_metric: Self::InputMetric, scale: f64, k: Option<i32>, ) -> Fallible<Measurement<Self, Self::Carrier, Self::InputMetric, ZeroConcentratedDivergence>>

impl<QI: Number> GaussianDomain<ZeroConcentratedDivergence, QI> for AtomDomain<i8>

where f64: InfCast<QI>,

type InputMetric = AbsoluteDistance<QI>

fn make_gaussian( input_domain: Self, input_metric: Self::InputMetric, scale: f64, k: Option<i32>, ) -> Fallible<Measurement<Self, Self::Carrier, Self::InputMetric, ZeroConcentratedDivergence>>

impl<QI: Number> GaussianDomain<ZeroConcentratedDivergence, QI> for AtomDomain<isize>

where f64: InfCast<QI>,

type InputMetric = AbsoluteDistance<QI>

fn make_gaussian( input_domain: Self, input_metric: Self::InputMetric, scale: f64, k: Option<i32>, ) -> Fallible<Measurement<Self, Self::Carrier, Self::InputMetric, ZeroConcentratedDivergence>>

impl<QI: Number> GaussianDomain<ZeroConcentratedDivergence, QI> for AtomDomain<u128>

where f64: InfCast<QI>,

type InputMetric = AbsoluteDistance<QI>

fn make_gaussian( input_domain: Self, input_metric: Self::InputMetric, scale: f64, k: Option<i32>, ) -> Fallible<Measurement<Self, Self::Carrier, Self::InputMetric, ZeroConcentratedDivergence>>

impl<QI: Number> GaussianDomain<ZeroConcentratedDivergence, QI> for AtomDomain<u16>

where f64: InfCast<QI>,

type InputMetric = AbsoluteDistance<QI>

fn make_gaussian( input_domain: Self, input_metric: Self::InputMetric, scale: f64, k: Option<i32>, ) -> Fallible<Measurement<Self, Self::Carrier, Self::InputMetric, ZeroConcentratedDivergence>>

impl<QI: Number> GaussianDomain<ZeroConcentratedDivergence, QI> for AtomDomain<u32>

where f64: InfCast<QI>,

type InputMetric = AbsoluteDistance<QI>

fn make_gaussian( input_domain: Self, input_metric: Self::InputMetric, scale: f64, k: Option<i32>, ) -> Fallible<Measurement<Self, Self::Carrier, Self::InputMetric, ZeroConcentratedDivergence>>

impl<QI: Number> GaussianDomain<ZeroConcentratedDivergence, QI> for AtomDomain<u64>

where f64: InfCast<QI>,

type InputMetric = AbsoluteDistance<QI>

fn make_gaussian( input_domain: Self, input_metric: Self::InputMetric, scale: f64, k: Option<i32>, ) -> Fallible<Measurement<Self, Self::Carrier, Self::InputMetric, ZeroConcentratedDivergence>>

impl<QI: Number> GaussianDomain<ZeroConcentratedDivergence, QI> for AtomDomain<u8>

where f64: InfCast<QI>,

type InputMetric = AbsoluteDistance<QI>

fn make_gaussian( input_domain: Self, input_metric: Self::InputMetric, scale: f64, k: Option<i32>, ) -> Fallible<Measurement<Self, Self::Carrier, Self::InputMetric, ZeroConcentratedDivergence>>

impl<QI: Number> GaussianDomain<ZeroConcentratedDivergence, QI> for AtomDomain<usize>

where f64: InfCast<QI>,

type InputMetric = AbsoluteDistance<QI>

fn make_gaussian( input_domain: Self, input_metric: Self::InputMetric, scale: f64, k: Option<i32>, ) -> Fallible<Measurement<Self, Self::Carrier, Self::InputMetric, ZeroConcentratedDivergence>>

impl GaussianDomain<ZeroConcentratedDivergence, f32> for AtomDomain<f32>

type InputMetric = AbsoluteDistance<f32>

fn make_gaussian( input_domain: Self, input_metric: Self::InputMetric, scale: f64, k: Option<i32>, ) -> Fallible<Measurement<Self, Self::Carrier, Self::InputMetric, ZeroConcentratedDivergence>>

impl GaussianDomain<ZeroConcentratedDivergence, f64> for AtomDomain<f64>

type InputMetric = AbsoluteDistance<f64>

fn make_gaussian( input_domain: Self, input_metric: Self::InputMetric, scale: f64, k: Option<i32>, ) -> Fallible<Measurement<Self, Self::Carrier, Self::InputMetric, ZeroConcentratedDivergence>>

impl GeometricDomain for AtomDomain<i128>

fn make_geometric( input_domain: Self, input_metric: Self::InputMetric, scale: f64, bounds: Option<(<Self::InputMetric as Metric>::Distance, <Self::InputMetric as Metric>::Distance)>, ) -> Fallible<Measurement<Self, Self::Carrier, Self::InputMetric, MaxDivergence>>

impl GeometricDomain for AtomDomain<i16>

fn make_geometric( input_domain: Self, input_metric: Self::InputMetric, scale: f64, bounds: Option<(<Self::InputMetric as Metric>::Distance, <Self::InputMetric as Metric>::Distance)>, ) -> Fallible<Measurement<Self, Self::Carrier, Self::InputMetric, MaxDivergence>>

impl GeometricDomain for AtomDomain<i32>

fn make_geometric( input_domain: Self, input_metric: Self::InputMetric, scale: f64, bounds: Option<(<Self::InputMetric as Metric>::Distance, <Self::InputMetric as Metric>::Distance)>, ) -> Fallible<Measurement<Self, Self::Carrier, Self::InputMetric, MaxDivergence>>

impl GeometricDomain for AtomDomain<i64>

fn make_geometric( input_domain: Self, input_metric: Self::InputMetric, scale: f64, bounds: Option<(<Self::InputMetric as Metric>::Distance, <Self::InputMetric as Metric>::Distance)>, ) -> Fallible<Measurement<Self, Self::Carrier, Self::InputMetric, MaxDivergence>>

impl GeometricDomain for AtomDomain<i8>

fn make_geometric( input_domain: Self, input_metric: Self::InputMetric, scale: f64, bounds: Option<(<Self::InputMetric as Metric>::Distance, <Self::InputMetric as Metric>::Distance)>, ) -> Fallible<Measurement<Self, Self::Carrier, Self::InputMetric, MaxDivergence>>

impl GeometricDomain for AtomDomain<isize>

fn make_geometric( input_domain: Self, input_metric: Self::InputMetric, scale: f64, bounds: Option<(<Self::InputMetric as Metric>::Distance, <Self::InputMetric as Metric>::Distance)>, ) -> Fallible<Measurement<Self, Self::Carrier, Self::InputMetric, MaxDivergence>>

impl GeometricDomain for AtomDomain<u128>

fn make_geometric( input_domain: Self, input_metric: Self::InputMetric, scale: f64, bounds: Option<(<Self::InputMetric as Metric>::Distance, <Self::InputMetric as Metric>::Distance)>, ) -> Fallible<Measurement<Self, Self::Carrier, Self::InputMetric, MaxDivergence>>

impl GeometricDomain for AtomDomain<u16>

fn make_geometric( input_domain: Self, input_metric: Self::InputMetric, scale: f64, bounds: Option<(<Self::InputMetric as Metric>::Distance, <Self::InputMetric as Metric>::Distance)>, ) -> Fallible<Measurement<Self, Self::Carrier, Self::InputMetric, MaxDivergence>>

impl GeometricDomain for AtomDomain<u32>

fn make_geometric( input_domain: Self, input_metric: Self::InputMetric, scale: f64, bounds: Option<(<Self::InputMetric as Metric>::Distance, <Self::InputMetric as Metric>::Distance)>, ) -> Fallible<Measurement<Self, Self::Carrier, Self::InputMetric, MaxDivergence>>

impl GeometricDomain for AtomDomain<u64>

fn make_geometric( input_domain: Self, input_metric: Self::InputMetric, scale: f64, bounds: Option<(<Self::InputMetric as Metric>::Distance, <Self::InputMetric as Metric>::Distance)>, ) -> Fallible<Measurement<Self, Self::Carrier, Self::InputMetric, MaxDivergence>>

impl GeometricDomain for AtomDomain<u8>

fn make_geometric( input_domain: Self, input_metric: Self::InputMetric, scale: f64, bounds: Option<(<Self::InputMetric as Metric>::Distance, <Self::InputMetric as Metric>::Distance)>, ) -> Fallible<Measurement<Self, Self::Carrier, Self::InputMetric, MaxDivergence>>

impl GeometricDomain for AtomDomain<usize>

fn make_geometric( input_domain: Self, input_metric: Self::InputMetric, scale: f64, bounds: Option<(<Self::InputMetric as Metric>::Distance, <Self::InputMetric as Metric>::Distance)>, ) -> Fallible<Measurement<Self, Self::Carrier, Self::InputMetric, MaxDivergence>>

impl<T: CheckAtom + InherentNull> ImputeConstantDomain for AtomDomain<T>

type Imputed = <AtomDomain<T> as Domain>::Carrier

This is the type of Self::Carrier after imputation.

fn impute_constant<'a>( default: &'a Self::Carrier, constant: &'a Self::Imputed, ) -> &'a Self::Imputed

A function that replaces a potentially-null carrier type with a non-null imputed type.

impl LaplaceDomain for AtomDomain<f32>

type InputMetric = AbsoluteDistance<f32>

fn make_laplace( input_domain: Self, input_metric: Self::InputMetric, scale: f64, k: Option<i32>, ) -> Fallible<Measurement<Self, Self::Carrier, Self::InputMetric, MaxDivergence>>

impl LaplaceDomain for AtomDomain<f64>

type InputMetric = AbsoluteDistance<f64>

fn make_laplace( input_domain: Self, input_metric: Self::InputMetric, scale: f64, k: Option<i32>, ) -> Fallible<Measurement<Self, Self::Carrier, Self::InputMetric, MaxDivergence>>

impl LaplaceDomain for AtomDomain<i128>

type InputMetric = AbsoluteDistance<i128>

fn make_laplace( input_domain: Self, input_metric: Self::InputMetric, scale: f64, k: Option<i32>, ) -> Fallible<Measurement<Self, Self::Carrier, Self::InputMetric, MaxDivergence>>

impl LaplaceDomain for AtomDomain<i16>

type InputMetric = AbsoluteDistance<i16>

fn make_laplace( input_domain: Self, input_metric: Self::InputMetric, scale: f64, k: Option<i32>, ) -> Fallible<Measurement<Self, Self::Carrier, Self::InputMetric, MaxDivergence>>

impl LaplaceDomain for AtomDomain<i32>

type InputMetric = AbsoluteDistance<i32>

fn make_laplace( input_domain: Self, input_metric: Self::InputMetric, scale: f64, k: Option<i32>, ) -> Fallible<Measurement<Self, Self::Carrier, Self::InputMetric, MaxDivergence>>

impl LaplaceDomain for AtomDomain<i64>

type InputMetric = AbsoluteDistance<i64>

fn make_laplace( input_domain: Self, input_metric: Self::InputMetric, scale: f64, k: Option<i32>, ) -> Fallible<Measurement<Self, Self::Carrier, Self::InputMetric, MaxDivergence>>

impl LaplaceDomain for AtomDomain<i8>

type InputMetric = AbsoluteDistance<i8>

fn make_laplace( input_domain: Self, input_metric: Self::InputMetric, scale: f64, k: Option<i32>, ) -> Fallible<Measurement<Self, Self::Carrier, Self::InputMetric, MaxDivergence>>

impl LaplaceDomain for AtomDomain<isize>

type InputMetric = AbsoluteDistance<isize>

fn make_laplace( input_domain: Self, input_metric: Self::InputMetric, scale: f64, k: Option<i32>, ) -> Fallible<Measurement<Self, Self::Carrier, Self::InputMetric, MaxDivergence>>

impl LaplaceDomain for AtomDomain<u128>

type InputMetric = AbsoluteDistance<u128>

fn make_laplace( input_domain: Self, input_metric: Self::InputMetric, scale: f64, k: Option<i32>, ) -> Fallible<Measurement<Self, Self::Carrier, Self::InputMetric, MaxDivergence>>

impl LaplaceDomain for AtomDomain<u16>

type InputMetric = AbsoluteDistance<u16>

fn make_laplace( input_domain: Self, input_metric: Self::InputMetric, scale: f64, k: Option<i32>, ) -> Fallible<Measurement<Self, Self::Carrier, Self::InputMetric, MaxDivergence>>

impl LaplaceDomain for AtomDomain<u32>

type InputMetric = AbsoluteDistance<u32>

fn make_laplace( input_domain: Self, input_metric: Self::InputMetric, scale: f64, k: Option<i32>, ) -> Fallible<Measurement<Self, Self::Carrier, Self::InputMetric, MaxDivergence>>

impl LaplaceDomain for AtomDomain<u64>

type InputMetric = AbsoluteDistance<u64>

fn make_laplace( input_domain: Self, input_metric: Self::InputMetric, scale: f64, k: Option<i32>, ) -> Fallible<Measurement<Self, Self::Carrier, Self::InputMetric, MaxDivergence>>

impl LaplaceDomain for AtomDomain<u8>

type InputMetric = AbsoluteDistance<u8>

fn make_laplace( input_domain: Self, input_metric: Self::InputMetric, scale: f64, k: Option<i32>, ) -> Fallible<Measurement<Self, Self::Carrier, Self::InputMetric, MaxDivergence>>

impl LaplaceDomain for AtomDomain<usize>

type InputMetric = AbsoluteDistance<usize>

fn make_laplace( input_domain: Self, input_metric: Self::InputMetric, scale: f64, k: Option<i32>, ) -> Fallible<Measurement<Self, Self::Carrier, Self::InputMetric, MaxDivergence>>

impl<T> LipschitzMulFloatDomain for AtomDomain<T>

where T: 'static + Float,

type Atom = T

fn transform(constant: &T, (lower, upper): &(T, T), v: &T) -> Fallible<T>

impl<T: PartialEq + CheckAtom> PartialEq for AtomDomain<T>

fn eq(&self, other: &AtomDomain<T>) -> 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.

impl<T: CheckAtom + PrimitiveDataType> SeriesElementDomain for AtomDomain<T>

const NULLABLE: bool = false

Proof Definition

type InnerDomain = AtomDomain<T>

fn dtype(&self) -> DataType

Proof Definition

fn inner_domain(&self) -> &Self

Proof Definition

impl<T: CheckAtom> StructuralPartialEq for AtomDomain<T>