Struct opendp::domains::VectorDomain

pub struct VectorDomain<D: Domain> {
    pub element_domain: D,
    pub size: Option<usize>,
}

A Domain that contains vectors of (homogeneous) values.

Proof Definition

VectorDomain(inner_domain, D, Option<size>) is the domain of all vectors of elements drawn from domain inner_domain. If size is specified, then the domain is further restricted to all vectors of the given size.

Example

use opendp::domains::{VectorDomain, AtomDomain};
use opendp::core::Domain;

// Represents the domain of vectors.
let vec_domain = VectorDomain::new(AtomDomain::default());
assert!(vec_domain.member(&vec![1, 2, 3])?);

// Represents the domain of all vectors of bounded elements.
let bounded_domain = VectorDomain::new(AtomDomain::new_closed((-10, 10))?);

// vec![0] is a member, but vec![12] is not, because 12 is out of bounds of the inner domain
assert!(bounded_domain.member(&vec![0])?);
assert!(!bounded_domain.member(&vec![12])?);

Size Example

use opendp::domains::{VectorDomain, AtomDomain};
// Create a domain that includes all i32 vectors of length 3.
let sized_domain = VectorDomain::new(AtomDomain::<i32>::default()).with_size(3);

// vec![1, 2, 3] is a member of the sized_domain
use opendp::core::Domain;
assert!(sized_domain.member(&vec![1, 2, 3])?);

// vec![1, 2] is not a member of the sized_domain
assert!(!sized_domain.member(&vec![1, 2])?);

Fields

element_domain: D

size: Option<usize>

Implementations

impl<D: Domain> VectorDomain<D>

pub fn new(element_domain: D) -> Self

pub fn with_size(self, size: usize) -> Self

pub fn without_size(self) -> Self

Trait Implementations

impl<D: Clone + Domain> Clone for VectorDomain<D>

fn clone(&self) -> VectorDomain<D>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<D: Domain> Debug for VectorDomain<D>

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

Formats the value using the given formatter.

impl<D: Domain + Default> Default for VectorDomain<D>

fn default() -> Self

Returns the “default value” for a type.

impl<D: Domain> Domain for VectorDomain<D>

type Carrier = Vec<<D as Domain>::Carrier, Global>

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<D: Domain> IsSizedDomain for VectorDomain<D>

fn get_size(&self) -> Fallible<usize>

impl<D: LipschitzMulFloatDomain> LipschitzMulFloatDomain for VectorDomain<D>where D::Atom: Copy + SaturatingMul + CheckNull + TotalOrd,

type Atom = <D as LipschitzMulFloatDomain>::Atom

fn transform( constant: &D::Atom, bounds: &(Self::Atom, Self::Atom), v: &Vec<D::Carrier> ) -> Fallible<Vec<D::Carrier>>

impl<D: PartialEq + Domain> PartialEq<VectorDomain<D>> for VectorDomain<D>

fn eq(&self, other: &VectorDomain<D>) -> 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<D: Domain> StructuralPartialEq for VectorDomain<D>