org.deidentifier.arx.metric.v2

## Class __MetricV2

- java.lang.Object
- - org.deidentifier.arx.metric.v2.__MetricV2

    public class __MetricV2
    extends java.lang.Object

This internal class provides access to version 2 of all metrics. Users of the API should use `org.deidentifier.arx.metric.Metric`for creating instances of metrics for information loss.``

Author:
  Fabian Prasser

### Constructor Summary

Constructors
Constructor and Description
`__MetricV2()`

### Method Summary

All Methods Static Methods Concrete Methods
`static Metric<ILSingleDimensional>` `createAECSMetric()` Creates a new instance of the AECS metric.
`static Metric<ILSingleDimensional>` `createAECSMetric(double gsFactor)` Creates a new instance of the AECS metric.
`static Metric<ILSingleDimensional>` `createAECSMetric(int rowCount)` Creates a new instance of the AECS metric.
`static Metric<ILSingleDimensional>` `createAmbiguityMetric()` Creates an instance of the ambiguity metric.
`static Metric<ILSingleDimensional>` `createClassificationMetric()` Creates an instance of the classification metric.
`static Metric<ILSingleDimensional>` `createClassificationMetric(double gsFactor)` Creates an instance of the classification metric.
`static Metric<ILSingleDimensional>` `createDiscernabilityMetric()` Creates an instance of the discernability metric.
`static Metric<ILSingleDimensional>` `createDiscernabilityMetric(boolean monotonic)` Creates an instance of the discernability metric.
`static Metric<ILSingleDimensional>` `createDiscernabilityMetric(boolean monotonic, double numTuples)` Creates an instance of the discernability metric.
`static MetricSDNMEntropyBasedInformationLoss` `createEntropyBasedInformationLossMetric(double gsFactor)` Creates an instance of the entropy-based information loss metric.
`static Metric<AbstractILMultiDimensional>` `createEntropyMetric()` Creates an instance of the non-monotonic non-uniform entropy metric.
`static Metric<AbstractILMultiDimensional>` `createEntropyMetric(boolean monotonic)` Creates an instance of the non-uniform entropy metric.
`static Metric<AbstractILMultiDimensional>` `createEntropyMetric(boolean monotonic, double gsFactor)` Creates an instance of the non-uniform entropy metric.
`static Metric<AbstractILMultiDimensional>` `createEntropyMetric(boolean monotonic, double[][] cache, int[][][] cardinalities, int[][][] hierarchies)` Creates an instance of the non-uniform entropy metric.
`static Metric<AbstractILMultiDimensional>` `createEntropyMetric(boolean monotonic, double gsFactor, Metric.AggregateFunction function)` Creates an instance of the non-uniform entropy metric.
`static Metric<AbstractILMultiDimensional>` `createEntropyMetric(boolean monotonic, Metric.AggregateFunction function)` Creates an instance of the non-uniform entropy metric.
`static Metric<AbstractILMultiDimensional>` `createEntropyMetric(double gsFactor)` Creates an instance of the non-monotonic non-uniform entropy metric.
`static Metric<AbstractILMultiDimensional>` `createHeightMetric()` Creates an instance of the height metric.
`static Metric<AbstractILMultiDimensional>` `createHeightMetric(int minHeight, int maxHeight)` Creates an instance of the height metric.
`static Metric<AbstractILMultiDimensional>` `createHeightMetric(Metric.AggregateFunction function)` Creates an instance of the height metric.
`static InformationLoss<?>` `createILMultiDimensionalArithmeticMean(double value)` Helper method.
`static InformationLoss<?>` `createILMultiDimensionalSum(double value)` Helper method.
`static InformationLoss<?>` `createILSingleDimensional(double value)` Helper method.
`static Metric<ILSingleDimensional>` `createKLDivergenceMetric()` Creates an instance of the KL Divergence metric.
`static Metric<AbstractILMultiDimensional>` `createLossMetric()` Creates an instance of the loss metric which treats generalization and suppression equally.
`static Metric<AbstractILMultiDimensional>` `createLossMetric(double gsFactor)` Creates an instance of the loss metric with factors for weighting generalization and suppression.
`static Metric<AbstractILMultiDimensional>` `createLossMetric(double gsFactor, Metric.AggregateFunction function)` Creates an instance of the loss metric with factors for weighting generalization and suppression.
`static Metric<AbstractILMultiDimensional>` `createLossMetric(Metric.AggregateFunction function)` Creates an instance of the loss metric which treats generalization and suppression equally.
`static Metric<AbstractILMultiDimensional>` `createNormalizedEntropyMetric()` Creates an instance of the normalized entropy metric.
`static Metric<AbstractILMultiDimensional>` `createNormalizedEntropyMetric(Metric.AggregateFunction function)` Creates an instance of the normalized entropy metric.
`static Metric<AbstractILMultiDimensional>` `createPrecisionMetric()` Creates an instance of the non-monotonic precision metric.
`static Metric<AbstractILMultiDimensional>` `createPrecisionMetric(boolean monotonic)` Creates an instance of the precision metric.
`static Metric<AbstractILMultiDimensional>` `createPrecisionMetric(boolean monotonic, double gsFactor)` Creates an instance of the precision metric.
`static Metric<AbstractILMultiDimensional>` `createPrecisionMetric(boolean monotonic, double gsFactor, Metric.AggregateFunction function)` Creates an instance of the precision metric.
`static Metric<AbstractILMultiDimensional>` `createPrecisionMetric(boolean monotonic, int[] heights, double cells)` Creates an instance of the precision metric.
`static Metric<AbstractILMultiDimensional>` `createPrecisionMetric(boolean monotonic, Metric.AggregateFunction function)` Creates an instance of the precision metric.
`static Metric<AbstractILMultiDimensional>` `createPrecisionMetric(double gsFactor)` Creates an instance of the non-monotonic precision metric.
`static Metric<AbstractILMultiDimensional>` `createPrecisionMetric(double gsFactor, Metric.AggregateFunction function)` Creates an instance of the non-monotonic precision metric.
`static Metric<AbstractILMultiDimensional>` `createPrecisionMetric(Metric.AggregateFunction function)` Creates an instance of the non-monotonic precision metric.
`static Metric<AbstractILMultiDimensional>` `createPrecomputedEntropyMetric(double threshold)` Creates a potentially precomputed instance of the non-monotonic non-uniform entropy metric.
`static Metric<AbstractILMultiDimensional>` `createPrecomputedEntropyMetric(double threshold, boolean monotonic)` Creates a potentially precomputed instance of the non-uniform entropy metric.
`static Metric<AbstractILMultiDimensional>` `createPrecomputedEntropyMetric(double threshold, boolean monotonic, double gsFactor)` Creates a potentially precomputed instance of the non-uniform entropy metric.
`static Metric<AbstractILMultiDimensional>` `createPrecomputedEntropyMetric(double threshold, boolean monotonic, double gsFactor, Metric.AggregateFunction function)` Creates a potentially precomputed instance of the non-uniform entropy metric.
`static Metric<AbstractILMultiDimensional>` `createPrecomputedEntropyMetric(double threshold, boolean monotonic, Metric.AggregateFunction function)` Creates a potentially precomputed instance of the non-uniform entropy metric.
`static Metric<AbstractILMultiDimensional>` `createPrecomputedEntropyMetric(double threshold, double gsFactor)` Creates a potentially precomputed instance of the non-monotonic non-uniform entropy metric.
`static Metric<AbstractILMultiDimensional>` `createPrecomputedLossMetric(double threshold)` Creates a potentially precomputed instance of the loss metric which treats generalization and suppression equally.
`static Metric<AbstractILMultiDimensional>` `createPrecomputedLossMetric(double threshold, double gsFactor)` Creates a potentially precomputed instance of the loss metric with factors for weighting generalization and suppression.
`static Metric<AbstractILMultiDimensional>` `createPrecomputedLossMetric(double threshold, double gsFactor, Metric.AggregateFunction function)` Creates a potentially precomputed instance of the loss metric with factors for weighting generalization and suppression.
`static Metric<AbstractILMultiDimensional>` `createPrecomputedLossMetric(double threshold, Metric.AggregateFunction function)` Creates a potentially precomputed instance of the loss metric which treats generalization and suppression equally.
`static Metric<AbstractILMultiDimensional>` `createPrecomputedNormalizedEntropyMetric(double threshold)` Creates a potentially precomputed instance of the normalized entropy metric.
`static Metric<AbstractILMultiDimensional>` `createPrecomputedNormalizedEntropyMetric(double threshold, Metric.AggregateFunction function)` Creates a potentially precomputed instance of the normalized entropy metric.
`static MetricSDNMPublisherPayout` `createPublisherBenefitMetric(boolean journalistAttackerModel, double gsFactor)` Creates an instance of the model for maximizing publisher benefit in the game-theoretic privacy model based on a cost/benefit analysis.
`static Metric<AbstractILMultiDimensional>` `createStaticMetric(java.util.Map<java.lang.String,java.util.List<java.lang.Double>> loss)` Creates an instance of a metric with statically defined information loss.
`static Metric<AbstractILMultiDimensional>` `createStaticMetric(java.util.Map<java.lang.String,java.util.List<java.lang.Double>> loss, Metric.AggregateFunction function)` Creates an instance of a metric with statically defined information loss.

### Methods inherited from class java.lang.Object

`equals, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`

### Constructor Detail

#### __MetricV2

    public __MetricV2()

### Method Detail

#### createAECSMetric

    public static Metric<ILSingleDimensional> createAECSMetric()

Creates a new instance of the AECS metric.

Returns:

#### createAECSMetric

    public static Metric<ILSingleDimensional> createAECSMetric(double gsFactor)

Creates a new instance of the AECS metric.

Parameters:
  `gsFactor` - A factor [0,1] weighting generalization and suppression. The default value is 0.5, which means that generalization and suppression will be treated equally. A factor of 0 will favor suppression, and a factor of 1 will favor generalization. The values in between can be used for balancing both methods.
Returns:

#### createAECSMetric

    public static Metric<ILSingleDimensional> createAECSMetric(int rowCount)

Creates a new instance of the AECS metric.

Parameters:
  `rowCount` -
Returns:

#### createAmbiguityMetric

    public static Metric<ILSingleDimensional> createAmbiguityMetric()

Creates an instance of the ambiguity metric.

Returns:

#### createClassificationMetric

    public static Metric<ILSingleDimensional> createClassificationMetric(double gsFactor)

Creates an instance of the classification metric.

Parameters:
  `gsFactor` -
Returns:

#### createClassificationMetric

    public static Metric<ILSingleDimensional> createClassificationMetric()

Creates an instance of the classification metric.

Returns:

#### createDiscernabilityMetric

    public static Metric<ILSingleDimensional> createDiscernabilityMetric()

Creates an instance of the discernability metric.

Returns:

#### createDiscernabilityMetric

    public static Metric<ILSingleDimensional> createDiscernabilityMetric(boolean monotonic)

Creates an instance of the discernability metric. The monotonic variant is DM*.

Parameters:
  `monotonic` - If set to true, the monotonic variant (DM*) will be created
Returns:

#### createDiscernabilityMetric

    public static Metric<ILSingleDimensional> createDiscernabilityMetric(boolean monotonic,
                                                                         double numTuples)

Creates an instance of the discernability metric. The monotonic variant is DM*.

Parameters:
  `monotonic` - If set to true, the monotonic variant (DM*) will be created
  `numTuples` - Pre-initialization
Returns:

#### createEntropyBasedInformationLossMetric

    public static MetricSDNMEntropyBasedInformationLoss createEntropyBasedInformationLossMetric(double gsFactor)

Creates an instance of the entropy-based information loss metric.

Parameters:
  `gsFactor` - A factor [0,1] weighting generalization and suppression. The default value is 0.5, which means that generalization and suppression will be treated equally. A factor of 0 will favor suppression, and a factor of 1 will favor generalization. The values in between can be used for balancing both methods.
Returns:

#### createEntropyMetric

    public static Metric<AbstractILMultiDimensional> createEntropyMetric()

Creates an instance of the non-monotonic non-uniform entropy metric. The default aggregate function, which is the sum-function, will be used for comparing results. This metric will respect attribute weights defined in the configuration.

Returns:

#### createEntropyMetric

    public static Metric<AbstractILMultiDimensional> createEntropyMetric(boolean monotonic)

Creates an instance of the non-uniform entropy metric. The default aggregate function, which is the sum-function, will be used for comparing results. This metric will respect attribute weights defined in the configuration.

Parameters:
  `monotonic` - If set to true, the monotonic variant of the metric will be created
Returns:

#### createEntropyMetric

    public static Metric<AbstractILMultiDimensional> createEntropyMetric(boolean monotonic,
                                                                         Metric.AggregateFunction function)

Creates an instance of the non-uniform entropy metric. This metric will respect attribute weights defined in the configuration.

Parameters:
  `monotonic` - If set to true, the monotonic variant of the metric will be created
  `function` - The aggregate function to be used for comparing results
Returns:

#### createEntropyMetric

    public static Metric<AbstractILMultiDimensional> createEntropyMetric(boolean monotonic,
                                                                         double gsFactor)

Creates an instance of the non-uniform entropy metric. The default aggregate function, which is the sum-function, will be used for comparing results. This metric will respect attribute weights defined in the configuration.

Parameters:
  `monotonic` - If set to true, the monotonic variant of the metric will be created
  `gsFactor` - A factor [0,1] weighting generalization and suppression. The default value is 0.5, which means that generalization and suppression will be treated equally. A factor of 0 will favor suppression, and a factor of 1 will favor generalization. The values in between can be used for balancing both methods.
Returns:

#### createEntropyMetric

    public static Metric<AbstractILMultiDimensional> createEntropyMetric(boolean monotonic,
                                                                         double gsFactor,
                                                                         Metric.AggregateFunction function)

Creates an instance of the non-uniform entropy metric. This metric will respect attribute weights defined in the configuration.

Parameters:
  `monotonic` - If set to true, the monotonic variant of the metric will be created
  `gsFactor` - A factor [0,1] weighting generalization and suppression. The default value is 0.5, which means that generalization and suppression will be treated equally. A factor of 0 will favor suppression, and a factor of 1 will favor generalization. The values in between can be used for balancing both methods.
  `function` - The aggregate function to be used for comparing results
Returns:

#### createEntropyMetric

    public static Metric<AbstractILMultiDimensional> createEntropyMetric(boolean monotonic,
                                                                         double[][] cache,
                                                                         int[][][] cardinalities,
                                                                         int[][][] hierarchies)

Creates an instance of the non-uniform entropy metric. The default aggregate function, which is the sum-function, will be used for comparing results. This metric will respect attribute weights defined in the configuration.

Parameters:
  `monotonic` - If set to true, the monotonic variant of the metric will be created
  `cache` -
  `cardinalities` -
  `hierarchies` -
Returns:

#### createEntropyMetric

    public static Metric<AbstractILMultiDimensional> createEntropyMetric(double gsFactor)

Creates an instance of the non-monotonic non-uniform entropy metric. The default aggregate function, which is the sum-function, will be used for comparing results. This metric will respect attribute weights defined in the configuration.

Parameters:
  `gsFactor` - A factor [0,1] weighting generalization and suppression. The default value is 0.5, which means that generalization and suppression will be treated equally. A factor of 0 will favor suppression, and a factor of 1 will favor generalization. The values in between can be used for balancing both methods.
Returns:

#### createHeightMetric

    public static Metric<AbstractILMultiDimensional> createHeightMetric()

Creates an instance of the height metric. The default aggregate function, which is the sum-function, will be used for comparing results. This metric will respect attribute weights defined in the configuration.

Returns:

#### createHeightMetric

    public static Metric<AbstractILMultiDimensional> createHeightMetric(Metric.AggregateFunction function)

Creates an instance of the height metric. This metric will respect attribute weights defined in the configuration.

Parameters:
  `function` - The aggregate function to use for comparing results
Returns:

#### createHeightMetric

    public static Metric<AbstractILMultiDimensional> createHeightMetric(int minHeight,
                                                                        int maxHeight)

Creates an instance of the height metric. The default aggregate function, which is the sum-function, will be used for comparing results. This metric will respect attribute weights defined in the configuration.

Parameters:
  `minHeight` -
  `maxHeight` -
Returns:

#### createILMultiDimensionalArithmeticMean

    public static InformationLoss<?> createILMultiDimensionalArithmeticMean(double value)

Helper method. Normally, there should be no need to call this

Parameters:
  `value` -
Returns:

#### createILMultiDimensionalSum

    public static InformationLoss<?> createILMultiDimensionalSum(double value)

Helper method. Normally, there should be no need to call this

Parameters:
  `value` -
Returns:

#### createILSingleDimensional

    public static InformationLoss<?> createILSingleDimensional(double value)

Helper method. Normally, there should be no need to call this

Parameters:
  `value` -
Returns:

#### createKLDivergenceMetric

    public static Metric<ILSingleDimensional> createKLDivergenceMetric()

Creates an instance of the KL Divergence metric.

Returns:

#### createLossMetric

    public static Metric<AbstractILMultiDimensional> createLossMetric()

Creates an instance of the loss metric which treats generalization and suppression equally. The default aggregate function, which is the geometric mean, will be used. This metric will respect attribute weights defined in the configuration.

Returns:

#### createLossMetric

    public static Metric<AbstractILMultiDimensional> createLossMetric(Metric.AggregateFunction function)

Creates an instance of the loss metric which treats generalization and suppression equally. This metric will respect attribute weights defined in the configuration.

Parameters:
  `function` - The aggregate function to use for comparing results
Returns:

#### createLossMetric

    public static Metric<AbstractILMultiDimensional> createLossMetric(double gsFactor)

Creates an instance of the loss metric with factors for weighting generalization and suppression. The default aggregate function, which is the geometric mean, will be used. This metric will respect attribute weights defined in the configuration.

Parameters:
  `gsFactor` - A factor [0,1] weighting generalization and suppression. The default value is 0.5, which means that generalization and suppression will be treated equally. A factor of 0 will favor suppression, and a factor of 1 will favor generalization. The values in between can be used for balancing both methods.
Returns:

#### createLossMetric

    public static Metric<AbstractILMultiDimensional> createLossMetric(double gsFactor,
                                                                      Metric.AggregateFunction function)

Creates an instance of the loss metric with factors for weighting generalization and suppression. This metric will respect attribute weights defined in the configuration.

Parameters:
  `gsFactor` - A factor [0,1] weighting generalization and suppression. The default value is 0.5, which means that generalization and suppression will be treated equally. A factor of 0 will favor suppression, and a factor of 1 will favor generalization. The values in between can be used for balancing both methods.
  `function` - The aggregate function to use for comparing results
Returns:

#### createNormalizedEntropyMetric

    public static Metric<AbstractILMultiDimensional> createNormalizedEntropyMetric()

Creates an instance of the normalized entropy metric. The default aggregate function, which is the sum function, will be used. This metric will respect attribute weights defined in the configuration.

Returns:

#### createNormalizedEntropyMetric

    public static Metric<AbstractILMultiDimensional> createNormalizedEntropyMetric(Metric.AggregateFunction function)

Creates an instance of the normalized entropy metric. This metric will respect attribute weights defined in the configuration.

Parameters:
  `function` - The aggregate function to use for comparing results
Returns:

#### createPrecisionMetric

    public static Metric<AbstractILMultiDimensional> createPrecisionMetric()

Creates an instance of the non-monotonic precision metric. The default aggregate function, which is the arithmetic mean, will be used. This metric will respect attribute weights defined in the configuration.

Returns:

#### createPrecisionMetric

    public static Metric<AbstractILMultiDimensional> createPrecisionMetric(Metric.AggregateFunction function)

Creates an instance of the non-monotonic precision metric. This metric will respect attribute weights defined in the configuration.

Parameters:
  `function` - The aggregate function to use for comparing results
Returns:

#### createPrecisionMetric

    public static Metric<AbstractILMultiDimensional> createPrecisionMetric(boolean monotonic)

Creates an instance of the precision metric. The default aggregate function, which is the arithmetic mean, will be used. This metric will respect attribute weights defined in the configuration.

Parameters:
  `monotonic` - If set to true, the monotonic variant of the metric will be created
Returns:

#### createPrecisionMetric

    public static Metric<AbstractILMultiDimensional> createPrecisionMetric(boolean monotonic,
                                                                           Metric.AggregateFunction function)

Creates an instance of the precision metric. This metric will respect attribute weights defined in the configuration.

Parameters:
  `monotonic` - If set to true, the monotonic variant of the metric will be created
  `function` -
Returns:

#### createPrecisionMetric

    public static Metric<AbstractILMultiDimensional> createPrecisionMetric(boolean monotonic,
                                                                           double gsFactor)

Creates an instance of the precision metric. The default aggregate function, which is the arithmetic mean, will be used. This metric will respect attribute weights defined in the configuration.

Parameters:
  `monotonic` - If set to true, the monotonic variant of the metric will be created
  `gsFactor` - A factor [0,1] weighting generalization and suppression. The default value is 0.5, which means that generalization and suppression will be treated equally. A factor of 0 will favor suppression, and a factor of 1 will favor generalization. The values in between can be used for balancing both methods.
Returns:

#### createPrecisionMetric

    public static Metric<AbstractILMultiDimensional> createPrecisionMetric(boolean monotonic,
                                                                           double gsFactor,
                                                                           Metric.AggregateFunction function)

Creates an instance of the precision metric. This metric will respect attribute weights defined in the configuration.

Parameters:
  `monotonic` - If set to true, the monotonic variant of the metric will be created
  `gsFactor` - A factor [0,1] weighting generalization and suppression. The default value is 0.5, which means that generalization and suppression will be treated equally. A factor of 0 will favor suppression, and a factor of 1 will favor generalization. The values in between can be used for balancing both methods.
  `function` -
Returns:

#### createPrecisionMetric

    public static Metric<AbstractILMultiDimensional> createPrecisionMetric(boolean monotonic,
                                                                           int[] heights,
                                                                           double cells)

Creates an instance of the precision metric. The default aggregate function, which is the arithmetic mean, will be used. This metric will respect attribute weights defined in the configuration.

Parameters:
  `monotonic` - If set to true, the monotonic variant of the metric will be created
  `heights` -
  `cells` -
Returns:

#### createPrecisionMetric

    public static Metric<AbstractILMultiDimensional> createPrecisionMetric(double gsFactor)

Creates an instance of the non-monotonic precision metric. The default aggregate function, which is the arithmetic mean, will be used. This metric will respect attribute weights defined in the configuration.

Parameters:
  `gsFactor` - A factor [0,1] weighting generalization and suppression. The default value is 0.5, which means that generalization and suppression will be treated equally. A factor of 0 will favor suppression, and a factor of 1 will favor generalization. The values in between can be used for balancing both methods.
Returns:

#### createPrecisionMetric

    public static Metric<AbstractILMultiDimensional> createPrecisionMetric(double gsFactor,
                                                                           Metric.AggregateFunction function)

Creates an instance of the non-monotonic precision metric. This metric will respect attribute weights defined in the configuration.

Parameters:
  `gsFactor` - A factor [0,1] weighting generalization and suppression. The default value is 0.5, which means that generalization and suppression will be treated equally. A factor of 0 will favor suppression, and a factor of 1 will favor generalization. The values in between can be used for balancing both methods.
  `function` - The aggregate function to use for comparing results
Returns:

#### createPrecomputedEntropyMetric

    public static Metric<AbstractILMultiDimensional> createPrecomputedEntropyMetric(double threshold)

Creates a potentially precomputed instance of the non-monotonic non-uniform entropy metric. The default aggregate function, which is the sum-function, will be used for comparing results. This metric will respect attribute weights defined in the configuration.

Parameters:
  `threshold` - The precomputed variant of the metric will be used if #distinctValues / #rows <= threshold for all quasi-identifiers.
Returns:

#### createPrecomputedEntropyMetric

    public static Metric<AbstractILMultiDimensional> createPrecomputedEntropyMetric(double threshold,
                                                                                    boolean monotonic)

Creates a potentially precomputed instance of the non-uniform entropy metric. The default aggregate function, which is the sum-function, will be used for comparing results. This metric will respect attribute weights defined in the configuration.

Parameters:
  `threshold` - The precomputed variant of the metric will be used if #distinctValues / #rows <= threshold for all quasi-identifiers.
  `monotonic` - If set to true, the monotonic variant of the metric will be created
Returns:

#### createPrecomputedEntropyMetric

    public static Metric<AbstractILMultiDimensional> createPrecomputedEntropyMetric(double threshold,
                                                                                    boolean monotonic,
                                                                                    Metric.AggregateFunction function)

Creates a potentially precomputed instance of the non-uniform entropy metric. This metric will respect attribute weights defined in the configuration.

Parameters:
  `threshold` - The precomputed variant of the metric will be used if #distinctValues / #rows <= threshold for all quasi-identifiers.
  `monotonic` - If set to true, the monotonic variant of the metric will be created
  `function` - The aggregate function to be used for comparing results
Returns:

#### createPrecomputedEntropyMetric

    public static Metric<AbstractILMultiDimensional> createPrecomputedEntropyMetric(double threshold,
                                                                                    boolean monotonic,
                                                                                    double gsFactor)

Creates a potentially precomputed instance of the non-uniform entropy metric. The default aggregate function, which is the sum-function, will be used for comparing results. This metric will respect attribute weights defined in the configuration.

Parameters:
  `threshold` - The precomputed variant of the metric will be used if #distinctValues / #rows <= threshold for all quasi-identifiers.
  `monotonic` - If set to true, the monotonic variant of the metric will be created
  `gsFactor` - A factor [0,1] weighting generalization and suppression. The default value is 0.5, which means that generalization and suppression will be treated equally. A factor of 0 will favor suppression, and a factor of 1 will favor generalization. The values in between can be used for balancing both methods.
Returns:

#### createPrecomputedEntropyMetric

    public static Metric<AbstractILMultiDimensional> createPrecomputedEntropyMetric(double threshold,
                                                                                    boolean monotonic,
                                                                                    double gsFactor,
                                                                                    Metric.AggregateFunction function)

Creates a potentially precomputed instance of the non-uniform entropy metric. This metric will respect attribute weights defined in the configuration.

Parameters:
  `threshold` - The precomputed variant of the metric will be used if #distinctValues / #rows <= threshold for all quasi-identifiers.
  `monotonic` - If set to true, the monotonic variant of the metric will be created
  `gsFactor` - A factor [0,1] weighting generalization and suppression. The default value is 0.5, which means that generalization and suppression will be treated equally. A factor of 0 will favor suppression, and a factor of 1 will favor generalization. The values in between can be used for balancing both methods.
  `function` - The aggregate function to be used for comparing results
Returns:

#### createPrecomputedEntropyMetric

    public static Metric<AbstractILMultiDimensional> createPrecomputedEntropyMetric(double threshold,
                                                                                    double gsFactor)

Creates a potentially precomputed instance of the non-monotonic non-uniform entropy metric. The default aggregate function, which is the sum-function, will be used for comparing results. This metric will respect attribute weights defined in the configuration.

Parameters:
  `threshold` - The precomputed variant of the metric will be used if #distinctValues / #rows <= threshold for all quasi-identifiers.
  `gsFactor` - A factor [0,1] weighting generalization and suppression. The default value is 0.5, which means that generalization and suppression will be treated equally. A factor of 0 will favor suppression, and a factor of 1 will favor generalization. The values in between can be used for balancing both methods.
Returns:

#### createPrecomputedLossMetric

    public static Metric<AbstractILMultiDimensional> createPrecomputedLossMetric(double threshold)

Creates a potentially precomputed instance of the loss metric which treats generalization and suppression equally. The default aggregate function, which is the geometric mean, will be used. This metric will respect attribute weights defined in the configuration.

Parameters:
  `threshold` - The precomputed variant of the metric will be used if #distinctValues / #rows <= threshold for all quasi-identifiers.
Returns:

#### createPrecomputedLossMetric

    public static Metric<AbstractILMultiDimensional> createPrecomputedLossMetric(double threshold,
                                                                                 Metric.AggregateFunction function)

Creates a potentially precomputed instance of the loss metric which treats generalization and suppression equally. This metric will respect attribute weights defined in the configuration.

Parameters:
  `threshold` - The precomputed variant of the metric will be used if #distinctValues / #rows <= threshold for all quasi-identifiers.
  `function` - The aggregate function to use for comparing results
Returns:

#### createPrecomputedLossMetric

    public static Metric<AbstractILMultiDimensional> createPrecomputedLossMetric(double threshold,
                                                                                 double gsFactor)

Creates a potentially precomputed instance of the loss metric with factors for weighting generalization and suppression. The default aggregate function, which is the gemetric mean, will be used. This metric will respect attribute weights defined in the configuration.

Parameters:
  `threshold` - The precomputed variant of the metric will be used if #distinctValues / #rows <= threshold for all quasi-identifiers.
  `gsFactor` - A factor [0,1] weighting generalization and suppression. The default value is 0.5, which means that generalization and suppression will be treated equally. A factor of 0 will favor suppression, and a factor of 1 will favor generalization. The values in between can be used for balancing both methods.
Returns:

#### createPrecomputedLossMetric

    public static Metric<AbstractILMultiDimensional> createPrecomputedLossMetric(double threshold,
                                                                                 double gsFactor,
                                                                                 Metric.AggregateFunction function)

Creates a potentially precomputed instance of the loss metric with factors for weighting generalization and suppression. This metric will respect attribute weights defined in the configuration.

Parameters:
  `threshold` - The precomputed variant of the metric will be used if #distinctValues / #rows <= threshold for all quasi-identifiers.
  `gsFactor` - A factor [0,1] weighting generalization and suppression. The default value is 0.5, which means that generalization and suppression will be treated equally. A factor of 0 will favor suppression, and a factor of 1 will favor generalization. The values in between can be used for balancing both methods.
  `function` - The aggregate function to use for comparing results
Returns:

#### createPrecomputedNormalizedEntropyMetric

    public static Metric<AbstractILMultiDimensional> createPrecomputedNormalizedEntropyMetric(double threshold)

Creates a potentially precomputed instance of the normalized entropy metric. The default aggregate function, which is the sum function, will be used. This metric will respect attribute weights defined in the configuration.

Parameters:
  `threshold` - The precomputed variant of the metric will be used if #distinctValues / #rows <= threshold for all quasi-identifiers.
Returns:

#### createPrecomputedNormalizedEntropyMetric

    public static Metric<AbstractILMultiDimensional> createPrecomputedNormalizedEntropyMetric(double threshold,
                                                                                              Metric.AggregateFunction function)

Creates a potentially precomputed instance of the normalized entropy metric. This metric will respect attribute weights defined in the configuration.

Parameters:
  `threshold` - The precomputed variant of the metric will be used if #distinctValues / #rows <= threshold for all quasi-identifiers.
  `function` - The aggregate function to use for comparing results
Returns:

#### createPublisherBenefitMetric

    public static MetricSDNMPublisherPayout createPublisherBenefitMetric(boolean journalistAttackerModel,
                                                                         double gsFactor)

Creates an instance of the model for maximizing publisher benefit in the game-theoretic privacy model based on a cost/benefit analysis.

Parameters:
  `journalistAttackerModel` - If set to true, the journalist attacker model will be assumed, the prosecutor model will be assumed, otherwise
  `gsFactor` - A factor [0,1] weighting generalization and suppression. The default value is 0.5, which means that generalization and suppression will be treated equally. A factor of 0 will favor suppression, and a factor of 1 will favor generalization. The values in between can be used for balancing both methods.
Returns:

#### createStaticMetric

    public static Metric<AbstractILMultiDimensional> createStaticMetric(java.util.Map<java.lang.String,java.util.List<java.lang.Double>> loss)

Creates an instance of a metric with statically defined information loss. The default aggregate function, which is the sum-function, will be used for comparing results. This metric will respect attribute weights defined in the configuration.

Parameters:
  `loss` - User defined information loss per attribute
Returns:

#### createStaticMetric

    public static Metric<AbstractILMultiDimensional> createStaticMetric(java.util.Map<java.lang.String,java.util.List<java.lang.Double>> loss,
                                                                        Metric.AggregateFunction function)

Creates an instance of a metric with statically defined information loss. This metric will respect attribute weights defined in the configuration.

Parameters:
  `loss` - User defined information loss per attribute
  `function` - The aggregate function to use for comparing results
Returns: