opendp.transformations module

opendp.transformations.choose_branching_factor(size_guess)

Returns an approximation to the ideal branching_factor for a dataset of a given size, that minimizes error in cdf and quantile estimates based on b-ary trees.

choose_branching_factor in Rust documentation.

Citations:

• QYL13 Understanding Hierarchical Methods for Differentially Private Histograms

Parameters:

size_guess (int) – A guess at the size of your dataset.

Return type:

int

Raises:

• TypeError – if an argument’s type differs from the expected type

• UnknownTypeError – if a type argument fails to parse

opendp.transformations.make_b_ary_tree(input_domain, input_metric, leaf_count, branching_factor)

Expand a vector of counts into a b-ary tree of counts, where each branch is the sum of its b immediate children.

make_b_ary_tree in Rust documentation.

Supporting Elements:

• Input Domain: VectorDomain<AtomDomain<TA>>

• Output Domain: VectorDomain<AtomDomain<TA>>

• Input Metric: M

• Output Metric: M

Parameters:

• input_domain –

• input_metric –

• leaf_count (int) – The number of leaf nodes in the b-ary tree.

• branching_factor (int) – The number of children on each branch of the resulting tree. Larger branching factors result in shallower trees.

Return type:

Transformation

Raises:

• TypeError – if an argument’s type differs from the expected type

• UnknownTypeError – if a type argument fails to parse

• OpenDPException – packaged error from the core OpenDP library

opendp.transformations.make_bounded_float_checked_sum(size_limit, bounds, S='Pairwise<T>')

Make a Transformation that computes the sum of bounded data with known dataset size.

This uses a restricted-sensitivity proof that takes advantage of known dataset size for better utility. Use make_clamp to bound data and make_resize to establish dataset size.

S (summation algorithm)	input type
Sequential<S::Item>	Vec<S::Item>
Pairwise<S::Item>	Vec<S::Item>

S::Item is the type of all of the following: each bound, each element in the input data, the output data, and the output sensitivity.

For example, to construct a transformation that pairwise-sums f32 half-precision floats, set S to Pairwise<f32>.

make_bounded_float_checked_sum in Rust documentation.

Citations:

• CSVW22 Widespread Underestimation of Sensitivity…

• DMNS06 Calibrating Noise to Sensitivity in Private Data Analysis

Supporting Elements:

• Input Domain: VectorDomain<AtomDomain<S::Item>>

• Output Domain: AtomDomain<S::Item>

• Input Metric: SymmetricDistance

• Output Metric: AbsoluteDistance<S::Item>

Parameters:

• size_limit (int) – Upper bound on number of records to keep in the input data.

• bounds (Tuple[Any, Any]) – Tuple of lower and upper bounds for data in the input domain.

• S (Type Argument) – Summation algorithm to use over some data type T (T is shorthand for S::Item)

Return type:

Transformation

Raises:

• TypeError – if an argument’s type differs from the expected type

• UnknownTypeError – if a type argument fails to parse

• OpenDPException – packaged error from the core OpenDP library

opendp.transformations.make_bounded_float_ordered_sum(size_limit, bounds, S='Pairwise<T>')

Make a Transformation that computes the sum of bounded floats with known ordering.

Only useful when make_bounded_float_checked_sum returns an error due to potential for overflow. You may need to use make_ordered_random to impose an ordering on the data. The utility loss from overestimating the size_limit is small.

S (summation algorithm)	input type
Sequential<S::Item>	Vec<S::Item>
Pairwise<S::Item>	Vec<S::Item>

S::Item is the type of all of the following: each bound, each element in the input data, the output data, and the output sensitivity.

For example, to construct a transformation that pairwise-sums f32 half-precision floats, set S to Pairwise<f32>.

make_bounded_float_ordered_sum in Rust documentation.

Citations:

• CSVW22 Widespread Underestimation of Sensitivity…

• DMNS06 Calibrating Noise to Sensitivity in Private Data Analysis

Supporting Elements:

• Input Domain: VectorDomain<AtomDomain<S::Item>>

• Output Domain: AtomDomain<S::Item>

• Input Metric: InsertDeleteDistance

• Output Metric: AbsoluteDistance<S::Item>

Parameters:

• size_limit (int) – Upper bound on the number of records in input data. Used to bound sensitivity.

• bounds (Tuple[Any, Any]) – Tuple of lower and upper bounds for data in the input domain.

• S (Type Argument) – Summation algorithm to use over some data type T (T is shorthand for S::Item)

Return type:

Transformation

Raises:

• TypeError – if an argument’s type differs from the expected type

• UnknownTypeError – if a type argument fails to parse

• OpenDPException – packaged error from the core OpenDP library

opendp.transformations.make_bounded_int_monotonic_sum(bounds, T=None)

Make a Transformation that computes the sum of bounded ints, where all values share the same sign.

make_bounded_int_monotonic_sum in Rust documentation.

Citations:

• CSVW22 Widespread Underestimation of Sensitivity…

• DMNS06 Calibrating Noise to Sensitivity in Private Data Analysis

Supporting Elements:

• Input Domain: VectorDomain<AtomDomain<T>>

• Output Domain: AtomDomain<T>

• Input Metric: SymmetricDistance

• Output Metric: AbsoluteDistance<T>

Parameters:

• bounds (Tuple[Any, Any]) – Tuple of lower and upper bounds for data in the input domain.

• T (Type Argument) – Atomic Input Type and Output Type

Return type:

Transformation

Raises:

• TypeError – if an argument’s type differs from the expected type

• UnknownTypeError – if a type argument fails to parse

• OpenDPException – packaged error from the core OpenDP library

opendp.transformations.make_bounded_int_ordered_sum(bounds, T=None)

Make a Transformation that computes the sum of bounded ints. You may need to use make_ordered_random to impose an ordering on the data.

make_bounded_int_ordered_sum in Rust documentation.

Citations:

• CSVW22 Widespread Underestimation of Sensitivity…

• DMNS06 Calibrating Noise to Sensitivity in Private Data Analysis

Supporting Elements:

• Input Domain: VectorDomain<AtomDomain<T>>

• Output Domain: AtomDomain<T>

• Input Metric: InsertDeleteDistance

• Output Metric: AbsoluteDistance<T>

Parameters:

• bounds (Tuple[Any, Any]) – Tuple of lower and upper bounds for data in the input domain.

• T (Type Argument) – Atomic Input Type and Output Type

Return type:

Transformation

Raises:

• TypeError – if an argument’s type differs from the expected type

• UnknownTypeError – if a type argument fails to parse

• OpenDPException – packaged error from the core OpenDP library

opendp.transformations.make_bounded_int_split_sum(bounds, T=None)

Make a Transformation that computes the sum of bounded ints. Adds the saturating sum of the positives to the saturating sum of the negatives.

make_bounded_int_split_sum in Rust documentation.

Citations:

• CSVW22 Widespread Underestimation of Sensitivity…

• DMNS06 Calibrating Noise to Sensitivity in Private Data Analysis

Supporting Elements:

• Input Domain: VectorDomain<AtomDomain<T>>

• Output Domain: AtomDomain<T>

• Input Metric: SymmetricDistance

• Output Metric: AbsoluteDistance<T>

Parameters:

• bounds (Tuple[Any, Any]) – Tuple of lower and upper bounds for data in the input domain.

• T (Type Argument) – Atomic Input Type and Output Type

Return type:

Transformation

Raises:

• TypeError – if an argument’s type differs from the expected type

• UnknownTypeError – if a type argument fails to parse

• OpenDPException – packaged error from the core OpenDP library

opendp.transformations.make_cast(input_domain, input_metric, TOA)

Make a Transformation that casts a vector of data from type TIA to type TOA. For each element, failure to parse results in None, else Some(out).

Can be chained with make_impute_constant or make_drop_null to handle nullity.

make_cast in Rust documentation.

Supporting Elements:

• Input Domain: VectorDomain<AtomDomain<TIA>>

• Output Domain: VectorDomain<OptionDomain<AtomDomain<TOA>>>

• Input Metric: M

• Output Metric: M

Parameters:

• input_domain –

• input_metric –

• TOA (Type Argument) – Atomic Output Type to cast into

Return type:

Transformation

Raises:

• TypeError – if an argument’s type differs from the expected type

• UnknownTypeError – if a type argument fails to parse

• OpenDPException – packaged error from the core OpenDP library

opendp.transformations.make_cast_default(input_domain, input_metric, TOA)

Make a Transformation that casts a vector of data from type TIA to type TOA. Any element that fails to cast is filled with default.

TIA	TIA::default()
float	0.
int	0
string	""
bool	false

make_cast_default in Rust documentation.

Supporting Elements:

• Input Domain: VectorDomain<AtomDomain<TIA>>

• Output Domain: VectorDomain<AtomDomain<TOA>>

• Input Metric: M

• Output Metric: M

Parameters:

• input_domain –

• input_metric –

• TOA (Type Argument) – Atomic Output Type to cast into

Return type:

Transformation

Raises:

• TypeError – if an argument’s type differs from the expected type

• UnknownTypeError – if a type argument fails to parse

• OpenDPException – packaged error from the core OpenDP library

opendp.transformations.make_cast_inherent(input_domain, input_metric, TOA)

Make a Transformation that casts a vector of data from type TIA to a type that can represent nullity TOA. If cast fails, fill with TOA’s null value.

TIA	TIA::default()
float	NaN

make_cast_inherent in Rust documentation.

Supporting Elements:

• Input Domain: VectorDomain<AtomDomain<TIA>>

• Output Domain: VectorDomain<AtomDomain<TOA>>

• Input Metric: M

• Output Metric: M

Parameters:

• input_domain –

• input_metric –

• TOA (Type Argument) – Atomic Output Type to cast into

Return type:

Transformation

Raises:

• TypeError – if an argument’s type differs from the expected type

• UnknownTypeError – if a type argument fails to parse

• OpenDPException – packaged error from the core OpenDP library

opendp.transformations.make_cdf(TA='float')

Postprocess a noisy array of float summary counts into a cumulative distribution.

make_cdf in Rust documentation.

Supporting Elements:

• Input Type: Vec<TA>

• Output Type: Vec<TA>

Parameters:

TA (Type Argument) – Atomic Type. One of f32 or f64

Return type:

Function

Raises:

• TypeError – if an argument’s type differs from the expected type

• UnknownTypeError – if a type argument fails to parse

• OpenDPException – packaged error from the core OpenDP library

opendp.transformations.make_clamp(input_domain, input_metric, bounds)

Make a Transformation that clamps numeric data in Vec<TA> to bounds.

If datum is less than lower, let datum be lower. If datum is greater than upper, let datum be upper.

make_clamp in Rust documentation.

Supporting Elements:

• Input Domain: VectorDomain<AtomDomain<TA>>

• Output Domain: VectorDomain<AtomDomain<TA>>

• Input Metric: M

• Output Metric: M

Proof Definition:

(Proof Document)

Parameters:

• input_domain (Domain) – Domain of input data.

• input_metric (Metric) – Metric on input domain.

• bounds (Tuple[Any, Any]) – Tuple of inclusive lower and upper bounds.

Return type:

Transformation

Raises:

• TypeError – if an argument’s type differs from the expected type

• UnknownTypeError – if a type argument fails to parse

• OpenDPException – packaged error from the core OpenDP library

opendp.transformations.make_consistent_b_ary_tree(branching_factor, TIA='int', TOA='float')

Postprocessor that makes a noisy b-ary tree internally consistent, and returns the leaf layer.

The input argument of the function is a balanced b-ary tree implicitly stored in breadth-first order Tree is assumed to be complete, as in, all leaves on the last layer are on the left. Non-existent leaves are assumed to be zero.

The output remains consistent even when leaf nodes are missing. This is due to an adjustment to the original algorithm to apportion corrections to children relative to their variance.

make_consistent_b_ary_tree in Rust documentation.

Citations:

• HRMS09 Boosting the Accuracy of Differentially Private Histograms Through Consistency, section 4.1

Supporting Elements:

• Input Type: Vec<TIA>

• Output Type: Vec<TOA>

Parameters:

• branching_factor (int) – the maximum number of children

• TIA (Type Argument) – Atomic type of the input data. Should be an integer type.

• TOA (Type Argument) – Atomic type of the output data. Should be a float type.

Return type:

Function

Raises:

• TypeError – if an argument’s type differs from the expected type

• UnknownTypeError – if a type argument fails to parse

• OpenDPException – packaged error from the core OpenDP library

opendp.transformations.make_count(input_domain, input_metric, TO='int')

Make a Transformation that computes a count of the number of records in data.

make_count in Rust documentation.

Citations:

• GRS12 Universally Utility-Maximizing Privacy Mechanisms

Supporting Elements:

• Input Domain: VectorDomain<AtomDomain<TIA>>

• Output Domain: AtomDomain<TO>

• Input Metric: SymmetricDistance

• Output Metric: AbsoluteDistance<TO>

Proof Definition:

(Proof Document)

Parameters:

• input_domain – Domain of the data type to be privatized.

• input_metric – Metric of the data type to be privatized.

• TO (Type Argument) – Output Type. Must be numeric.

Return type:

Transformation

Raises:

• TypeError – if an argument’s type differs from the expected type

• UnknownTypeError – if a type argument fails to parse

• OpenDPException – packaged error from the core OpenDP library

opendp.transformations.make_count_by(input_domain, input_metric, MO, TV='int')

Make a Transformation that computes the count of each unique value in data. This assumes that the category set is unknown.

make_count_by in Rust documentation.

Citations:

• BV17 Differential Privacy on Finite Computers

Supporting Elements:

• Input Domain: VectorDomain<AtomDomain<TK>>

• Output Domain: MapDomain<AtomDomain<TK>, AtomDomain<TV>>

• Input Metric: SymmetricDistance

• Output Metric: MO

Parameters:

• input_domain –

• input_metric –

• MO (SensitivityMetric) – Output Metric.

• TV (Type Argument) – Type of Value. Express counts in terms of this integral type.

Returns:

The carrier type is HashMap<TK, TV>, a hashmap of the count (TV) for each unique data input (TK).

Return type:

Transformation

Raises:

• TypeError – if an argument’s type differs from the expected type

• UnknownTypeError – if a type argument fails to parse

• OpenDPException – packaged error from the core OpenDP library

opendp.transformations.make_count_by_categories(input_domain, input_metric, categories, null_category=True, MO='L1Distance<int>', TOA='int')

Make a Transformation that computes the number of times each category appears in the data. This assumes that the category set is known.

make_count_by_categories in Rust documentation.

Citations:

• GRS12 Universally Utility-Maximizing Privacy Mechanisms

• BV17 Differential Privacy on Finite Computers

Supporting Elements:

• Input Domain: VectorDomain<AtomDomain<TIA>>

• Output Domain: VectorDomain<AtomDomain<TOA>>

• Input Metric: SymmetricDistance

• Output Metric: MO

Parameters:

• input_domain –

• input_metric –

• categories (Any) – The set of categories to compute counts for.

• null_category (bool) – Include a count of the number of elements that were not in the category set at the end of the vector.

• MO (SensitivityMetric) – Output Metric.

• TOA (Type Argument) – Atomic Output Type that is numeric.

Returns:

The carrier type is Vec<TOA>, a vector of the counts (TOA).

Return type:

Transformation

Raises:

• TypeError – if an argument’s type differs from the expected type

• UnknownTypeError – if a type argument fails to parse

• OpenDPException – packaged error from the core OpenDP library

opendp.transformations.make_count_distinct(input_domain, input_metric, TO='int')

Make a Transformation that computes a count of the number of unique, distinct records in data.

make_count_distinct in Rust documentation.

Citations:

• GRS12 Universally Utility-Maximizing Privacy Mechanisms

Supporting Elements:

• Input Domain: VectorDomain<AtomDomain<TIA>>

• Output Domain: AtomDomain<TO>

• Input Metric: SymmetricDistance

• Output Metric: AbsoluteDistance<TO>

Parameters:

• input_domain –

• input_metric –

• TO (Type Argument) – Output Type. Must be numeric.

Return type:

Transformation

Raises:

• TypeError – if an argument’s type differs from the expected type

• UnknownTypeError – if a type argument fails to parse

• OpenDPException – packaged error from the core OpenDP library

opendp.transformations.make_create_dataframe(col_names, K=None)

Make a Transformation that constructs a dataframe from a Vec<Vec<String>> (a vector of records).

make_create_dataframe in Rust documentation.

Supporting Elements:

• Input Domain: VectorDomain<VectorDomain<AtomDomain<String>>>

• Output Domain: DataFrameDomain<K>

• Input Metric: SymmetricDistance

• Output Metric: SymmetricDistance

Parameters:

• col_names (Any) – Column names for each record entry.

• K (Type Argument) – categorical/hashable data type of column names

Return type:

Transformation

Raises:

• TypeError – if an argument’s type differs from the expected type

• UnknownTypeError – if a type argument fails to parse

• OpenDPException – packaged error from the core OpenDP library

opendp.transformations.make_df_cast_default(input_domain, input_metric, column_name, TIA, TOA)

Make a Transformation that casts the elements in a column in a dataframe from type TIA to type TOA. If cast fails, fill with default.

TIA	TIA::default()
float	0.
int	0
string	""
bool	false

make_df_cast_default in Rust documentation.

Supporting Elements:

• Input Domain: DataFrameDomain<TK>

• Output Domain: DataFrameDomain<TK>

• Input Metric: M

• Output Metric: M

Parameters:

• input_domain –

• input_metric –

• column_name (Any) – column name to be transformed

• TIA (Type Argument) – Atomic Input Type to cast from

• TOA (Type Argument) – Atomic Output Type to cast into

Return type:

Transformation

Raises:

• TypeError – if an argument’s type differs from the expected type

• UnknownTypeError – if a type argument fails to parse

• OpenDPException – packaged error from the core OpenDP library

opendp.transformations.make_df_is_equal(input_domain, input_metric, column_name, value, TIA=None)

Make a Transformation that checks if each element in a column in a dataframe is equivalent to value.

make_df_is_equal in Rust documentation.

Supporting Elements:

• Input Domain: DataFrameDomain<TK>

• Output Domain: DataFrameDomain<TK>

• Input Metric: M

• Output Metric: M

Parameters:

• input_domain –

• input_metric –

• column_name (Any) – Column name to be transformed

• value (Any) – Value to check for equality

• TIA (Type Argument) – Atomic Input Type to cast from

Return type:

Transformation

Raises:

• TypeError – if an argument’s type differs from the expected type

• UnknownTypeError – if a type argument fails to parse

• OpenDPException – packaged error from the core OpenDP library

opendp.transformations.make_drop_null(input_domain, input_metric)

Make a Transformation that drops null values.

input_domain
vector_domain(option_domain(atom_domain(TA)))
vector_domain(atom_domain(TA))

make_drop_null in Rust documentation.

Supporting Elements:

• Input Domain: VectorDomain<DIA>

• Output Domain: VectorDomain<AtomDomain<DIA::Imputed>>

• Input Metric: M

• Output Metric: M

Parameters:

• input_domain –

• input_metric –

Return type:

Transformation

Raises:

• TypeError – if an argument’s type differs from the expected type

• UnknownTypeError – if a type argument fails to parse

• OpenDPException – packaged error from the core OpenDP library

opendp.transformations.make_find(input_domain, input_metric, categories)

Find the index of a data value in a set of categories.

For each value in the input vector, finds the index of the value in categories. If an index is found, returns Some(index), else None. Chain with make_impute_constant or make_drop_null to handle nullity.

make_find in Rust documentation.

Supporting Elements:

• Input Domain: VectorDomain<AtomDomain<TIA>>

• Output Domain: VectorDomain<OptionDomain<AtomDomain<usize>>>

• Input Metric: M

• Output Metric: M

Parameters:

• input_domain – The domain of the input vector.

• input_metric – The metric of the input vector.

• categories (Any) – The set of categories to find indexes from.

Return type:

Transformation

Raises:

• TypeError – if an argument’s type differs from the expected type

• UnknownTypeError – if a type argument fails to parse

• OpenDPException – packaged error from the core OpenDP library

opendp.transformations.make_find_bin(input_domain, input_metric, edges)

Make a transformation that finds the bin index in a monotonically increasing vector of edges.

For each value in the input vector, finds the index of the bin the value falls into. edges splits the entire range of TIA into bins. The first bin at index zero ranges from negative infinity to the first edge, non-inclusive. The last bin at index edges.len() ranges from the last bin, inclusive, to positive infinity.

To be valid, edges must be unique and ordered. edges are left inclusive, right exclusive.

make_find_bin in Rust documentation.

Supporting Elements:

• Input Domain: VectorDomain<AtomDomain<TIA>>

• Output Domain: VectorDomain<AtomDomain<usize>>

• Input Metric: M

• Output Metric: M

Parameters:

• input_domain – The domain of the input vector.

• input_metric – The metric of the input vector.

• edges (Any) – The set of edges to split bins by.

Return type:

Transformation

Raises:

• TypeError – if an argument’s type differs from the expected type

• UnknownTypeError – if a type argument fails to parse

• OpenDPException – packaged error from the core OpenDP library

opendp.transformations.make_identity(domain, metric)

Make a Transformation representing the identity function.

WARNING: In Python, this function does not ensure that the domain and metric form a valid metric space. However, if the domain and metric do not form a valid metric space, then the resulting Transformation won’t be chainable with any valid Transformation, so it cannot be used to introduce an invalid metric space into a chain of valid Transformations.

make_identity in Rust documentation.

Supporting Elements:

• Input Domain: D

• Output Domain: D

• Input Metric: M

• Output Metric: M

Parameters:

• domain –

• metric –

Return type:

Transformation

Raises:

• TypeError – if an argument’s type differs from the expected type

• UnknownTypeError – if a type argument fails to parse

• OpenDPException – packaged error from the core OpenDP library

opendp.transformations.make_impute_constant(input_domain, input_metric, constant)

Make a Transformation that replaces null/None data with constant.

If chaining after a make_cast, the input type is Option<Vec<TA>>. If chaining after a make_cast_inherent, the input type is Vec<TA>, where TA may take on float NaNs.

input_domain	Input Data Type
vector_domain(option_domain(atom_domain(TA)))	Vec<Option<TA>>
vector_domain(atom_domain(TA))	Vec<TA>

make_impute_constant in Rust documentation.

Supporting Elements:

• Input Domain: VectorDomain<DIA>

• Output Domain: VectorDomain<AtomDomain<DIA::Imputed>>

• Input Metric: M

• Output Metric: M

Parameters:

• input_domain – Domain of the input data. See table above.

• input_metric – Metric of the input data. A dataset metric.

• constant (Any) – Value to replace nulls with.

Return type:

Transformation

Raises:

• TypeError – if an argument’s type differs from the expected type

• UnknownTypeError – if a type argument fails to parse

• OpenDPException – packaged error from the core OpenDP library

opendp.transformations.make_impute_uniform_float(input_domain, input_metric, bounds)

Make a Transformation that replaces NaN values in Vec<TA> with uniformly distributed floats within bounds.

make_impute_uniform_float in Rust documentation.

Supporting Elements:

• Input Domain: VectorDomain<AtomDomain<TA>>

• Output Domain: VectorDomain<AtomDomain<TA>>

• Input Metric: M

• Output Metric: M

Parameters:

• input_domain – Domain of the input.

• input_metric – Metric of the input.

• bounds (Tuple[Any, Any]) – Tuple of inclusive lower and upper bounds.

Return type:

Transformation

Raises:

• TypeError – if an argument’s type differs from the expected type

• UnknownTypeError – if a type argument fails to parse

• OpenDPException – packaged error from the core OpenDP library

opendp.transformations.make_index(input_domain, input_metric, categories, null, TOA=None)

Make a transformation that treats each element as an index into a vector of categories.

make_index in Rust documentation.

Supporting Elements:

• Input Domain: VectorDomain<AtomDomain<usize>>

• Output Domain: VectorDomain<AtomDomain<TOA>>

• Input Metric: M

• Output Metric: M

Parameters:

• input_domain – The domain of the input vector.

• input_metric – The metric of the input vector.

• categories (Any) – The set of categories to index into.

• null (Any) – Category to return if the index is out-of-range of the category set.

• TOA (Type Argument) – Atomic Output Type. Output data will be Vec<TOA>.

Return type:

Transformation

Raises:

• TypeError – if an argument’s type differs from the expected type

• UnknownTypeError – if a type argument fails to parse

• OpenDPException – packaged error from the core OpenDP library

opendp.transformations.make_is_equal(input_domain, input_metric, value)

Make a Transformation that checks if each element is equal to value.

make_is_equal in Rust documentation.

Supporting Elements:

• Input Domain: VectorDomain<AtomDomain<TIA>>

• Output Domain: VectorDomain<AtomDomain<bool>>

• Input Metric: M

• Output Metric: M

Parameters:

• input_domain –

• input_metric –

• value (Any) – value to check against

Return type:

Transformation

Raises:

• TypeError – if an argument’s type differs from the expected type

• UnknownTypeError – if a type argument fails to parse

• OpenDPException – packaged error from the core OpenDP library

opendp.transformations.make_is_null(input_domain, input_metric)

Make a Transformation that checks if each element in a vector is null.

make_is_null in Rust documentation.

Supporting Elements:

• Input Domain: VectorDomain<DIA>

• Output Domain: VectorDomain<AtomDomain<bool>>

• Input Metric: M

• Output Metric: M

Parameters:

• input_domain –

• input_metric –

Return type:

Transformation

Raises:

• TypeError – if an argument’s type differs from the expected type

• UnknownTypeError – if a type argument fails to parse

• OpenDPException – packaged error from the core OpenDP library

opendp.transformations.make_lipschitz_float_mul(constant, bounds, D='AtomDomain<T>', M='AbsoluteDistance<T>')

Make a transformation that multiplies an aggregate by a constant.

The bounds clamp the input, in order to bound the increase in sensitivity from float rounding.

make_lipschitz_float_mul in Rust documentation.

Supporting Elements:

• Input Domain: D

• Output Domain: D

• Input Metric: M

• Output Metric: M

Parameters:

• constant – The constant to multiply aggregates by.

• bounds (Tuple[Any, Any]) – Tuple of inclusive lower and upper bounds.

• D (Type Argument) – Domain of the function. Must be AtomDomain<T> or VectorDomain<AtomDomain<T>>

• M (Type Argument) – Metric. Must be AbsoluteDistance<T>, L1Distance<T> or L2Distance<T>

Return type:

Transformation

Raises:

• TypeError – if an argument’s type differs from the expected type

• UnknownTypeError – if a type argument fails to parse

• OpenDPException – packaged error from the core OpenDP library

opendp.transformations.make_mean(input_domain, input_metric)

Make a Transformation that computes the mean of bounded data.

This uses a restricted-sensitivity proof that takes advantage of known dataset size. Use make_clamp to bound data and make_resize to establish dataset size.

make_mean in Rust documentation.

Supporting Elements:

• Input Domain: VectorDomain<AtomDomain<T>>

• Output Domain: AtomDomain<T>

• Input Metric: MI

• Output Metric: AbsoluteDistance<T>

Parameters:

• input_domain –

• input_metric –

Return type:

Transformation

Raises:

• TypeError – if an argument’s type differs from the expected type

• UnknownTypeError – if a type argument fails to parse

• OpenDPException – packaged error from the core OpenDP library

opendp.transformations.make_metric_bounded(input_domain, input_metric)

Make a Transformation that converts the unbounded dataset metric MI to the respective bounded dataset metric with a no-op.

The constructor enforces that the input domain has known size, because it must have known size to be valid under a bounded dataset metric.

MI	MI::BoundedMetric
SymmetricDistance	ChangeOneDistance
InsertDeleteDistance	HammingDistance

make_metric_bounded in Rust documentation.

Supporting Elements:

• Input Domain: D

• Output Domain: D

• Input Metric: MI

• Output Metric: MI::BoundedMetric

Parameters:

• input_domain –

• input_metric –

Return type:

Transformation

Raises:

• TypeError – if an argument’s type differs from the expected type

• UnknownTypeError – if a type argument fails to parse

• OpenDPException – packaged error from the core OpenDP library

opendp.transformations.make_metric_unbounded(input_domain, input_metric)

Make a Transformation that converts the bounded dataset metric MI to the respective unbounded dataset metric with a no-op.

MI	MI::UnboundedMetric
ChangeOneDistance	SymmetricDistance
HammingDistance	InsertDeleteDistance

make_metric_unbounded in Rust documentation.

Supporting Elements:

• Input Domain: D

• Output Domain: D

• Input Metric: MI

• Output Metric: MI::UnboundedMetric

Parameters:

• input_domain –

• input_metric –

Return type:

Transformation

Raises:

• TypeError – if an argument’s type differs from the expected type

• UnknownTypeError – if a type argument fails to parse

• OpenDPException – packaged error from the core OpenDP library

opendp.transformations.make_ordered_random(input_domain, input_metric)

Make a Transformation that converts the unordered dataset metric SymmetricDistance to the respective ordered dataset metric InsertDeleteDistance by assigning a random permutation.

MI	MI::OrderedMetric
SymmetricDistance	InsertDeleteDistance
ChangeOneDistance	HammingDistance

make_ordered_random in Rust documentation.

Supporting Elements:

• Input Domain: D

• Output Domain: D

• Input Metric: MI

• Output Metric: MI::OrderedMetric

Parameters:

• input_domain –

• input_metric –

Return type:

Transformation

Raises:

• TypeError – if an argument’s type differs from the expected type

• UnknownTypeError – if a type argument fails to parse

• OpenDPException – packaged error from the core OpenDP library

opendp.transformations.make_quantiles_from_counts(bin_edges, alphas, interpolation='linear', TA=None, F='float')

Postprocess a noisy array of summary counts into quantiles.

make_quantiles_from_counts in Rust documentation.

Supporting Elements:

• Input Type: Vec<TA>

• Output Type: Vec<TA>

Parameters:

• bin_edges (Any) – The edges that the input data was binned into before counting.

• alphas (Any) – Return all specified alpha-quantiles.

• interpolation (str) – Must be one of linear or nearest

• TA (Type Argument) – Atomic Type of the bin edges and data.

• F (Type Argument) – Float type of the alpha argument. One of f32 or f64

Return type:

Function

Raises:

• TypeError – if an argument’s type differs from the expected type

• UnknownTypeError – if a type argument fails to parse

• OpenDPException – packaged error from the core OpenDP library

opendp.transformations.make_resize(input_domain, input_metric, size, constant, MO='SymmetricDistance')

Make a Transformation that either truncates or imputes records with constant to match a provided size.

make_resize in Rust documentation.

Supporting Elements:

• Input Domain: VectorDomain<AtomDomain<TA>>

• Output Domain: VectorDomain<AtomDomain<TA>>

• Input Metric: MI

• Output Metric: MO

Parameters:

• input_domain – Domain of input data.

• input_metric – Metric of input data.

• size (int) – Number of records in output data.

• constant (Any) – Value to impute with.

• MO (Type Argument) – Output Metric. One of InsertDeleteDistance or SymmetricDistance

Returns:

A vector of the same type TA, but with the provided size.

Return type:

Transformation

Raises:

• TypeError – if an argument’s type differs from the expected type

• UnknownTypeError – if a type argument fails to parse

• OpenDPException – packaged error from the core OpenDP library

opendp.transformations.make_select_column(key, TOA, K=None)

Make a Transformation that retrieves the column key from a dataframe as Vec<TOA>.

make_select_column in Rust documentation.

Supporting Elements:

• Input Domain: DataFrameDomain<K>

• Output Domain: VectorDomain<AtomDomain<TOA>>

• Input Metric: SymmetricDistance

• Output Metric: SymmetricDistance

Parameters:

• key (Any) – categorical/hashable data type of the key/column name

• K (Type Argument) – data type of key

• TOA (Type Argument) – Atomic Output Type to downcast vector to

Return type:

Transformation

Raises:

• TypeError – if an argument’s type differs from the expected type

• UnknownTypeError – if a type argument fails to parse

• OpenDPException – packaged error from the core OpenDP library

opendp.transformations.make_sized_bounded_float_checked_sum(size, bounds, S='Pairwise<T>')

Make a Transformation that computes the sum of bounded floats with known dataset size.

This uses a restricted-sensitivity proof that takes advantage of known dataset size for better utility.

S (summation algorithm)	input type
Sequential<S::Item>	Vec<S::Item>
Pairwise<S::Item>	Vec<S::Item>

S::Item is the type of all of the following: each bound, each element in the input data, the output data, and the output sensitivity.

For example, to construct a transformation that pairwise-sums f32 half-precision floats, set S to Pairwise<f32>.

make_sized_bounded_float_checked_sum in Rust documentation.

Citations:

• CSVW22 Widespread Underestimation of Sensitivity…

• DMNS06 Calibrating Noise to Sensitivity in Private Data Analysis

Supporting Elements:

• Input Domain: VectorDomain<AtomDomain<S::Item>>

• Output Domain: AtomDomain<S::Item>

• Input Metric: SymmetricDistance

• Output Metric: AbsoluteDistance<S::Item>

Parameters:

• size (int) – Number of records in input data.

• bounds (Tuple[Any, Any]) – Tuple of lower and upper bounds for data in the input domain.

• S (Type Argument) – Summation algorithm to use over some data type T (T is shorthand for S::Item)

Return type:

Transformation

Raises:

• TypeError – if an argument’s type differs from the expected type

• UnknownTypeError – if a type argument fails to parse

• OpenDPException – packaged error from the core OpenDP library

opendp.transformations.make_sized_bounded_float_ordered_sum(size, bounds, S='Pairwise<T>')

Make a Transformation that computes the sum of bounded floats with known ordering and dataset size.

Only useful when make_bounded_float_checked_sum returns an error due to potential for overflow. This uses a restricted-sensitivity proof that takes advantage of known dataset size for better utility. You may need to use make_ordered_random to impose an ordering on the data.

S (summation algorithm)	input type
Sequential<S::Item>	Vec<S::Item>
Pairwise<S::Item>	Vec<S::Item>

S::Item is the type of all of the following: each bound, each element in the input data, the output data, and the output sensitivity.

For example, to construct a transformation that pairwise-sums f32 half-precision floats, set S to Pairwise<f32>.

make_sized_bounded_float_ordered_sum in Rust documentation.

Citations:

• CSVW22 Widespread Underestimation of Sensitivity…

• DMNS06 Calibrating Noise to Sensitivity in Private Data Analysis

Supporting Elements:

• Input Domain: VectorDomain<AtomDomain<S::Item>>

• Output Domain: AtomDomain<S::Item>

• Input Metric: InsertDeleteDistance

• Output Metric: AbsoluteDistance<S::Item>

Parameters:

• size (int) – Number of records in input data.

• bounds (Tuple[Any, Any]) – Tuple of lower and upper bounds for data in the input domain.

• S (Type Argument) – Summation algorithm to use over some data type T (T is shorthand for S::Item)

Return type:

Transformation

Raises:

• TypeError – if an argument’s type differs from the expected type

• UnknownTypeError – if a type argument fails to parse

• OpenDPException – packaged error from the core OpenDP library

opendp.transformations.make_sized_bounded_int_checked_sum(size, bounds, T=None)

Make a Transformation that computes the sum of bounded ints. The effective range is reduced, as (bounds * size) must not overflow.

make_sized_bounded_int_checked_sum in Rust documentation.

Citations:

• CSVW22 Widespread Underestimation of Sensitivity…

• DMNS06 Calibrating Noise to Sensitivity in Private Data Analysis

Supporting Elements:

• Input Domain: VectorDomain<AtomDomain<T>>

• Output Domain: AtomDomain<T>

• Input Metric: SymmetricDistance

• Output Metric: AbsoluteDistance<T>

Parameters:

• size (int) – Number of records in input data.

• bounds (Tuple[Any, Any]) – Tuple of lower and upper bounds for data in the input domain.

• T (Type Argument) – Atomic Input Type and Output Type

Return type:

Transformation

Raises:

• TypeError – if an argument’s type differs from the expected type

• UnknownTypeError – if a type argument fails to parse

• OpenDPException – packaged error from the core OpenDP library

opendp.transformations.make_sized_bounded_int_monotonic_sum(size, bounds, T=None)

Make a Transformation that computes the sum of bounded ints, where all values share the same sign.

make_sized_bounded_int_monotonic_sum in Rust documentation.

Citations:

• CSVW22 Widespread Underestimation of Sensitivity…

• DMNS06 Calibrating Noise to Sensitivity in Private Data Analysis

Supporting Elements:

• Input Domain: VectorDomain<AtomDomain<T>>

• Output Domain: AtomDomain<T>

• Input Metric: SymmetricDistance

• Output Metric: AbsoluteDistance<T>

Parameters:

• size (int) – Number of records in input data.

• bounds (Tuple[Any, Any]) – Tuple of lower and upper bounds for data in the input domain.

• T (Type Argument) – Atomic Input Type and Output Type

Return type:

Transformation

Raises:

• TypeError – if an argument’s type differs from the expected type

• UnknownTypeError – if a type argument fails to parse

• OpenDPException – packaged error from the core OpenDP library

opendp.transformations.make_sized_bounded_int_ordered_sum(size, bounds, T=None)

Make a Transformation that computes the sum of bounded ints with known dataset size.

This uses a restricted-sensitivity proof that takes advantage of known dataset size for better utility. You may need to use make_ordered_random to impose an ordering on the data.

make_sized_bounded_int_ordered_sum in Rust documentation.

Citations:

• CSVW22 Widespread Underestimation of Sensitivity…

• DMNS06 Calibrating Noise to Sensitivity in Private Data Analysis

Supporting Elements:

• Input Domain: VectorDomain<AtomDomain<T>>

• Output Domain: AtomDomain<T>

• Input Metric: InsertDeleteDistance

• Output Metric: AbsoluteDistance<T>

Parameters:

• size (int) – Number of records in input data.

• bounds (Tuple[Any, Any]) – Tuple of lower and upper bounds for data in the input domain.

• T (Type Argument) – Atomic Input Type and Output Type

Return type:

Transformation

Raises:

• TypeError – if an argument’s type differs from the expected type

• UnknownTypeError – if a type argument fails to parse

• OpenDPException – packaged error from the core OpenDP library

opendp.transformations.make_sized_bounded_int_split_sum(size, bounds, T=None)

Make a Transformation that computes the sum of bounded ints with known dataset size.

This uses a restricted-sensitivity proof that takes advantage of known dataset size for better utility. Adds the saturating sum of the positives to the saturating sum of the negatives.

make_sized_bounded_int_split_sum in Rust documentation.

Citations:

• CSVW22 Widespread Underestimation of Sensitivity…

• DMNS06 Calibrating Noise to Sensitivity in Private Data Analysis

Supporting Elements:

• Input Domain: VectorDomain<AtomDomain<T>>

• Output Domain: AtomDomain<T>

• Input Metric: SymmetricDistance

• Output Metric: AbsoluteDistance<T>

Parameters:

• size (int) – Number of records in input data.

• bounds (Tuple[Any, Any]) – Tuple of lower and upper bounds for data in the input domain.

• T (Type Argument) – Atomic Input Type and Output Type

Return type:

Transformation

Raises:

• TypeError – if an argument’s type differs from the expected type

• UnknownTypeError – if a type argument fails to parse

• OpenDPException – packaged error from the core OpenDP library

opendp.transformations.make_split_dataframe(separator, col_names, K=None)

Make a Transformation that splits each record in a String into a Vec<Vec<String>>, and loads the resulting table into a dataframe keyed by col_names.

make_split_dataframe in Rust documentation.

Supporting Elements:

• Input Domain: AtomDomain<String>

• Output Domain: DataFrameDomain<K>

• Input Metric: SymmetricDistance

• Output Metric: SymmetricDistance

Parameters:

• separator (str) – The token(s) that separate entries in each record.

• col_names (Any) – Column names for each record entry.

• K (Type Argument) – categorical/hashable data type of column names

Return type:

Transformation

Raises:

• TypeError – if an argument’s type differs from the expected type

• UnknownTypeError – if a type argument fails to parse

• OpenDPException – packaged error from the core OpenDP library

opendp.transformations.make_split_lines()

Make a Transformation that takes a string and splits it into a Vec<String> of its lines.

make_split_lines in Rust documentation.

Supporting Elements:

• Input Domain: AtomDomain<String>

• Output Domain: VectorDomain<AtomDomain<String>>

• Input Metric: SymmetricDistance

• Output Metric: SymmetricDistance

Return type:

Transformation

Raises:

• TypeError – if an argument’s type differs from the expected type

• UnknownTypeError – if a type argument fails to parse

• OpenDPException – packaged error from the core OpenDP library

opendp.transformations.make_split_records(separator)

Make a Transformation that splits each record in a Vec<String> into a Vec<Vec<String>>.

make_split_records in Rust documentation.

Supporting Elements:

• Input Domain: VectorDomain<AtomDomain<String>>

• Output Domain: VectorDomain<VectorDomain<AtomDomain<String>>>

• Input Metric: SymmetricDistance

• Output Metric: SymmetricDistance

Parameters:

separator (str) – The token(s) that separate entries in each record.

Return type:

Transformation

Raises:

• TypeError – if an argument’s type differs from the expected type

• UnknownTypeError – if a type argument fails to parse

• OpenDPException – packaged error from the core OpenDP library

opendp.transformations.make_subset_by(indicator_column, keep_columns, TK=None)

Make a Transformation that subsets a dataframe by a boolean column.

make_subset_by in Rust documentation.

Supporting Elements:

• Input Domain: DataFrameDomain<TK>

• Output Domain: DataFrameDomain<TK>

• Input Metric: SymmetricDistance

• Output Metric: SymmetricDistance

Parameters:

• indicator_column (Any) – name of the boolean column that indicates inclusion in the subset

• keep_columns (Any) – list of column names to apply subset to

• TK (Type Argument) – Type of the column name

Return type:

Transformation

Raises:

• TypeError – if an argument’s type differs from the expected type

• UnknownTypeError – if a type argument fails to parse

• OpenDPException – packaged error from the core OpenDP library

opendp.transformations.make_sum(input_domain, input_metric)

Make a Transformation that computes the sum of bounded data. Use make_clamp to bound data.

If dataset size is known, uses a restricted-sensitivity proof that takes advantage of known dataset size for better utility.

make_sum in Rust documentation.

Citations:

• CSVW22 Widespread Underestimation of Sensitivity…

• DMNS06 Calibrating Noise to Sensitivity in Private Data Analysis

Supporting Elements:

• Input Domain: VectorDomain<AtomDomain<T>>

• Output Domain: AtomDomain<T>

• Input Metric: MI

• Output Metric: AbsoluteDistance<T>

Parameters:

• input_domain – Domain of the input data.

• input_metric – One of SymmetricDistance or InsertDeleteDistance.

Return type:

Transformation

Raises:

• TypeError – if an argument’s type differs from the expected type

• UnknownTypeError – if a type argument fails to parse

• OpenDPException – packaged error from the core OpenDP library

opendp.transformations.make_sum_of_squared_deviations(input_domain, input_metric, S='Pairwise<T>')

Make a Transformation that computes the sum of squared deviations of bounded data.

This uses a restricted-sensitivity proof that takes advantage of known dataset size. Use make_clamp to bound data and make_resize to establish dataset size.

S (summation algorithm)	input type
Sequential<S::Item>	Vec<S::Item>
Pairwise<S::Item>	Vec<S::Item>

S::Item is the type of all of the following: each bound, each element in the input data, the output data, and the output sensitivity.

For example, to construct a transformation that computes the SSD of f32 half-precision floats, set S to Pairwise<f32>.

make_sum_of_squared_deviations in Rust documentation.

Citations:

• CSVW22 Widespread Underestimation of Sensitivity…

• DMNS06 Calibrating Noise to Sensitivity in Private Data Analysis

Supporting Elements:

• Input Domain: VectorDomain<AtomDomain<S::Item>>

• Output Domain: AtomDomain<S::Item>

• Input Metric: SymmetricDistance

• Output Metric: AbsoluteDistance<S::Item>

Parameters:

• input_domain –

• input_metric –

• S (Type Argument) – Summation algorithm to use on data type T. One of Sequential<T> or Pairwise<T>.

Return type:

Transformation

Raises:

• TypeError – if an argument’s type differs from the expected type

• UnknownTypeError – if a type argument fails to parse

• OpenDPException – packaged error from the core OpenDP library

opendp.transformations.make_unordered(input_domain, input_metric)

Make a Transformation that converts the ordered dataset metric MI to the respective ordered dataset metric with a no-op.

MI	MI::UnorderedMetric
InsertDeleteDistance	SymmetricDistance
HammingDistance	ChangeOneDistance

make_unordered in Rust documentation.

Supporting Elements:

• Input Domain: D

• Output Domain: D

• Input Metric: MI

• Output Metric: MI::UnorderedMetric

Parameters:

• input_domain –

• input_metric –

Return type:

Transformation

Raises:

• TypeError – if an argument’s type differs from the expected type

• UnknownTypeError – if a type argument fails to parse

• OpenDPException – packaged error from the core OpenDP library

opendp.transformations.make_user_transformation(input_domain, input_metric, output_domain, output_metric, function, stability_map)

Construct a Transformation from user-defined callbacks.

make_user_transformation in Rust documentation.

Parameters:

• input_domain (Domain) – A domain describing the set of valid inputs for the function.

• input_metric (Metric) – The metric from which distances between adjacent inputs are measured.

• output_domain (Domain) – A domain describing the set of valid outputs of the function.

• output_metric (Metric) – The metric from which distances between outputs of adjacent inputs are measured.

• function – A function mapping data from input_domain to output_domain.

• stability_map – A function mapping distances from input_metric to output_metric.

Return type:

Transformation

Raises:

• TypeError – if an argument’s type differs from the expected type

• UnknownTypeError – if a type argument fails to parse

• OpenDPException – packaged error from the core OpenDP library

opendp.transformations.make_variance(input_domain, input_metric, ddof=1, S='Pairwise<T>')

Make a Transformation that computes the variance of bounded data.

This uses a restricted-sensitivity proof that takes advantage of known dataset size. Use make_clamp to bound data and make_resize to establish dataset size.

make_variance in Rust documentation.

Citations:

• DHK15 Differential Privacy for Social Science Inference

Supporting Elements:

• Input Domain: VectorDomain<AtomDomain<S::Item>>

• Output Domain: AtomDomain<S::Item>

• Input Metric: SymmetricDistance

• Output Metric: AbsoluteDistance<S::Item>

Parameters:

• input_domain –

• input_metric –

• ddof (int) – Delta degrees of freedom. Set to 0 if not a sample, 1 for sample estimate.

• S (Type Argument) – Summation algorithm to use on data type T. One of Sequential<T> or Pairwise<T>.

Return type:

Transformation

Raises:

• TypeError – if an argument’s type differs from the expected type

• UnknownTypeError – if a type argument fails to parse

• OpenDPException – packaged error from the core OpenDP library

opendp.transformations.then_b_ary_tree(leaf_count, branching_factor)

Parameters:

• leaf_count (int) –

• branching_factor (int) –

opendp.transformations.then_cast(TOA)

Parameters:

TOA (RuntimeType | str | Type[List | Tuple | int | float | str | bool] | tuple | _GenericAlias | GenericAlias) –

opendp.transformations.then_cast_default(TOA)

Parameters:

TOA (RuntimeType | str | Type[List | Tuple | int | float | str | bool] | tuple | _GenericAlias | GenericAlias) –

opendp.transformations.then_cast_inherent(TOA)

Parameters:

TOA (RuntimeType | str | Type[List | Tuple | int | float | str | bool] | tuple | _GenericAlias | GenericAlias) –

opendp.transformations.then_clamp(bounds)

Parameters:

bounds (Tuple[Any, Any]) –

opendp.transformations.then_count(TO='int')

Parameters:

TO (RuntimeType | str | Type[List | Tuple | int | float | str | bool] | tuple | _GenericAlias | GenericAlias) –

opendp.transformations.then_count_by(MO, TV='int')

Parameters:

• MO (SensitivityMetric) –

• TV (RuntimeType | str | Type[List | Tuple | int | float | str | bool] | tuple | _GenericAlias | GenericAlias) –

opendp.transformations.then_count_by_categories(categories, null_category=True, MO='L1Distance<int>', TOA='int')

Parameters:

• categories (Any) –

• null_category (bool) –

• MO (SensitivityMetric) –

• TOA (RuntimeType | str | Type[List | Tuple | int | float | str | bool] | tuple | _GenericAlias | GenericAlias) –

opendp.transformations.then_count_distinct(TO='int')

Parameters:

TO (RuntimeType | str | Type[List | Tuple | int | float | str | bool] | tuple | _GenericAlias | GenericAlias) –

opendp.transformations.then_df_cast_default(column_name, TIA, TOA)

Parameters:

• column_name (Any) –

• TIA (RuntimeType | str | Type[List | Tuple | int | float | str | bool] | tuple | _GenericAlias | GenericAlias) –

• TOA (RuntimeType | str | Type[List | Tuple | int | float | str | bool] | tuple | _GenericAlias | GenericAlias) –

opendp.transformations.then_df_is_equal(column_name, value, TIA=None)

Parameters:

• column_name (Any) –

• value (Any) –

• TIA (RuntimeType | str | Type[List | Tuple | int | float | str | bool] | tuple | _GenericAlias | GenericAlias | None) –

opendp.transformations.then_drop_null()

opendp.transformations.then_find(categories)

Parameters:

categories (Any) –

opendp.transformations.then_find_bin(edges)

Parameters:

edges (Any) –

opendp.transformations.then_identity()

opendp.transformations.then_impute_constant(constant)

Parameters:

constant (Any) –

opendp.transformations.then_impute_uniform_float(bounds)

Parameters:

bounds (Tuple[Any, Any]) –

opendp.transformations.then_index(categories, null, TOA=None)

Parameters:

• categories (Any) –

• null (Any) –

• TOA (RuntimeType | str | Type[List | Tuple | int | float | str | bool] | tuple | _GenericAlias | GenericAlias | None) –

opendp.transformations.then_is_equal(value)

Parameters:

value (Any) –

opendp.transformations.then_is_null()

opendp.transformations.then_mean()

opendp.transformations.then_metric_bounded()

opendp.transformations.then_metric_unbounded()

opendp.transformations.then_ordered_random()

opendp.transformations.then_resize(size, constant, MO='SymmetricDistance')

Parameters:

• size (int) –

• constant (Any) –

• MO (RuntimeType | str | Type[List | Tuple | int | float | str | bool] | tuple | _GenericAlias | GenericAlias) –

opendp.transformations.then_sum()

opendp.transformations.then_sum_of_squared_deviations(S='Pairwise<T>')

Parameters:

S (RuntimeType | str | Type[List | Tuple | int | float | str | bool] | tuple | _GenericAlias | GenericAlias) –

opendp.transformations.then_unordered()

opendp.transformations.then_variance(ddof=1, S='Pairwise<T>')

Parameters:

• ddof (int) –

• S (RuntimeType | str | Type[List | Tuple | int | float | str | bool] | tuple | _GenericAlias | GenericAlias) –