Struct Transformation

pub struct Transformation<DI: Domain, DO: Domain, MI: Metric, MO: Metric> {
    pub input_domain: DI,
    pub output_domain: DO,
    pub function: Function<DI::Carrier, DO::Carrier>,
    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::Carrier, DO::Carrier>

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>

where (DI, MI): MetricSpace, (DO, MO): MetricSpace,

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

pub(crate) fn with_map<MI2: Metric, MO2: Metric>( &self, input_metric: MI2, output_metric: MO2, privacy_map: StabilityMap<MI2, MO2>, ) -> Fallible<Transformation<DI, DO, MI2, MO2>>

where (DI, MI2): MetricSpace, (DO, MO2): MetricSpace,

pub fn input_space(&self) -> (DI, MI)

pub fn output_space(&self) -> (DO, MO)

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

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: ProductOrd,

Trait Implementations

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

where DI::Carrier: Clone, DO::Carrier: Clone,

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: Domain, DO: Domain, MI: Metric, MO: Metric> Debug for Transformation<DI, DO, MI, MO>

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

Formats the value using the given formatter.

impl<DI, DX, TO, MI, MX, MO> Shr<Measurement<DX, TO, MX, MO>> for Transformation<DI, DX, MI, MX>

where DI: 'static + Domain, DX: 'static + Domain, TO: 'static, MI: 'static + Metric, MX: 'static + Metric, MO: 'static + Measure, (DI, MI): MetricSpace, (DX, MX): MetricSpace,

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

The resulting type after applying the >> operator.

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

Performs the >> operation.

impl<DI, DX, DO, MI, MO, MTI, MTO> Shr<Transformation<DX, DO, MTI, MTO>> for Measurement<DI, DX::Carrier, MI, MO>

where DI: 'static + Domain, DX: 'static + Domain, DO: 'static + Domain, MI: 'static + Metric, MO: 'static + Measure, MTI: 'static + Metric, MTO: 'static + Metric, (DI, MI): MetricSpace, (DX, MTI): MetricSpace, (DO, MTO): MetricSpace,

type Output = Result<Measurement<DI, <DO as Domain>::Carrier, MI, MO>, 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, MO, MTI, MTO> Shr<Transformation<DX, DO, MTI, MTO>> for Fallible<Measurement<DI, DX::Carrier, MI, MO>>

where DI: 'static + Domain, DX: 'static + Domain, DO: 'static + Domain, MI: 'static + Metric, MO: 'static + Measure, MTI: 'static + Metric, MTO: 'static + Metric, (DI, MI): MetricSpace, (DX, MTI): MetricSpace, (DO, MTO): MetricSpace,

type Output = Result<Measurement<DI, <DO as Domain>::Carrier, MI, MO>, 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, (DI, MI): MetricSpace, (DX, MX): MetricSpace, (DO, MO): MetricSpace,

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, (DI, MI): MetricSpace, (DX, MX): MetricSpace, (DO, MO): MetricSpace,

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.