ImputationT Class

[SerializableAttribute]
public class Imputation<T> : BaseFilter<ImputationTOptions, Imputation<T>>, 
	IAutoConfigurableFilter, IFilter, ITransform<T[], T[]>, ICovariantTransform<T[], T[]>, 
	ITransform, IUnsupervisedLearning<Imputation<T>, T[], T[]>

<SerializableAttribute>
Public Class Imputation(Of T)
	Inherits BaseFilter(Of ImputationTOptions, Imputation(Of T))
	Implements IAutoConfigurableFilter, IFilter, ITransform(Of T(), T()), 
	ICovariantTransform(Of T(), T()), ITransform, IUnsupervisedLearning(Of Imputation(Of T), T(), T())

// Suppose we have the following double data containing missing values 
// (indicated by Double.NaN values). Let's say we would like to replace 
// those NaN values by inputing likely values at their original locations:

double[][] data =
{
    new[] { Double.NaN,        0.5,  0.2,               0.7 },
    new[] {        1.2,        6.2,  1.2,               4.2 },
    new[] {         10,        2.2, -1.1,        Double.NaN },
    new[] {         10, Double.NaN, -1.1,               1.0 },
    new[] {         10,        2.2,  Double.NaN,        1.0 },
};

// Let's create a new data imputation filter:
var imputation = new Imputation<double>();

// Let's instruct it to replace NaN values in the first
// column by their median, values in the second column
// by their average, values in the third column by a fixed 
// value and values in the last column by their mode:
imputation[0].Strategy = ImputationStrategy.Median;
imputation[1].Strategy = ImputationStrategy.Mean;
imputation[2].Strategy = ImputationStrategy.FixedValue;
imputation[2].ReplaceWith = 42;
imputation[3].Strategy = ImputationStrategy.Mode;

// Learn from the data:
imputation.Learn(data);

// Now, let's transform the input data using the 
// data imputation rules we just defined above:
double[][] result = imputation.Transform(data);

// The result should be:
// 
//   double[][] expected = new double[][]
//   {
//       new[] {   a, 0.5,  0.2, 0.7 },
//       new[] { 1.2, 6.2,  1.2, 4.2 },
//       new[] {  10, 2.2, -1.1,   d },
//       new[] {  10,   b, -1.1, 1.0 },
//       new[] {  10, 2.2,    c, 1.0 },
//   };