/// <summary>
/// Normalize a single column to the input vector.
/// </summary>
/// <param name="colDef">The column to normalize.</param>
/// <param name="outputColumn">The current position in the vector.</param>
/// <param name="output">The vector to output to.</param>
/// <param name="isInput">Is this an input column.</param>
/// <param name="value">The value to normalize.</param>
/// <returns>The new current position in the vector.</returns>
public int NormalizeToVector(ColumnDefinition colDef, int outputColumn,
double[] output, bool isInput, String value)
{
IMissingHandler handler = null;
if (_unknownValues.Contains(value))
{
if (!_missingHandlers.ContainsKey(colDef))
{
throw new EncogError(
"Do not know how to process missing value \"" + value
+ "\" in field: " + colDef.Name);
}
handler = _missingHandlers[colDef];
}
if (colDef.DataType == ColumnType.Continuous)
{
double d = ParseDouble(value);
if (handler != null)
{
d = handler.ProcessDouble(colDef);
}
return(NormStrategy.NormalizeColumn(colDef, isInput, d,
output, outputColumn));
}
if (handler != null)
{
value = handler.ProcessString(colDef);
}
return(NormStrategy.NormalizeColumn(colDef, isInput, value,
output, outputColumn));
}
/// <summary>
/// Normalize a single output column.
/// </summary>
/// <param name="i">The column definition index (from the output columns).</param>
/// <param name="value">The value to normalize.</param>
/// <returns>The normalized result.</returns>
public double[] NormalizeOutputColumn(int i, string value)
{
ColumnDefinition colDef = _outputColumns[i];
var result = new double[NormStrategy.NormalizedSize(colDef,
false)];
NormStrategy.NormalizeColumn(colDef, false, value, result, 0);
return(result);
}
/// <summary>
/// Denormalize a complete output vector to an array of strings.
/// </summary>
/// <param name="output">The data vector to denorm, the source.</param>
/// <returns>The denormalized vector.</returns>
public String[] DenormalizeOutputVectorToString(IMLData output)
{
var result = new String[_outputColumns.Count];
int idx = 0;
for (int i = 0; i < _outputColumns.Count; i++)
{
ColumnDefinition colDef = _outputColumns[i];
result[i] = NormStrategy.DenormalizeColumn(colDef, false,
output, idx);
idx += NormStrategy.NormalizedSize(colDef, false);
}
return(result);
}
/// <summary>
/// Calculate the number of elements the output will normalize to.
/// </summary>
/// <returns>The number of elements the output will normalize to.</returns>
public int CalculateNormalizedOutputCount()
{
return(_outputColumns.Sum(colDef => NormStrategy.NormalizedSize(colDef, false)));
}
/// <summary>
/// Calculate the number of elements the input will normalize to.
/// </summary>
/// <returns>The number of elements the input will normalize to.</returns>
public int CalculateNormalizedInputCount()
{
return(_inputColumns.Sum(colDef => NormStrategy.NormalizedSize(colDef, true)));
}
