Struct opendp::domains::AtomDomain

pub struct AtomDomain<T: CheckAtom> {
    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

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

pub fn new_nullable() -> Self

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

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

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<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<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<AtomDomain<T>> for AtomDomain<T>

fn eq(&self, other: &AtomDomain<T>) -> bool

This method tests for self and other values to be equal, and is used by ==.

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

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

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