Struct opendp::core::Transformation

pub struct Transformation<DI: Domain, DO: Domain, MI: Metric, MO: Metric> {
    pub input_domain: DI,
    pub output_domain: DO,
    pub function: Function<DI, DO>,
    pub input_metric: MI,
    pub output_metric: MO,
    pub stability_map: StabilityMap<MI, MO>,
}

A data transformation with certain stability characteristics.

The trait bounds provided by the Rust type system guarantee that:

• input_domain and output_domain are valid domains
• input_metric and output_metric are valid metrics

It is, however, left to constructor functions to prove that:

• metrics are compatible with domains
• function is a mapping from the input domain to the output domain
• stability_map is a mapping from the input metric to the output metric

Fields

input_domain: DI

output_domain: DO

function: Function<DI, DO>

input_metric: MI

output_metric: MO

stability_map: StabilityMap<MI, MO>

Implementations

impl<DI: Domain, DO: Domain, MI: Metric, MO: Metric> Transformation<DI, DO, MI, MO>

pub fn new(
input_domain: DI,
output_domain: DO,
function: Function<DI, DO>,
input_metric: MI,
output_metric: MO,
stability_map: StabilityMap<MI, MO>
) -> Self

pub fn invoke(&self, arg: &DI::Carrier) -> Fallible<DO::Carrier>

pub fn map(&self, d_in: &MI::Distance) -> Fallible<MO::Distance>

pub fn check(&self, d_in: &MI::Distance, d_out: &MO::Distance) -> Fallible<bool>where
MO::Distance: TotalOrd,

impl<DI, DO, MI, MO> Transformation<DI, DO, MI, MO>where
DI: 'static + Domain,
DI::Carrier: 'static,
DO: 'static + Domain,
DO::Carrier: 'static,
MI: 'static + Metric,
MO: 'static + Metric,

pub fn into_poly(self) -> Transformation<DI, PolyDomain, MI, MO>

Converts this Transformation into one with polymorphic output. It’s not clear if we’ll need this, but it’s provided for symmetry with Measurement.

Trait Implementations

impl<DI: Clone + Domain, DO: Clone + Domain, MI: Clone + Metric, MO: Clone + Metric> Clone for Transformation<DI, DO, MI, MO>

fn clone(&self) -> Transformation<DI, DO, MI, MO>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<DI: 'static + Domain, DO: 'static + Domain, MI: 'static + Metric, MO: 'static + Metric> IntoAnyTransformationExt for Transformation<DI, DO, MI, MO>where
DI::Carrier: 'static,
DO::Carrier: 'static,
MI::Distance: 'static,
MO::Distance: 'static,

fn into_any(self) -> Transformation<AnyDomain, AnyDomain, AnyMetric, AnyMetric>

impl<DI, DX, DO, MI, MX, MO> Shr<Measurement<DX, DO, MX, MO>> for Transformation<DI, DX, MI, MX>where
DI: 'static + Domain,
DX: 'static + Domain,
DO: 'static + Domain,
MI: 'static + Metric,
MX: 'static + Metric,
MO: 'static + Measure,

type Output = Result<Measurement<DI, DO, MI, MO>, Error>

The resulting type after applying the >> operator.

fn shr(self, rhs: Measurement<DX, DO, MX, MO>) -> Self::Output

Performs the >> operation.

impl<DI, DX, DO, MMI, MMO, MTI, MTO> Shr<Transformation<DX, DO, MTI, MTO>> for Fallible<Measurement<DI, DX, MMI, MMO>>where
DI: 'static + Domain,
DX: 'static + Domain,
DO: 'static + Domain,
MMI: 'static + Metric,
MMO: 'static + Measure,
MTI: 'static + Metric,
MTO: 'static + Metric,

type Output = Result<Measurement<DI, DO, MMI, MMO>, Error>

The resulting type after applying the >> operator.

fn shr(self, rhs: Transformation<DX, DO, MTI, MTO>) -> Self::Output

Performs the >> operation.

impl<DI, DX, DO, MMI, MMO, MTI, MTO> Shr<Transformation<DX, DO, MTI, MTO>> for Measurement<DI, DX, MMI, MMO>where
DI: 'static + Domain,
DX: 'static + Domain,
DO: 'static + Domain,
MMI: 'static + Metric,
MMO: 'static + Measure,
MTI: 'static + Metric,
MTO: 'static + Metric,

type Output = Result<Measurement<DI, DO, MMI, MMO>, Error>

The resulting type after applying the >> operator.

fn shr(self, rhs: Transformation<DX, DO, MTI, MTO>) -> Self::Output

Performs the >> operation.

impl<DI, DX, DO, MI, MX, MO> Shr<Transformation<DX, DO, MX, MO>> for Fallible<Transformation<DI, DX, MI, MX>>where
DI: 'static + Domain,
DX: 'static + Domain,
DO: 'static + Domain,
MI: 'static + Metric,
MX: 'static + Metric,
MO: 'static + Metric,

type Output = Result<Transformation<DI, DO, MI, MO>, Error>

The resulting type after applying the >> operator.

fn shr(self, rhs: Transformation<DX, DO, MX, MO>) -> Self::Output

Performs the >> operation.

impl<DI, DX, DO, MI, MX, MO> Shr<Transformation<DX, DO, MX, MO>> for Transformation<DI, DX, MI, MX>where
DI: 'static + Domain,
DX: 'static + Domain,
DO: 'static + Domain,
MI: 'static + Metric,
MX: 'static + Metric,
MO: 'static + Metric,

type Output = Result<Transformation<DI, DO, MI, MO>, Error>

The resulting type after applying the >> operator.

fn shr(self, rhs: Transformation<DX, DO, MX, MO>) -> Self::Output

Performs the >> operation.